RUNY started because ChatGPT was useful for my ADHD.
I could hand it the giant pile of thoughts in my head before I had figured out how they connected. I didn’t have to keep every piece suspended in working memory while I figured out the structure. I could just start writing.
That was a pretty big deal for me.
Then I used it enough for the cracks to become obvious.
A chat would get too long. Something important would be buried five conversations ago. I’d switch models and suddenly have to explain the entire fucking project again.
I could save pieces of information.
The working context kept disappearing anyway.
So I started trying to preserve it.
At first I thought the answer was better memory.
Save the important stuff. Make it searchable. Carry it into the next conversation.
That helped.
Then I realized the harder part was preserving the way I worked.
The Problem Under the Problem
Once I started thinking about how I worked, I realized how much of my day was held together by little strategies I’d invented for myself.
I already knew a lot about what helped me think clearly. The problem was having access to that knowledge at the moment I actually needed it.
I generate ideas faster than I can organize them, so unfinished threads disappear easily. I forget why I made decisions. I will solve the same problem twice because I forgot I already solved it once.
The same brain is also extremely good at finding patterns, building systems, naming distinctions, and connecting things that looked unrelated five minutes ago. I can handle a ridiculous amount of complexity when I know where the pieces live.
That last part turned out to matter a lot.
The complexity itself usually isn’t what overwhelms me. I get into trouble when I also have to keep track of where everything is, what still needs attention, why I made a particular choice, and which useful strategy I was supposed to remember to use.
Once I could see that pattern, the problem got much more interesting.
Memory was only one layer of it.
I wanted the system to help preserve the conditions that let me work well in the first place.
That led to one of the questions at the center of RUNY:
What if I could translate some of my best behaviors into processes that run automatically, then build scaffolding around the places where I predictably drop the ball?
If ideas arrive faster than I can organize them, I can preserve them before I have to decide where they belong. If unfinished work tends to disappear, something outside my head can keep track of it. If separating evidence from interpretation helps me reason more clearly, that distinction can already be built into the workflow when I get there.
The more of these patterns I noticed, the more places I found where a little bit of structure could save me from repeatedly spending energy on the same problem.
That became the basic rhythm of RUNY.
Something would break or become frustrating. I’d figure out what was actually going wrong, build something to compensate for it, and then use the new system long enough to discover the next point of friction.
Every fix taught me a little more about what I actually needed.
At some point I looked around and realized I had accidentally built a whole system.
Software That Fits My Brain
Figuring out what I needed was only useful up to a point.
I’ve spent years having basically the same experience with software:
This is almost perfect. I just need it to do one more thing.
Sometimes the thing really is tiny.
I need this button over here. I need these two pieces of information to talk to each other. I need the app to remember one more thing. I need the workflow to happen in a slightly different order. I need a field that doesn’t exist, an automation nobody built, or a way to organize something that makes sense to my brain.
And I can see exactly how I want it to work.
That’s the maddening part.
I’m sitting there staring at a system that is 90% of the way to what I need, knowing the last 10% would make an enormous difference, and the system is completely outside my control.
So I go looking for an extension.
Then a plugin.
Then another app that fills one gap in the first app.
Then some horrible little workaround connecting all three of them.
Sometimes I can patch together something close enough. Sometimes I submit a feature request and hope somebody else happens to want the same weirdly specific thing I want. Sometimes I spend an embarrassing amount of time trying to force a tool into a shape it was never designed to have.
And then eventually I hit the wall.
I can see the change I need. I know why I need it. I know exactly how much easier it would make everything.
I just can’t make it happen.
Doing that over and over again is exhausting.
There are so many systems in my life that have made me think, god, if I could just tweak this one thing.
For most of my life, that thought ended there.
AI changed what I could do with it.
Suddenly, “I just need it to work a little differently” could become an actual design problem.
I could describe the missing piece. Figure out why I needed it. Prototype something. Test it. Change it. Keep going until the workflow started fitting the way my brain actually works.
That shift is a huge part of RUNY.
Once I had the ability to keep changing the system, all those tiny points of friction stopped feeling inevitable.
I started asking what software would look like if I could build around my actual cognition from the beginning.
My language. My patterns. My strengths. My recurring problems. My projects. My values. My weird little associations. The things that make perfect sense in my head and take a paragraph to explain to somebody else.
RUNY starts with one deeply modeled person: me.
Then I can ask what generalizes.
That is where I started thinking about cognitive prosthetics.
The closest analogy I have is physical therapy.
You figure out what can bear weight. You strengthen what responds well to exercise. You support what needs support. The amount of assistance changes depending on what the person can do.
I think cognitive accessibility can work that way too.
For me, the useful version of AI makes more of my own cognition available to me.
It gives my strongest abilities more room to work and catches some of the shit my brain keeps dropping on the floor.
A lot of my energy currently goes into compensating for the same bottlenecks over and over again.
I keep wondering what I could do with that energy if I got some of it back.
Infrastructure for the Weirdness
A lot of that energy goes into managing the sheer amount of stuff my brain generates.
I make connections constantly.
I’ll start with one problem and somehow end up connecting software architecture, psychology, accessibility, mythology, information science, AI governance, and whatever paper I read at three in the morning.
Usually there is a thread connecting all of it.
The annoying part is that the thread is much easier for me to see than it is to preserve.
An idea shows up before I know what it belongs to. Something I read suddenly connects to a project from six months ago. One conversation creates three new questions and reminds me of four unfinished ones. I’ll understand why two things are related long before I have language for the relationship.
Then I have to put all of that somewhere.
This is where a lot of systems start fighting me again.
They want the category before I understand the thing.
Pick the folder. Choose the project. Add the tag. Decide whether this is research or writing or a task or a note.
Meanwhile I’m still figuring out what the fuck I just noticed.
RUNY has gradually become a place where I can preserve those connections before I fully understand them.
An idea can stay unfinished.
A question can stay open.
Something can belong to more than one part of the system.
I can keep evidence connected to the interpretation it inspired while still keeping track of which is which.
I can find the old version of an idea later and see how it changed instead of vaguely remembering that I used to think something different.
That gives me room to follow the interesting thread without having to solve its entire filing system first.
And that matters because the weird associative stuff is often where my best work comes from.
A lot of my thinking happens by following connections. One thing reminds me of another, which points me toward something else, and eventually I realize there’s a useful relationship between them.
The more of those ideas I preserve, the more likely I am to find my way back to the connection later.
Which means the system has to be able to hold a lot of complexity without turning into a giant pile of sludge.
That is why RUNY keeps accumulating structure.
Containers. Labels. Relationships. Provenance. Versions. Rules about what kind of thing something is and what happens to it next.
I like structure because it lets me keep more complexity alive at once.
If I know where something is, I can stop holding onto it.
If I know I can find an unfinished thought later, I can leave it unfinished.
If I know the original source is preserved, I can speculate more freely without worrying that I’ll forget which part was evidence and which part came out of my own head.
The structure creates room.
And the more room I have, the farther I can follow the weird stuff.
This Is Technomancy
Somewhere in the middle of building all of this, I realized the structure felt strangely familiar.
I’ve been interested in symbolic systems for years.
Names. Rituals. Correspondences. Mythology. Visual languages. All the little ways humans use symbols to make abstract things easier to hold onto, move around, combine, and act on.
That same instinct keeps showing up in RUNY.
A name can turn a vague pattern into something I can recognize the next time it happens.
A label can preserve a distinction that would otherwise blur together.
A ritual can become a repeatable process.
A symbol can carry an entire cluster of meaning once enough context has accumulated around it.
At some point I realized systems design was scratching the exact same part of my brain.
I had been treating technomancy and software as two different interests.
Apparently they were already merging.
Now the symbolic system can participate.
I can describe a pattern to an AI, give it a name, test whether the name actually helps, turn the idea into a process, and then use that process long enough to discover something new about the original pattern.
The symbols become operational.
Then the operational system starts generating new information.
That loop is a huge part of RUNY.
I build something to help me think.
Using it changes what I notice.
What I notice changes the system.
Then I use the new version and learn something else.
That cycle has repeated enough times that RUNY has started feeling less like a piece of software and more like an ongoing practice.
Technomancy turned out to be a pretty good word for that.
Keeping the Thread
For any of this to work, the conversation had to survive.
That kept becoming a problem.
The models changed. Chats ended. Context windows filled up. Products changed underneath me. Something we had figured out together would suddenly be stranded in an old conversation, and I’d have to reconstruct enough of it to keep going.
Sometimes that meant finding a specific decision.
Sometimes it meant remembering why we had rejected an earlier idea.
Sometimes it was harder to name. The conversation had developed a shared vocabulary or a way of approaching the problem, and the next chat technically had the information but none of the accumulated understanding around it.
I kept running into the same question:
Okay, but what were we doing?
And every time I had to answer it from scratch, I could feel how much was being lost.
The more useful AI became to me, the more important that accumulated context became.
Language.
Decisions.
Corrections.
Patterns.
Things we’d tried.
Things that had failed spectacularly.
The reasons behind choices that made absolutely no sense once the reasons disappeared.
From the beginning, I knew I was building something I did not want trapped inside one company’s product.
If the model changed, I wanted the work to survive.
If I switched tools, I wanted to keep going.
If I changed my mind six months later, I wanted the old idea to stay attached to the context that produced it.
I wanted enough continuity that a new conversation could pick up the thread without requiring an archaeological dig first.
So I started pulling the context outward.
That decision ended up changing RUNY again.
RUNY had to preserve the parts of the collaboration I actually cared about, while models, apps, and interfaces could come and go around it.
And once I started preserving all of that context, I ran into another problem.
The system could remember something perfectly and still be wrong about what it meant now.
Remembering Forward
The longer RUNY existed, the more this mattered.
I change my mind. Projects change direction. Something that worked perfectly for me in one context becomes useless in another. A decision can make complete sense at the time and look bizarre later if I lose the circumstances that produced it.
So preserving context also means preserving movement.
I want to be able to see what I thought, why I thought it, what changed, and what replaced it.
That is where I started thinking about remembering forward.
The phrase came from trying to describe the kind of continuity I actually wanted.
I want the past available because it gives me somewhere to build from.
A decision can keep its reasoning.
An old idea can keep its place in the history of the project.
A process can evolve without erasing the version that came before it.
Something unfinished can wait for me without quietly becoming permanent.
The system can carry things forward while still leaving room for me to become somebody who would make a different choice.
That matters more as RUNY gets better at modeling me.
The more a system knows about how I work, the easier it would be for yesterday’s version of me to become the default.
I really don’t want that.
I want a system that can recognize continuity across change.
Something that can say: this mattered before, this is what it meant then, and here is what happened afterward.
That feels much closer to how people actually develop.
We carry our old selves with us. We reinterpret them. We contradict them. We keep some parts and abandon others. Sometimes we don’t realize something changed until we look backward and see the trail.
RUNY gives me a way to keep more of that trail.
And because the trail is still there, I can keep moving without having to keep starting over.
The runes answered back. RUNY is how I keep remembering forward.