Experimental RecurseWright: Engineering on Moving Ground, and Other Pretty Problems with Stability

Dedicated to my beloved Lana, Meri, and Leo,
and to everyone who reads this article to the end.

---

“Create systems that help your brain, not just your calendar.”
via Rachel Laycock, “The Conductor Developer”

Have you ever had this happen: over the course of a day, a week, or a month, so much changes around a project that each change, taken on its own, seems to have been handled quite reasonably - and then you look back and realize the overall trajectory has become a little chaotic?

For a moment, step into one of those familiar working situations. A feature is already moving forward, but one unresolved question is holding up the next step. Make your call - then follow what happens to the work around it.

One big change, a dozen small ones. New information, strange system behavior, a colleague's comment, an answer from AI, an API change. Some things need a response now. Some can wait. And some get sent to a private .gitignore whose contents are usually known only to us.

Usually, that's where it ends: an impulse arrives, we assess it, do something, and move on. But some changes have an unpleasant habit of coming back. Sometimes only as a thought: “I may have underestimated that.” Sometimes as a bug, an architectural constraint, or the realization that a decision which made perfect sense at the time turned out to be part of a very different story.

And the problem is not necessarily bad information. The more interesting case is when the information was reliable, the decisions were rational, and yet we still failed to preserve and integrate all of it properly into what came next.

At some point I ran into a simple and uncomfortable thought:

verified information is not automatically evidence for the claim we want to make.

A Door Opens from the Outside

I came across the line at the top of this article in Rachel Laycock's writing, where she shares it as advice from her executive coach. I found it at exactly the kind of moment when a single thought can do considerably more than it has any business doing.

Rachel writes with an openness I found quietly disarming: thoughts do not always have to wait until they are polished into something final before they are allowed to meet other people. That stayed with me, because I had been treating publication as something that came after a thought was finished enough.

Her example made another possibility feel both simpler and a little braver: a thought can still be unfinished and already have enough support to meet the outside world.

Unfinished is not the same thing as unsupported.

The distinction made me a little less protective of work that was still forming. Not in the sense of I have no idea whether this is true, but here goes. More like: there is something here, I know why I think so, and perhaps keeping it indoors until every edge is polished is not doing it any favors.

The rhythm of the work changed more than I expected. Things could come back earlier: a comment, an objection, a surprisingly quiet response to something I thought would be controversial. Sometimes nothing useful came back at all, which is information of its own.

Somewhere around there, a rather comfortable model began to form in my head: keep the reasons, keep enough of the path, let reality answer, and don't make the next decision from an artificially clean slate.

That model still seems useful to me. It simply turned out not to be enough.

I found that out during a very ordinary piece of engineering work.

The real case belongs to a product I cannot describe here, so I am going to be slightly unfair to a capybara. The causal sequence is real; the capybara, the box, and the striped socks are not.

Imagine that our capybara is carrying a box through a system with two gates. At one gate, the box is clearly not allowed through; elsewhere in the same system, there is no equivalent restriction.

If you've spent enough time around product code, you can probably feel the conclusion arriving before I write it. One part of the system knows the rule; the other has somehow missed it.

It was neat, plausible, and very easy to turn into work. We could point to the behavior, we could point to the place where the matching restriction was absent, and we could explain exactly how one observation had led us to the other. Nothing had been forgotten, and nobody had invented a fact.

Just before the conclusion became a task, though, one annoyingly simple question got in the way:

Where is the rule?

The behavior was there, and so was the code. That was evidence that the two gates behaved differently. What we could not find was evidence for the stronger claim: that both gates were meant to enforce the same rule, and one of them was violating it.

We looked, and could not establish it.

So the task quietly disappeared before it managed to become a task.

I kept thinking about that little non-event afterwards. We had preserved the context, we knew where the observations came from, and we could reconstruct the reasoning without much trouble. In other words, almost everything my comfortable model had asked us to preserve had survived.

The facts had survived perfectly well; we had simply carried them farther than they were entitled to go.

That was new.

The Order Changed

Not dramatically. There was no meeting where we announced a new engineering philosophy, and nobody printed “Where is the rule?” on a mug.

But not long afterwards, another piece of work arrived with the same familiar temptation: something in the product looked inconsistent, and there was an obvious task waiting to be written down.

This time the task did not come first.

We started by separating what we could actually see from what we thought it meant. Then we went looking for the thing that could turn the second into something we were allowed to act on.

Sometimes that thing existed. A requirement, an accepted decision, an owner who could settle the ambiguity.

Sometimes it did not.

And when it did not, the absence itself became useful. We could stop before inventing work for a system that had never asked for it.

I cannot honestly claim that one capybara changed our engineering practice. Real work is rarely kind enough to leave causality that tidy. Some of this discipline existed before; some of it became sharper later.

What I can say is simpler: shortly afterwards, the distinction was no longer sitting in a report as an interesting observation. It was being exercised in the order of the work.

We were no longer only preserving what had happened.

We had begun changing what happened next.

The change was small enough that I could have filed it under “better engineering habits” and moved on.

Except that the next time I asked AI to investigate a similar ambiguity, I noticed that the question I was giving it had changed too.

Instead of starting with something close to “what needs fixing here?”, the investigation began by separating what could actually be observed from what was only being inferred. Accepted decisions were kept apart from things that merely looked likely, and anything we could not establish was allowed to remain unknown rather than being quietly promoted into an answer.

That sounds like prompt hygiene, and part of it probably was. But the difference showed up in the work itself. The AI stopped being asked to complete the shape of the problem as quickly as possible; it was being asked to preserve the places where the shape was still uncertain.

The result was not always more convenient. Sometimes the answer came back with fewer conclusions than before, along with several irritatingly intact questions.

Those questions turned out to be useful.

A missing answer could now survive long enough to reach the person, document, code path, or later piece of evidence that actually had a chance of resolving it. And when nothing resolved it, we no longer had to pretend that uncertainty was a temporary formatting problem.

Somewhere in that shift, I noticed that we were no longer only improving the way we recorded engineering decisions.

The interaction that produced those decisions was beginning to change as well.

A Shore Comes Into View

A paper boat looks free for a moment. Then you notice how much of its journey belongs to the water and its banks.

Something similar had begun to happen in the work. The question I asked shaped the answer I received. The answer shaped what I had to check next. What I managed to verify shaped whether a task existed at all. A note, a prompt, a person, a piece of code - none of them was doing much alone, but none was staying alone either.

At first, I could still have described all this as a collection of improved habits. Ask better questions. Keep uncertainty visible. Resist the urge to turn every inconsistency into work. Sensible advice. Useful, even.

But that description was starting to feel a little too neat.

A change in one place was altering the next move somewhere else. A better prompt did not merely improve an answer; it changed the kind of answer that could return. A preserved ambiguity did not merely delay a conclusion; it changed the work waiting on the other side of it. Even a missing answer had become productive, because it could now survive long enough to meet the person, artifact, or later piece of evidence that might actually resolve it.

By then I was no longer only noticing better decisions. I was noticing changed conditions for making them.

That is a different sort of event. It does not announce itself loudly. There is no obvious before-and-after screenshot, and nobody gets to give it a grand launch name. You just realize, a little late, that the work is not moving through empty space. Its surroundings are part of the movement.

I still did not have a satisfying name for that.

What I had was smaller and more useful: the sense that a shore was beginning to come into view.

The Company It Keeps

Once I started looking at the work from that angle, a fairly ordinary pattern became harder to ignore: the adjustments did not reliably stay where they started.

For a while, “feedback” seemed like a good enough word for this. We send something out, something comes back, we correct course. Engineers have been living with feedback loops for rather longer than we have been living with chat windows.

But the word began to feel slightly too tidy.

Feedback can leave the things exchanging it essentially intact. What I was beginning to notice was that sometimes the exchange changed one of the participants themselves - not in some grand philosophical sense, but in the very practical sense that the next round began differently.

I asked AI a different kind of question because of what had happened before. That changed what it was useful to ask a human. A decision we had managed to establish changed what was worth checking in the code. A change in the order of those checks could make a task disappear before anyone spent time implementing it.

The result was still ordinary engineering work. It just became increasingly difficult to point at one part of it and say: this is where the change lives.

The question had moved again.

I was no longer only interested in how information traveled through the work.

I was beginning to notice what the traveling information did to the things it passed through.

The Environment Wasn't Scenery

Software engineers already have a fairly unromantic relationship with the word environment. It is often the place where something behaves differently than it did on your machine.

But I had started noticing another kind of environment around the work.

The question I asked AI, the person who could settle an ambiguity, the document that still carried an old decision, the code that showed what the system actually did, the way we chose to investigate it - I had been treating these mostly as things surrounding the task.

That was convenient. Tasks have edges. Surroundings can stay in the background.

Except they weren't staying there.

The result still mattered, of course. We were there to build things, not to admire the elegance of our uncertainty.

But the result was no longer the only thing left behind.

The next round could begin with a different question, a different check, a changed tool, a clarified rule, or simply a person who now knew to hesitate in a place where they had not hesitated before. None of those changes was particularly impressive on its own. Together they made the word workflow start to feel a little narrow.

A workflow suggests that work moves through a path.

What I was looking at seemed capable of changing parts of the path while moving through it.

Somewhere around here, I finally became comfortable using a larger word for what I was building.

A system.

Not because everything was suddenly connected to everything else. That is a wonderfully efficient way to explain almost nothing.

The reason was more practical. The human, AI, methods, tools and artifacts involved in the work were not merely passing results between fixed stations. An interaction could leave one of them in a slightly different condition for the next interaction, which meant that a change made in one place could become part of the working environment of another.

I did not yet know how far that idea went.

But the shore was no longer just where the boat happened to pass.

It was part of the journey.

Not Quite the Same Stations

Once I had allowed myself to call it a system, the diagram created a small problem of its own.

Diagrams are very good at making things look patient. Human here. AI there. Methods, tools and artifacts politely occupying their places while arrows do all the traveling.

Real work was less well behaved.

The person who came back to the next problem was not always approaching it in quite the same way. A method that had worked well enough once could acquire an extra check, lose a shortcut, or simply stop being the first thing we reached for. A tool could begin as a convenient one-off and later turn into something repeatable because doing the same careful work again had become more expensive than making it reproducible. Even an artifact could change its role: first a result, then a reference, then something another piece of work had to respond to.

AI made the picture particularly easy to misunderstand. The model did not magically rewrite itself because we had learned something on Tuesday. But the way we worked with it could change substantially: what we asked, what context we preserved, what we allowed it to infer, where we expected uncertainty to remain visible, and where a human decision still had to enter.

And the human was not a supervisor standing safely outside the diagram.

I could change too. Not because the system had issued an instruction to become a better component, but because some encounters left me with a question I would ask differently next time, a shortcut I no longer trusted, or a boundary I had learned not to cross quite so casually. Just as importantly, I could decide that the system was wrong, ignore a suggestion, change the method, or stop the whole line of reasoning and go another way.

That mattered. If every arrow ultimately meant “everything becomes better aligned with one central logic”, I would have built something much less interesting - and, for a human participant, rather less pleasant.

So the first picture in my head began to shift. The system was not merely producing changing results through a stable collection of parts. Sometimes the work could leave one of those parts, or the relationship between them, slightly different for whatever came next.

I was still a long way from knowing what to call that.

But I had stopped assuming that the output was the only thing allowed to change.

The Change Doesn't Stay Put

Once one part of the work changed, it had an annoying tendency to make itself somebody else's problem.

A small adjustment to the way we investigated uncertainty changed what we asked AI to return. That, in turn, changed what a human needed to decide. A clearer decision could make a check in the code unnecessary, or expose a place where the tooling was no longer helping. If the same kind of work appeared again, the tool might change too.

None of this required a master plan.

That was the interesting part.

The method did not issue instructions to the human. The human did not redesign AI. The artifact did not somehow improve the tool. Each change simply altered the conditions the others met the next time they interacted.

Sometimes the effect traveled surprisingly far. A question that began as “are we sure this is a rule?” could end up changing the order of an investigation, the shape of a prompt, what we recorded for later, and which part of the work still needed a human judgment.

Sometimes it traveled nowhere at all.

A new observation could arrive, get checked, and leave the current way of working perfectly intact.

I began to like that asymmetry. It meant the system did not have to treat every new signal as a command to evolve. Something could matter without forcing a change.

And when a change did happen, it did not have to make every other element more obedient to the same logic.

The human could disagree. A method could survive unchanged. A tool could be replaced. AI could return something useful that we still decided not to act on. An artifact could remain exactly as it was while becoming newly relevant because something around it had changed.

That made the picture stranger, but also more believable.

The parts were beginning to move.

They just weren't moving in formation.

The Stones Didn't Move

The stones did not move.

That was rather the point.

For a while, I had been thinking about change too literally. If a question could alter the way I worked with AI, if a method could acquire another check, if a tool could grow out of repeated work, then it was tempting to imagine a healthy system as one in which every meaningful encounter left something visibly different behind.

Real work is less obliging.

Sometimes new information arrived, survived the checks, and changed nothing we could point to. The method stayed. The tool stayed. The piece of code stayed exactly where it was.

But the next encounter with it was not necessarily the same.

Perhaps we had now tested an assumption that had previously gone untested. Perhaps we knew why the current behavior should remain. Perhaps an artifact that had been sitting quietly for weeks had suddenly become relevant to a different question. Or perhaps we had simply earned a better reason not to touch something.

The object could remain unchanged while its place in the work became a little clearer.

That distinction mattered more than I expected. Otherwise every new signal quietly turns into pressure to improve, update, refactor, revise, evolve. A system that behaves like that eventually becomes very good at disturbing itself.

Sometimes the useful result of looking again is to leave the thing alone.

The stone stays where it is. The water continues past it. What has changed is that the next time we meet that stone, we know something about why it is still there.

And that was the first point at which “moving” stopped meaning “changing state” for me.

A part of the system could stay exactly as it was and still remain inside the trajectory.

When the Edge Stops Being Quiet

The next question did not arrive as a definition.

It arrived more like a mild irritation.

If some parts of the work could stay in place and still acquire a different role in what came next, then the real difficulty was not simply deciding whether something had changed. Quite often, nothing obvious had. The method still worked. The tool still worked. The current arrangement still got us through the day.

And yet, from time to time, one part of that arrangement stopped feeling as unremarkable as it had a week earlier.

A question returned too easily. A neat explanation started needing one extra exception every time we used it. A stable piece of work began attracting just enough friction to make us look at it again. Nothing had broken. Nothing had announced a crisis. It was simply becoming harder to pass through the same place without noticing that the passage was narrower than we had been pretending.

That was the point at which I started thinking less about change in general and more about where a particular way of drawing the work around itself had ceased to be quiet.

I do not mean “boundary” in a heroic sense. Nobody was setting out each morning to discover a new frontier before lunch. Most of the time the work was quite happy to remain ordinary.

What interested me was more modest, and more useful. A boundary was often just the place where a working arrangement stopped being transparent. The assumptions holding it together were still there, but they had begun to show their outlines.

That could happen for all sorts of unglamorous reasons. A decision that made sense in one context started traveling into another. A tool that had been good enough once began creating more repetition than it saved. A question that seemed local returned in a slightly different disguise. Sometimes a new signal arrived from outside. Sometimes the pressure had been building inside the work for quite a while and only now became visible.

Either way, the experience was recognizable. You were no longer just inside the current shape of things; you had started noticing its edge.

That did not mean the edge had to move. It did not even mean the current state was wrong.

But it did mean that the old comfort had lost some of its innocence.

The work could still remain where it was. We could stop, check, keep going, and change nothing at all. But from that point on, if we stayed, we stayed with a little more knowledge about what was holding the shape together - and what might eventually push against it.

That, I think, was the beginning of my interest in boundaries.

Not because I wanted to chase them.

Because they had stopped being silent.

A Boundary Is Not a Task

Once a boundary becomes visible, there is a temptation to treat that as work waiting to happen.

Engineers are not entirely innocent here. We see an edge, an inconsistency, a place where an assumption has started showing through, and somewhere in the back of the mind a ticket is already putting on its shoes.

But noticing a boundary does not tell you what to do with it.

Sometimes the right move is to ask a better question. Sometimes it is to look for the decision that created the boundary in the first place. Sometimes the boundary belongs to somebody else, and the useful thing to do is not cross it more cleverly but ask whether you should be crossing it at all.

And sometimes, after looking closely, you leave it exactly where it is.

That last possibility took me a while to respect.

A visible edge can be uncomfortable simply because it has become visible. Once you see the assumptions holding a method, a tool, or a working agreement together, it is surprisingly easy to mistake awareness for a reason to redesign them.

The work taught me otherwise. Some boundaries survived inspection perfectly well. Others turned out to be in the wrong place. A few were not really boundaries at all, only habits that had acquired the appearance of architecture.

The difficult cases were the ones where we could not yet tell.

There, changing the system immediately would have meant pretending we knew more than we did. Leaving everything untouched forever would have made the opposite mistake.

So we needed a way to stay near the edge for a while without either worshipping it or knocking it down.

Sometimes that meant asking a person. Sometimes tracing an old decision. Sometimes trying the same work under slightly different conditions. And sometimes the uncertainty was narrow enough that we could ask reality a much smaller question and see what happened.

That was where experiments began to appear in the story.

Not as the engine of RecurseWright, and not as proof that every visible boundary should move.

Just as one useful way of finding out whether the ground on the other side was actually different from the ground beneath our feet.

What the Edge Is Made Of

A doorway looks simple until two people try to cross it at the same time.

Then, for a second, the doorway is no longer just an opening in a wall. It contains direction, timing, expectation, perhaps a little politeness, and the sudden discovery that the person on the other side had a perfectly reasonable plan of their own.

Engineering boundaries began to look similar.

The interesting part was rarely the line itself. It was what the line had been quietly carrying for us: who was expected to decide, which behavior counted as intentional, what a tool was allowed to assume, which uncertainty could be left open, what belonged to this piece of work and what belonged somewhere else.

Most of the time those assumptions were useful precisely because we did not have to think about them. They let the work move.

A boundary became noticeable when that stopped being true.

Sometimes one assumption no longer fitted the case in front of us. Sometimes two perfectly sensible expectations arrived at the same doorway from opposite sides. Sometimes nothing was wrong with either side; they had simply been built around different ideas of what happened at the edge.

That changed the way I looked at the problem.

Instead of asking only whether the boundary should move, I started asking what was making it necessary in the first place, and what else would move with it if it changed.

The answers were rarely local.

Clarifying who could make a decision might change the way we asked AI for help. Discovering that an apparent rule was only an implementation habit might remove a task. Moving responsibility from a tool back to a person could change the method around it. A boundary that looked like one small line in the work could turn out to be holding several relationships in place at once.

This did not make boundaries mysterious. If anything, it made them more practical.

A boundary was becoming less like the edge of a box and more like a place where several assumptions happened to meet.

And once you see one that way, moving it casually becomes difficult.

Not because boundaries are sacred.

Because you have begun to notice what is leaning on them.

One Edge Rarely Comes Alone

Once I started seeing boundaries that way, another inconvenience appeared almost immediately.

A visible boundary was rarely alone.

What first looked like a simple question about one edge often turned out to be a route into several others. If we asked whether a behavior represented a real rule, we quickly arrived at a boundary around authority. If we clarified who could decide, we often ran into another boundary around responsibility. If a tool had been making a decision we no longer trusted it to make, the next question was not only about the tool, but about the method around it, and the human judgment that had been standing a little farther back than it should.

One edge led to another, not because the work was secretly trying to become complicated, but because the previous arrangement had been allowing several assumptions to travel together under one name.

That changed the feel of the work again.

I was no longer looking at a single line and asking whether to cross it. More often, I found myself arriving at one edge, learning something there, and then discovering that the thing I had just clarified had brought another edge into view.

A question met a boundary. The boundary, once examined, changed the shape of the question. The new question then traveled until it met the next boundary.

That pattern repeated often enough that the work stopped looking like a march toward a final explanation. It felt more like moving from one temporary edge to another, each one visible for a reason, each one capable of changing what happened next.

Not every encounter demanded the same response.

Sometimes we reopened something we had treated as settled. Sometimes we explored. Sometimes we ran a very small experiment. Sometimes a different interpretation was enough. Sometimes we decided the apparent boundary was not ours to cross. And sometimes, after all that, we kept the current state exactly as it was and simply went on living there.

That last possibility mattered more than it first appeared to. Most of real work is not heroic passage. Most of it is stabilization, ordinary use, and the slow accumulation of reasons to trust - or question - the ground underfoot.

So by this point, I was no longer thinking of RecurseWright as a way to move past a problem once and for all. It was beginning to look more like a way of traveling from boundary to boundary without losing the consequences of what each encounter had taught us.

I still did not have the whole mechanism in view.

But I could already feel its grammar.

The Return Was Different

By then, the name RecurseWright was beginning to feel less like a title and more like a description.

Not because the work was looping mechanically, and not because every question sent us into some grand cycle of transformation. The return was usually much quieter than that.

A question met a boundary. Something about that boundary became visible. We checked it, clarified what we could, and sometimes discovered that the right consequence was not a change, but a better reason to leave the current state alone.

Then the next piece of work arrived.

What mattered was that it did not arrive on untouched ground.

A later ambiguity might look unrelated on the surface, but the earlier encounter had already left something behind: a distinction we now knew to preserve, a shortcut we no longer trusted, a question we had learned to ask sooner, an assumption we were less willing to let travel unexamined.

That did not guarantee a better result. It did something more modest, and in practice more useful. It changed the conditions of the next return.

One boundary encounter had left retained consequences for the next one.

This was not repetition alone. A return can bring you back to a familiar place; what mattered here was that the work came back carrying traces of what had already happened, and those traces could alter the next judgment, the next question, or the next move.

That was the first moment when the name started to earn itself.

The recursive part was not a trick of structure. It was the fact that the work could return to itself without shedding the consequences of its own history.

And the crafted part mattered too. None of this happened automatically. Someone still had to preserve the distinction, make the judgment, refuse the easy inference, ask the smaller question, or decide that the current state should stand.

The system was not merely going around.

It was being worked.

A boundary had been encountered. Something had been retained. The next state of the work was not a clean restart, and not a total reinvention either.

It was the same work, returning differently.

A First Skeleton

At that point I could finally draw something without pretending it was the whole system.

The first useful skeleton was surprisingly small:

Sₙ
→ [EvolutionRun:
   signal → inspection → evidence → judgment → retained consequences]
→ Sₙ₊₁

Sₙ is simply the state from which the work begins this particular encounter. Not the state of the universe, and not even a complete snapshot of the project - only enough of the current working reality for this run to have a meaningful starting point.

Then something happens that is worth reopening. A question returns, a boundary becomes visible, new information arrives, an assumption starts asking for attention. Instead of letting that signal dissolve into ordinary work, we give it a bounded passage of its own. That is the EvolutionRun.

Within the run, inspection does not automatically produce a decision. It may produce evidence, an observed outcome, a stronger question, or the discovery that what looked obvious cannot actually be established.

That distinction turned out to matter.

Evidence does not get to impersonate judgment, just as an observation did not get to impersonate a rule back in the capybara story. Someone still has to decide what the result means here, what authority it carries, and whether anything should follow from it.

Only then do we reach the part I had been missing in many earlier ways of working: what, if anything, should survive this encounter and become available to the next one?

A changed method can survive. A clarified rule can survive. A new question can survive. So can a reason for leaving something exactly as it is.

That last case is why Sₙ₊₁ should not be read as “the system must now look different”.

Sometimes it will.

Sometimes, from the outside, Sₙ₊₁ may look almost indistinguishable from Sₙ. The code is unchanged. The tool is unchanged. The method is unchanged.

What has changed is that the current state has now survived an encounter for a reason we can carry forward.

So the small +1 is not a demand for novelty.

It marks that something happened, was examined, judged, and either left a consequence behind or gave us a reason not to alter the present state.

For me, this was the first version of RecurseWright that felt structural rather than aspirational. It did not yet explain where boundaries came from, how long a stable state should remain stable, or what kinds of moves were possible once an edge became visible.

But it gave the return somewhere to land.

The work no longer had to come back merely remembering that something had happened.

It could come back carrying what the encounter had earned.

Between Two Boundaries

The first skeleton still left out one important dimension.

It showed how an encounter could leave something behind, but not why a run should begin in the first place, or why it should ever end.

The answer, somewhat to my relief, was not continuous change.

Most of the time, a working state should simply be allowed to work.

You build something, make a decision, settle on a method, clarify a responsibility - and then you live there. The state earns a little stability not because it has become final, but because, for now, it is sufficient for the work passing through it.

That “for now” turned out to matter.

A boundary became interesting when the conditions that had made the current state sufficient began to stop being sufficient. Perhaps a new case no longer fitted an old rule. Perhaps the same workaround kept returning. Perhaps a decision started traveling farther than its original authority. Sometimes the pressure came from outside; sometimes the current state had been accumulating its own awkward little protrusions for quite a while.

The useful question was no longer simply “has something changed?”

It was closer to: what exactly has stopped fitting here?

That made boundaries surprisingly researchable.

You could look for the assumption that had become visible, the authority the current arrangement depended on, the responsibility sitting on one side or the other, the evidence that had once been enough, or the condition under which the current shape still made sense.

And once the boundary was visible, there was no single prescribed move.

We might reopen something we had treated as settled. We might explore the unfamiliar part. We might run a bounded experiment. We might reinterpret what we already knew. We might decide that the apparent edge was not ours to cross.

Or, after all that, we might decide that nothing should change.

That was not a failed run.

Sometimes the result of looking carefully at a boundary was a better reason to stay exactly where we were.

Then the system could stabilize again and simply live there.

For a while.

Until another encounter made another edge visible.

Only then did the geometry of RecurseWright begin to make sense to me. The movement was not from “old” to “new”, or from “worse” to “better”. It was from one sufficiently stable state, through an encountered boundary, toward whatever state could honestly support the work next.

Sometimes that next state looked different.

Sometimes it looked almost identical.

Either way, the passage had happened.

And this was the part I had missed at first: even when an element remained still, it could still be moving with the trajectory.

Where the Shape Starts to Bulge

Seen from above, the pattern looks almost civilized.

There is a stable place to work from, a boundary, another stable place beyond it. You can trace the route with a finger and begin to believe that real work might occasionally have the courtesy to behave like its diagram.

It rarely does.

A boundary usually became interesting to me in a much less theatrical way. Something simply began to stick out.

One case no longer fitted the rule quite as neatly as the others. A workaround returned often enough to stop feeling temporary. A tool still worked, but only if we quietly supplied the judgment it was supposed to save us from. An old decision remained perfectly reasonable inside the conditions that had produced it, while the work around those conditions had moved on.

Nothing necessarily broke.

The current shape just stopped containing everything we were asking it to contain.

For a while I thought of these as exceptions. That was often accurate, but not always useful. “Exception” has a way of making the surrounding structure sound innocent. Sometimes the thing sticking out was exactly where the structure became easiest to inspect.

Follow the protrusion and you might find an old assumption underneath it. Follow that assumption and you might reach a decision, a method, a tool, a piece of retained evidence, or a human responsibility that had quietly become part of the same arrangement.

This was where boundary work started becoming unexpectedly powerful.

Investigating one edge did not mean changing everything connected to it. Quite often the opposite happened: most of the surrounding structure survived perfectly well. But the investigation could change what those parts meant to one another.

A rule might remain unchanged while its authority became clearer. A tool might remain unchanged while we narrowed what we trusted it to decide. A human might continue doing exactly the same thing, now with a different reason for doing it. An artifact might stay untouched and become important simply because a question had finally reached it.

The visible change could be tiny.

The rearrangement of meaning around it was sometimes much larger.

That made me increasingly suspicious of the idea that a boundary was simply where something ended. In practice, the interesting boundaries seemed to be places where enough assumptions had gathered close together that a new encounter could make several of them visible at once.

Not every protrusion deserved a new shape.

Some disappeared when we looked closely. Some taught us why the existing boundary was still good enough. Some remained unresolved and were better carried forward as questions than flattened into premature answers.

But every now and then, the current state could no longer honestly contain what had become visible.

Then staying put and moving forward stopped being opposites.

The work had already begun to extend beyond the shape that was holding it.

The Others Began to Answer

Seen on a diagram, it is tempting to mark the disturbance in red and believe that the change has been located.

Real work is less polite than that.

Once the current state could no longer honestly contain what had become visible, the interesting part was not only the local change itself. It was what happened around it.

A clarified boundary in one place altered what it was worth asking AI in another. A narrower trust in one tool moved more judgment back to a person. A question retained from one run resurfaced as a condition inside the next. An artifact that had seemed finished became part of a later decision. Sometimes nothing visibly changed except the meaning of the relations among these parts.

That was already enough.

I began to think of this less as simple propagation and more as resonance. Not because the system moved in harmony, and certainly not because one change issued orders to the rest. The point was almost the opposite. Each element answered from its own current condition.

Some changed. Some stayed where they were and acquired a different role. Some resisted. Some became newly important only because something else had moved.

That was the first point at which the phrase each element started to matter to me.

Up to then, it was still possible to describe the work as a system that changed its output. What I was seeing now was more demanding: the work could alter the elements and relationships through which it produced the next output.

Not every such answer deserved the grand word evolution. Sometimes the shift was slight. Sometimes it was only a change in trust, responsibility, or interpretation. But a few encounters did seem to leave one part more capable than before: a human with a better question, a method that now preserved an uncertainty it used to erase, a tool made repeatable because repeating the same careful work had become too expensive, an artifact that could now function as a probe instead of only a result.

And once several elements could answer in that way, something else began to appear.

The system could produce effects that no single element had contained in advance.

Some were useful: a better question arriving earlier, a more reliable distinction between evidence and judgment, a cleaner route through later work. Some were merely interesting. Some were awkward, costly, or quietly harmful.

Emergence, if that was the right word, did not deserve automatic applause.

But it did deserve attention.

A system in which parts can affect one another without losing their own trajectories will occasionally produce consequences that belong to the arrangement as a whole rather than to any one participant alone. Sometimes that is the beginning of a capability. Sometimes it is the beginning of a problem. Usually it is first felt not as a theory, but as a change in the texture of the work: something has become easier, stranger, riskier, calmer, heavier, lighter.

By then I could no longer tell the story honestly as though only the visible task had moved.

The movement was now traveling through the system itself.

Some parts had changed a little.
A few, perhaps, had done more than that.

The Stream Did Not Split

Useful emergence is easy to like.

A question begins reaching the right person earlier. An uncertainty that used to disappear inside a confident answer survives long enough to be resolved properly. A tool stops repeating work that no longer needs to be repeated. Several small changes, none remarkable on its own, leave the next piece of work noticeably easier to enter.

That is the pleasant version.

There are quieter ones.

A new interaction may alter nothing that deserves celebration or concern. A method becomes slightly more explicit. An artifact acquires another use. A human learns where not to trust an apparently convenient shortcut. The system does not become “better” in any grand sense; it simply acquires another way of behaving under a particular set of conditions.

And then there are outcomes we would rather not keep.

A shortcut becomes so convenient that people stop noticing the judgment it has quietly absorbed. An AI workflow gets faster while making one class of uncertainty increasingly invisible. A useful artifact starts attracting decisions it was never meant to carry. A local optimization makes the next task easier and the fifth one considerably harder.

None of these effects need to have been designed.

The distinction matters because emergence is sometimes discussed as though the word itself were good news. In a working system, it is closer to a description of where an effect came from: not from one component acting alone, but from the way several parts met, answered, and changed the conditions for one another.

The outcome can be helpful.

It can be neutral.

It can be harmful.

The stream is the same.

What differs is what the relations inside it begin to produce.

And somewhere here another assumption of mine became difficult to keep.

Until then, I could still speak loosely about “the system learning” or “the system changing”. Convenient phrases, but suspiciously smooth ones. They made the whole arrangement sound as though it were a single creature acquiring one new property at a time.

That was not what I was seeing.

A human might begin asking a question earlier without changing the tool at all. The tool might later become more constrained, which could change what the human had to judge. An artifact might remain untouched yet become part of a new decision path. A method could absorb a distinction that had first appeared somewhere else.

The system had not learned one thing.

Different elements had begun to participate differently in what happened next.

That is a smaller claim, but a much more interesting one.

Because participation can change even when the element itself appears static.

A document can remain byte-for-byte identical and suddenly become relevant to a decision it had never previously touched. A person can perform the same action for a different reason. A tool can expose the same interface while occupying a narrower place in the chain of judgment. An artifact can remain exactly where it was and become a probe because a new question has reached it.

Nothing supernatural has happened.

The element has not necessarily transformed internally.

But its position in the causal arrangement has changed, and that changes what it can do to the work around it - and what the work around it can now do to it.

Once several elements can shift in that way, the old picture of a system with changing outputs and stable parts becomes difficult to recover.

Some elements merely change their participation.

Some change more deeply.

And every now and then, an element seems to return from an encounter with a new way of being part of the work.

That is where I would reserve the stronger word.

Evolution.

When a Part Comes Back Different

The whole system did not have to learn anything.

That possibility became important almost as soon as I noticed it.

A useful effect could emerge from several elements without any one of them acquiring a new capability. The relations had changed enough to produce something new, and that was already interesting.

But sometimes one of the parts did come back differently.

Not merely used in a different place for one afternoon. Something from the encounter survived far enough to alter how that element could participate in later work.

For a human, the change might be almost embarrassingly small: a question learned well enough that it begins arriving before the mistake it used to follow. The person is still the same person, doing much of the same work. But the next encounter no longer begins from quite the same repertoire.

A method can return differently too. Perhaps it used to turn uncertainty into the most plausible answer and now preserves the uncertainty until someone with the right authority can resolve it. Most of the method may remain untouched. One distinction has survived, and that distinction changes what the method is capable of carrying forward.

A tool may change because repetition finally becomes expensive enough to deserve machinery. An artifact may begin as an answer and later become something we can ask questions of. Even the way AI participates can change substantially without pretending that the underlying model has somehow rewritten itself: different context is retained, different inferences are permitted, different uncertainty is expected to survive, and human judgment enters at different places.

These are not identical kinds of change.

I increasingly thought that treating them as if they were would hide the interesting part.

The human does not evolve as a tool does. A method does not have the autonomy of a human. An artifact does not “learn” because its role has changed. AI does not become a different model because our way of working with it has changed.

They remain different kinds of things.

That is precisely why their movement matters.

If RecurseWright required them all to change in the same way, toward the same shape, under the same central logic, it would be much easier to describe.

It would also be a system I would not particularly want to build.

What interested me was something less tidy: each element could retain its own nature and still be changed by encounters with the others. Sometimes the change would be temporary. Sometimes it would amount only to a new relation. Sometimes nothing inside the element would change at all.

And sometimes a consequence would survive long enough that the next work began with a genuinely different way for that element to participate.

That was the point at which I became willing to call the change evolutionary.

Not because change had happened.

Because something had been retained strongly enough to alter what could happen next.

This also changed what I meant by saying that every element of RecurseWright should be able to evolve.

It was not a claim that every element already does.

It was an architectural choice.

A human should be able to revise how they work without becoming an obedient executor of the system around them. A method should be revisable when its assumptions stop holding. A tool should be replaceable, narrowed, extended, or left alone. An artifact should be able to acquire a new role without the old one being rewritten out of history. The relations among them should be able to change as well.

Their unity comes from influence, not uniformity.

And once I saw the system that way, the red branch in the picture stopped looking like an exception to an otherwise healthy blue one.

Both belonged to the same capacity.

The ability of one part to alter the conditions encountered by another can produce a better question, a useful capability, an unremarkable adjustment - or a failure that becomes easier to repeat.

Evolution did not solve emergence.

It made emergence more consequential.

Because now an emergent effect did not necessarily end with the effect itself. It could change one of the elements that had produced it, and that changed element could enter the next encounter carrying the consequence forward.

The stream could affect its banks.

The banks could alter the next stream.

And by then, separating one from the other was becoming less useful than asking what, exactly, had survived the passage.

The path still looked continuous.

What carried it did not.

A consequence that had begun as a human judgment could later exist as a note, a prompt constraint, a test, a changed method, a piece of code, or simply as something another person now knew not to assume. None of those things looked much like the others. Yet something from the earlier encounter could survive in each of them.

That made the system unexpectedly difficult to point at.

The repository was part of it, but clearly not enough. So were the conversations, the tools, the artifacts, the decisions that never became code, and the people whose next decisions were no longer quite the same because of what had happened before.

Even preserving all of those objects would not necessarily preserve the continuity between them. A perfect archive could still leave us with a collection of things whose causal relationship had gone missing.

And the opposite seemed possible too. The form could change almost completely while the consequence survived.

What had crossed the distance was apparently not identical to the thing carrying it.

For a while, that was an awkward observation to leave lying around.

But by then, it was becoming difficult not to.

The odd part was no longer that the same consequence could appear in different places. Software does that all the time. Data moves. Representations change. One form becomes another.

What was harder to explain was why none of those forms seemed entitled to be called the place where the continuity lived.

A decision could begin in a person, alter a conversation, become a constraint in a prompt, survive as a test, disappear from the artifact that first recorded it, and still affect a later decision. Sometimes the original carrier remained. Sometimes it changed beyond recognition. Sometimes, as in the empty space above, it was simply gone.

And yet the path did not necessarily end there.

I started thinking of these different places as substrates - not because they were equivalent, but because each could temporarily carry some part of what the work had become.

A human memory is not a repository. A repository is not a conversation. A conversation is not a model context. A model context is not a method, and none of them become interchangeable merely because a consequence can pass through them.

That distinction mattered.

If the same thing were merely being copied from one substrate to another, the problem would be fairly ordinary. We would be talking about translation, serialization, perhaps synchronization.

But that was not quite what I was seeing.

What survived a passage could change its form, its precision, even its role. A question could become a guardrail. A failure could become a test. A conversation could become a change in method. An artifact could disappear while the constraint it exposed continued shaping work months later.

So the continuity was not behaving like an object being handed from one container to the next.

It looked more like a causal thread capable of crossing substrates without requiring any one of them to remain its permanent home.

I use substrate-crossing for that idea, cautiously.

At this point it is still a hypothesis, not a law of RecurseWright: some of the continuity we care about may survive passage between computational, cognitive, social, and material forms without belonging exclusively to any one of them.

That sounds abstract until you notice how often ordinary engineering already depends on it.

A production incident changes a person.
The person changes a review habit.
The habit changes what an AI is allowed to infer.
That changes a test.
The test later constrains code written by somebody who was never present for the incident.

There is no single object traveling through that sequence.

But neither is the sequence imaginary.

And this created a new problem.

If continuity can cross substrates, then preserving the carriers is not enough.

We also need some way for what mattered in the crossing to remain causally available on the other side.

Nothing Crosses Untouched

If continuity can cross substrates, then the next question is not whether something survived the crossing.

It is what survived, what did not, and what changed shape on the way through.

That mattered because continuity is not the same thing as perfect preservation.

A note can preserve a decision and lose the hesitation that made the decision careful. A test can preserve a constraint and lose the story of the failure that gave it meaning. A prompt rule can preserve caution and lose the surrounding judgment that once kept that caution proportional.

The passage continues.

But it need not continue untouched.

That was the reason I stopped treating the crossing as lossless.

Continuity can survive even when some context, precision, or proportion does not survive intact.

Some loss is often practical, and sometimes unavoidable.

A working system rarely carries every trace, every tone, every uncertainty, every discarded option, every local nuance of the original moment. Trying to preserve all of it can make the system heavier without making the next judgment wiser.

So loss is not automatically failure.

Often it is the price of movement.

What matters is whether what survives is still faithful enough to support the next judgment well.

That is the sense in which I use fidelity here. Not purity. Not exact duplication. Not archival completeness. Fidelity is simply the degree to which what emerges on the other side still carries what was causally important in the first place.

And that is where things become interesting.

Because loss is not the only possibility.

There is also distortion.

Distortion is harder to notice, partly because it often arrives looking organized. A simplified rule can seem cleaner than the original judgment. A test can look more objective than the failure that produced it. A repeated AI instruction can sound more stable than the uncertainty it quietly erased.

But a passage can remain continuous and still become misleading.

Something does survive.

Just not always in the right proportions.

A cautious local workaround can harden into a false general rule. A context-sensitive judgment can flatten into ritual. A useful artifact can continue shaping work long after the reason for trusting it has evaporated.

And then continuity starts doing a stranger kind of damage.

It preserves consequences, but carries them forward under altered meaning.

That was the point at which I stopped thinking of preservation as a yes-or-no property.

The more useful question became: preserved with what fidelity, and at what cost?

Once that question appears, the work changes again.

We are no longer trying merely to keep things from disappearing. We are trying to make the passages inspectable enough that we can notice what was lost, what was transformed, and what may already be asking for re-judgment.

The Passage Becomes Part of the Work

Once I started thinking in terms of fidelity, the crossing itself stopped being invisible.

Before that, I had mostly looked at what existed before a transition and what existed after it. A decision became a rule. A failure became a test. A conversation became a change in method. If the result still seemed useful, the passage between the two was easy to ignore.

But once complete fidelity is no longer assumed, that shortcut becomes harder to defend.

Because now the passage has properties of its own.

Something may be preserved well enough to keep moving. Something may lose detail without losing its causal usefulness. Something may arrive distorted enough that carrying it forward would be worse than stopping to look again.

I began to treat that as a working shape:

Not a universal algorithm, and certainly not a claim that fidelity can always be reduced to a clean numeric score.

cross → inspect what survived → judge what it may still justify → retain, reject, or re-judge

The transition is no longer treated as empty space.

A passage can now become something we inspect.

And once that happens, a curious possibility appears. The next state does not have to inherit every surviving consequence merely because it survived.

A consequence can make it across and still fail the next judgment.

That sounds almost trivial, but it closes a surprisingly large loophole.

Without that second look, persistence easily turns into authority. A rule survives long enough, so we assume it still deserves to rule. A test keeps passing, so its premise quietly becomes unquestionable. An old architectural constraint remains visible in enough places that people stop asking whether the world which produced it still exists.

RecurseWright cannot treat survival as sufficient evidence of continued validity.

If something persists, that tells us something about its history.

It does not settle its future.

So the passage needs two different kinds of attention.

One asks: did enough survive?

The other asks: does what survived still deserve to shape what comes next?

Those questions are related, but they are not interchangeable.

A nearly perfect copy of a bad assumption has excellent fidelity and terrible consequences. A heavily compressed trace of an old incident may preserve exactly the one constraint that still matters. Sometimes loss damages meaning. Sometimes loss removes noise. Sometimes distortion is obvious. Sometimes it looks like clarity.

Which means inspection cannot end at transmission quality.

Eventually it has to return to judgment.

And this was the point where the increasingly strange picture of RecurseWright began to look, unexpectedly, more like engineering again.

Not because the uncertainty disappeared.

Because there was now somewhere to put it.

What the Run Refuses to Collapse

By then, the earlier skeleton had become compact enough to revisit, and one part of it deserved a closer look than I had first given it.

Observation. Inspection. Evidence. Judgment.

Those are close neighbors, but they are not synonyms.

An observation notices.
Inspection looks closer.
Evidence supports a particular claim after scrutiny.
Judgment decides what that evidence is allowed to mean for action.

That separation turned out to matter more than I expected, partly because engineering habits are very good at collapsing it.

We notice something and act as if we already understand it. We gather traces and treat them as if they already justify a conclusion. We produce evidence and quietly let it harden into judgment without ever admitting that a choice was made.

RecurseWright slows that collapse down.

Not to make the work ceremonious.
To keep it honest.

And then comes the part I had not fully appreciated at first.

Judgment does not produce only change.

Sometimes it produces change, of course. A method shifts. A guardrail appears. A test is added. A boundary gets redrawn.

But sometimes the most truthful outcome is NO CHANGE.

Or DEFER.

Or even a more careful return later with better criteria.

Those outcomes matter just as much, because they still shape Sₙ₊₁.

A decision not to move is not the same thing as no consequence. A deferred judgment can preserve uncertainty explicitly instead of letting it leak invisibly into habit. A refusal to act can become a retained consequence if it changes what the next encounter is allowed to assume.

A deliberate DEFER still leaves something behind: a reopening condition naming what would have to become true, arrive, fail, or change before the question deserves another run.

That was when the recursive part of RecurseWright began to feel less decorative and more precise.

The next state is not merely what remains after action.

It is what remains after passage.

And passage includes not only what changed, but also what was kept, what was withheld, what was doubted, what was judged insufficient, and what was deliberately carried forward unresolved.

That is why retained consequences sits so close to the exit of the run.

What survives the passage does not vanish back into the background. It conditions the next one.

The next signal does not arrive in a neutral world. It arrives in Sₙ₊₁, a state already shaped by previous crossings, previous inspections, previous judgments, and previous refusals to pretend that evidence and judgment were the same thing.

Work returns.
But it does not return empty.

From Boundary to Boundary

Sₙ₊₁ can sound more dramatic than it is.

It is not a new world. Most of the time, it is simply the next state in which the work can become quiet again: enough has been inspected, enough judged, some consequences retained, some uncertainty deliberately left unresolved.

That changed how I understood the boundaries we had been meeting all along. A boundary was not merely something crossed during an EvolutionRun, and the run was not a machine for producing a better state on the other side. The two belonged to the same movement.

A sufficiently stable state can remain almost invisible while it works. Then somewhere, sufficiency thins. A result no longer fits its explanation. A tool begins asking for trust it has not earned. A method starts producing answers that are technically correct and somehow wrong. An old decision reaches farther than its evidence ever did.

That visibility is the signal: not always a demand to cross, not always even a demand to change anything, but an invitation to find out whether the present arrangement is still sufficient.

That was when “from boundary to boundary” stopped sounding like a metaphor to me.

RecurseWright was not progressing toward a final configuration. It was moving between provisional sufficiencies.

And Sₙ₊₁ is not defined by how many things changed. It is defined by what the passage has made true, available, constrained, doubtful, or deliberately preserved for what comes next.

Close, but Not Quite

By this point, a reasonable reader might suspect that RecurseWright is simply a disciplined way of running experiments.

That suspicion is not wrong.

In fact, it is one of the more useful temporary models the article can produce.

A signal appears. Something becomes questionable. We inspect the passage, gather evidence, decide whether enough survived, retain consequences, and continue. From a certain distance, that can look very much like an experimental loop.

And sometimes it is.

A small experiment may be exactly the right response to a newly visible boundary. We may change one condition, observe the result, preserve what the result entitles us to preserve, and let that shape the next state. RecurseWright has room for that, and real room - not decorative room.

But if I say that RecurseWright is an experiment, something important immediately slips away.

An experiment is one possible move inside an EvolutionRun.

It is not the whole run.

Many runs do not need an experiment at all. They may need a better question, a trace back through an old decision, a conversation with a person, a refusal to overgeneralize, a deliberate DEFER, or the recognition that the boundary is visible but not ours to cross.

Even when an experiment does occur, it does not settle the run by itself.

It may produce evidence without settling judgment, and judgment still need not produce change.

The passage is broader than the intervention.

The run includes how the signal was noticed, what was considered worth inspecting, what counted as evidence, what was judged insufficient, what was carried forward unresolved, and how those consequences altered the next sufficient state.

An experiment can illuminate a passage.

It cannot replace one.

There was another reason the equation did not quite collapse into experiment.

Experiments usually rely on a helpful intuition: there is a setup, something is varied, and we observe what follows.

But in the kind of work RecurseWright kept drawing my attention to, the setup itself was often part of what moved.

The criteria could sharpen while we were using them. The boundary we thought we were testing could shift under inspection. A tool could change not only the answer, but the shape of the question we were capable of asking next. A person could leave the run with the “same” practice and a different responsibility toward it.

So the movement was not always confined to the object under examination.

Sometimes the surrounding arrangement moved too.

That made “experiment” too small a word.

Not because it was false.

Because it was local.

Experiments belong inside RecurseWright.

They simply do not define its full geometry.

And once that became clear, another question began to press more firmly than before:

if not only the moving part, but sometimes the medium around it can change, then what exactly are we tracking when we say that the work continues?

The Ground Moves Too

Once experiment became only one possible move, the earlier idea of a changing environment needed one more extension.

Some of those surroundings were already participating in the passage. A prompt could change what AI inferred next time; a review habit what a person noticed; a test what future implementations could survive; an authority decision who could legitimately decide next.

They had not merely received the result. They had become part of the conditions of what followed.

A boundary made this especially visible.

Earlier, it had been useful to think of a boundary as something encountered: the point where the current arrangement stopped being silently sufficient.

But inspection could change the boundary itself.

Sometimes we discovered that it had been drawn in the wrong place. Sometimes two boundaries turned out to be one. Sometimes what looked like a technical limitation was really a question of authority. Sometimes the boundary stayed exactly where it was, but we now understood why it was there and what would have to become true before crossing it made sense.

The passage had affected the place through which the passage occurred.

This was different from simply producing a new state.

Sₙ₊₁ did not contain only changed objects.

It could contain changed relationships between objects that individually looked almost identical.

The same human.
The same tool.
The same method.
The same artifact.

And still, not quite the same arrangement.

A method might now be trusted in a narrower domain. An AI might be given less freedom in one class of decision and more in another. A person might retain the same practice but know which assumption underneath it remains provisional. An unchanged artifact might acquire an expiration condition it never had before.

An expiration condition did not have to be a date. It could simply name what would make the artifact deserve re-judgment.

Nothing dramatic needs to move for the geometry to change.

That was one of the harder ideas to see, because software gives us such good habits for locating change.

There is a diff.
A new version.
A changed row.
A new file.

But some consequential changes do not have a natural diff.

They live in relations.

What may this tool now decide?
What does this test still justify?
Who owns this boundary?
Which uncertainty must remain visible?
What is this artifact now allowed to mean?

Those questions can change while every object involved remains perfectly recognizable.

And suddenly from boundary to boundary acquired another layer.

We were not simply moving across a landscape of pre-existing boundaries.

Some passages changed the landscape.

Not arbitrarily or every time, but often enough to matter.

The strange part was that this did not require RecurseWright to become one giant self-modifying creature.

The elements could remain distinct.

A person remained a person. A model remained a model. A method remained a method. A repository did not somehow become a conversation.

Their differences mattered.

What changed was how they could participate in what happened next.

What I did not want to lose was this: mutual influence does not require uniformity.

The system did not need every element to converge toward one central logic.

In fact, that would have destroyed part of what made the arrangement useful.

Different elements could retain different capabilities, limits, histories, and kinds of agency while still altering one another's future conditions.

That left me with a more difficult picture than the one I had started with.

The work was moving.

The boundaries could move.

The relations between elements could move.

And some elements could remain externally still while their role in the trajectory changed.

So what, exactly, was the stable background?

For a while, I kept looking for one.

A repository was too small.
The human participants were too partial.
The AI was obviously not it.
Methods changed.
Artifacts disappeared.
Boundaries moved.

Even the substrates through which continuity passed were not permanent homes for it.

There was still continuity.

But less and less of it could be explained by pointing to one thing and saying:

there - that is what persists while everything else changes.

Perhaps that was the wrong kind of stability to look for.

Maybe the Rule Was Stable

There was, however, one candidate left.

The procedure itself.

By now the shape was becoming familiar:

signal → inspect → evidence → judgment → retained consequences → next state

Carriers could change. Boundaries could move. Relationships could be rearranged. Perhaps continuity did not need any of them to stay fixed because the grammar of the passage did.

For a while, that explanation worked surprisingly well.

It even made the diagrams feel reassuring.

The objects could move as much as they liked, as long as the machinery that handled their movement remained stable.

But then the same problem appeared one level higher.

What if inspection changed what we were willing to count as evidence, or repeated runs showed that a boundary was being noticed too late?

What if a tool made one stage cheaper while introducing a kind of distortion the existing procedure did not know how to see?

What if the distinction between two steps turned out to matter more than we had thought - or less?

Then the procedure was no longer standing outside the thing being examined.

It had entered the field.

That was uncomfortable, because a fixed method is wonderfully convenient. It gives us somewhere to stand while everything else changes.

But freezing the method also freezes its assumptions.

And once those assumptions become part of the problem, stability starts looking suspiciously like protection from evidence.

So the next move could not simply be:

everything may evolve except the process that decides how evolution works.

That would give RecurseWright a very elegant blind spot.

The method had to be inspectable too, without becoming casually mutable. A method that can change without constraint is not adaptive; it is unreliable.

But if evidence repeatedly exposes a weakness in the way a run is conducted, then the rules of the run cannot be permanently exempt from judgment.

That changed the picture again.

An EvolutionRun was not the immutable engine underneath RecurseWright. It was a current working form of passage: useful enough to stabilize work, explicit enough to inspect, and, if reality eventually earned the right to demand it, revisable.

This was the first point where recursion stopped meaning merely “the next run carries consequences from the previous one.”

The consequences could eventually reach the way runs themselves were made.

A changed tool could alter a method.

A changed method could alter what future evidence became visible.

That new evidence could, in turn, justify another change in the method.

Not every time, and not automatically. But the method was no longer outside the causal field.

And if the method could move too, then my search for the one stable layer underneath RecurseWright had failed again.

There might not be one.

Not Everything Is Up for Grabs

That conclusion suggested an easy next step, and for a moment I almost took it.

If the carriers can change, the boundaries can move, the relationships can rearrange, and even the method can eventually be revised, then perhaps RecurseWright is simply fluid all the way down.

Everything can move.

Everything can evolve.

Nothing is sacred.

That sounds liberating.

It is also a very efficient way to make continuity meaningless.

A system in which anything can change for any reason is not especially evolvable. It is merely difficult to trust.

For a passage to be inspectable, something about it has to resist arbitrary movement long enough for comparison to mean anything. Evidence needs criteria. Judgment needs authority. A method needs enough stability to be used before it can earn a reason to change.

Even revision needs a boundary around revision.

So the discovery that the method could move did not make RecurseWright liquid.

It made the conditions of movement more important.

A method could change - but not because novelty was exciting.

A boundary could move - but not because crossing it was convenient.

A retained consequence could lose authority - but not because the next run preferred a cleaner story.

Change had to earn its way into the next state.

And that meant different parts of the system could have very different relationships with change.

Some could be revised cheaply.

Some only after accumulated evidence.

Some could be replaced.

Some could refuse a proposed change and remain exactly where they were.

And some should never become writable merely because the system had learned how to write.

That last category mattered most around the human.

RecurseWright could change the information available to a person, the questions placed in front of them, the tools they could use, even the consequences of earlier decisions.

It could not turn that influence into ownership of the person.

Mutual influence was not permission to collapse autonomy.

This was where “every element can evolve” needed a correction of its own.

Can was a possibility, not an instruction.

It did not mean that every element should be made equally mutable, or that evolution meant becoming progressively more aligned with one central logic.

A human can evolve without becoming more obedient to the system.

A method can evolve without becoming more permissive.

A tool can evolve by losing authority.

An artifact can evolve by becoming less central.

Sometimes the most meaningful change is a reduction in reach.

That made the system less like a liquid and more like a field of differently constrained participants.

Influence could travel.

Consequences could cross substrates.

Boundaries could shift.

Methods could be revised.

But none of those facts erased the differences between the things involved.

The differences were part of what made the movement legible.

If everything had the same authority, the same mutability, the same memory, the same kind of agency, there would be very little left to inspect.

So perhaps the continuity was not hiding underneath all this motion after all.

Perhaps it was partly produced by the discipline of how motion was allowed to occur.

Not one fixed substrate.

Not one immutable method.

Not one permanent boundary.

But neither unrestricted change.

Something closer to:

change what reality has earned the right to change, preserve what still has reason to resist, and carry enough of the encounter forward that the next movement does not begin from fiction.

That was a much stricter idea than fluidity.

And, strangely, a more alive one.

What Still Has to Hold

Once change was no longer assumed to be good merely because it was possible, another question became unavoidable.

If so much can move, what has to remain true for the movement to still belong to RecurseWright?

Not the exact method, the current boundaries, the carriers, the artifacts, the tools, or even the particular arrangement of participants. All of those could change.

So whatever made the system recognizable could not simply be another object hidden underneath the others.

It had to be something more like a condition on change.

A change could be large and still belong; a change could be small and already violate it. Size was not the test.

A new method might radically alter how an EvolutionRun is conducted and still preserve the separation between evidence and judgment.

A new tool might replace an old one entirely and still respect the authority boundary around what it is allowed to decide.

A human might reject the system's recommendation, alter the method, or leave a boundary untouched - and the system would still remain itself precisely because that autonomy had not been collapsed.

Yet a seemingly minor convenience could do more damage than a major redesign if evidence quietly became judgment, retained consequences became unquestionable rules, a tool acquired authority merely because it had become capable, or uncertainty was erased because the interface had nowhere convenient to put it.

The shape might still look familiar.

But something more important would have changed.

This was the first time I stopped looking for stability as substance.

What mattered was not that some component remained untouched.

What mattered was that some distinctions remained enforceable.

That evidence was not allowed to promote itself into judgment.

That influence did not become ownership.

That persistence did not automatically become authority.

That uncertainty could survive without being forced into an answer.

That change itself remained answerable to something other than the desire to change.

Those were not frozen implementations.

They were constraints on what counted as a legitimate next state.

There is a close relative here in evolutionary architecture, where fitness functions are used to protect architectural characteristics as a system changes. RecurseWright can evolve its architecture too; the scope here is different because architecture is only one participant among several. Methods, tools, artifacts, AI participation, human practice, and the relations among them may change as well. What has to survive is not one preferred shape, but enough of the distinctions that make those changes inspectable.

Those constraints gave Sₙ₊₁ a sharper meaning too.

It was not merely whatever state happened to exist after the run.

It was a state the passage had earned.

Not because every decision was correct.

Not because every loss had been prevented.

Not because the system had somehow solved itself.

But because the movement from Sₙ had remained inspectable enough, bounded enough, and accountable enough that the next state still belonged to the same causal discipline.

That was a different kind of continuity.

Not continuity of material.

Not continuity of configuration.

Not even continuity of method.

Continuity of constraint.

Or perhaps, more carefully, continuity of what the system refuses to let change accidentally.

That distinction felt important enough that I did not want to rush past it.

Because a system capable of changing almost anything becomes trustworthy only when it is equally clear about what change is not allowed to smuggle in.

And somewhere around there, RecurseWright stopped looking like a mechanism for managing change.

It began to look like a mechanism for deciding what change is allowed to mean.

The Same System?

The two runs above can look almost identical: the same stages, the same kinds of artifacts, the same tools.

And yet one of them may no longer be doing the same thing.

A system does not necessarily stop being itself when its components change.

But neither does it necessarily remain itself because its components stayed.

RecurseWright could keep every familiar box in the diagram and still lose something essential if the relations between those boxes quietly collapsed the distinctions the passage was supposed to protect.

Nothing obvious would need to break; the machinery could continue running.

That made identity a much less comfortable property than version numbers usually suggest.

A repository can tell me that the implementation changed.

It cannot, by itself, tell me whether the change preserved the discipline that made the implementation RecurseWright in the first place.

And the reverse was equally strange.

A future RecurseWright might look very different from the one described in this article.

Different stages, tools, artifacts, perhaps even a different working vocabulary.

Yet if its passages still required claims to earn authority, preserved uncertainty where certainty had not been earned, kept consequences inspectable, and refused to turn mutual influence into ownership, I would have a hard time calling it a different system merely because the surface had changed.

So identity could not live entirely in the surface.

But I was also wary of solving that problem by inventing some invisible essence underneath it.

That would only move the still point one level deeper.

What seemed more plausible was that RecurseWright remained recognizable through the way one state was allowed to become another.

Not a fixed shape.

A constrained passage.

That put the earlier formula in a different light:

Sₙ → ... → Sₙ₊₁

The arrow had been doing more work than I had given it credit for.

It was never just “then.”

It contained the conditions under which then was allowed to follow now.

This also explained why a perfectly preserved state could still be a dead end.

If I froze Sₙ, copied it flawlessly, and reproduced it forever, I would have preserved configuration.

I would not have preserved RecurseWright.

The system only became visible in motion.

But not in arbitrary motion.

That difference was beginning to feel like the center of the whole problem.

A state supported work; a boundary exposed where that sufficiency ended; an EvolutionRun bounded the encounter; retained consequences shaped what came next; and constraints kept movement from becoming indistinguishable from drift.

The pieces were beginning to lock together.

Not into a machine that wanted everything to change.

Into a system that could change without treating change itself as proof of progress.

And suddenly “from boundary to boundary” meant something slightly different again.

The boundaries were not simply landmarks along a trajectory.

They were places where the system had to prove, locally, that the next piece of trajectory still deserved to belong to the same one.

When the Arrow Goes Quiet

“Identity in the passage” was a useful correction.

It was also a little too neat.

Because most of the time, no passage is happening.

There is no visible boundary. No active EvolutionRun. No evidence being weighed against judgment. The system is simply being used.

Code gets written. Tools do their jobs. People make ordinary decisions. Artifacts sit quietly where they were left.

The arrow goes quiet.

And RecurseWright does not disappear.

That meant its identity could not exist only in the transition between Sₙ and Sₙ₊₁.

Something also had to survive between transitions: not a permanent method or a frozen state, but the ability of the current arrangement to become questionable again.

That was a different kind of persistence.

A method could be stable without becoming unquestionable.

A boundary could remain quiet without becoming invisible forever.

A retained consequence could shape ordinary work without acquiring permanent authority.

A tool could remain useful while still being allowed to lose trust later.

The state did not need to stay in motion.

It needed to remain capable of re-entering motion for the right reasons.

That was when the word evolvability became harder to avoid.

Not evolution as constant change.

Evolvability as retained capacity for justified change.

A state was not alive because it kept changing.

It was alive because reality could still reach it.

This also changed how I thought about stability.

A stable state was not one in which change had stopped. It was one in which change no longer needed to consume attention, while sufficiency still held.

And sufficiency was always contextual.

The same arrangement could remain perfectly adequate for months and become questionable in an afternoon because the API changed, the team changed, the model changed, the evidence changed, or simply because we finally noticed the assumption we had been standing on.

Nothing inside the state had to decay first.

Reality could move around it.

And eventually the old sufficiency might no longer reach far enough.

Then a boundary could become visible again, not because RecurseWright had failed to stabilize, but because stabilization had done its job: it had given the work somewhere to live until another question genuinely deserved the cost of movement.

That distinction saved evolvability from becoming restlessness.

A system that constantly revises itself is not necessarily more adaptive than one that never does.

It may simply be unable to settle.

RecurseWright needed both abilities:

to move when reality had earned movement,

and to remain still when it had not.

Those are not opposing modes.

They are what make each other meaningful.

Without stability, change has no reference.

Without the possibility of change, stability becomes enclosure.

And suddenly the earlier journey from boundary to boundary looked less like a sequence of transitions and more like a rhythm:

stable enough → boundary becomes visible → passage → stable enough again

Not a loop demanding progress.

A rhythm that permits rest.

That was an important correction to the diagrams too.

They naturally emphasize the interesting part.

Boxes, arrows, inspection, judgment.

But most real work happens in the spaces between them.

The purpose of an EvolutionRun is not to keep another EvolutionRun running.

It is to make another period of ordinary work possible.

And that gave Sₙ₊₁ one more property I had not seen at first.

It was not merely a state that had survived a disciplined passage.

It was a state capable of becoming insufficient again without treating that future insufficiency as failure.

So RecurseWright was no longer asking how to build something that remains correct. It was asking how to build an arrangement that can remain useful, become wrong in a discoverable way, and still have somewhere honest to go next.

Stable Does Not Mean Spent

There was one more thing hiding inside that picture of stability.

A state can settle without returning to zero.

Sₙ₊₁ may be quiet enough for ordinary work again, but the passage that produced it has not simply vanished. Some of its effects remain distributed through the arrangement: a narrower trust boundary, a question that now comes to mind sooner, an uncertainty that has been kept visible, a method used with different caution, a tool whose authority is no longer quite what it was.

The state is stable.

It is not spent.

I needed some way to keep that distinction visible, so for the moment I will write it as:

Sₙ₊₁(r)

where r is not a score and certainly not a claim that the system stores some measurable quantity of “evolution.”

It is only shorthand for a residual disposition - the directionality left in a state by what it has already passed through.

That directionality does not predetermine the next change; it means only that the next encounter does not happen to a blank state.

The same external event can meet two apparently similar systems and produce very different consequences because they carry different residual dispositions toward what to inspect, what to distrust, what uncertainty to preserve, or which boundary deserves attention first.

And the impulse does not always have to arrive from outside.

An unresolved contradiction can remain quiet for weeks before becoming relevant. A retained consequence can collide with a new requirement. A method can begin exposing a weakness in itself simply because it has now been used often enough for the pattern to become visible.

So “external” and “internal” were useful only locally.

They described where an impulse appeared relative to the boundary I was looking at.

They did not divide the world into two permanent kinds of cause.

That mattered because it changed the role of Sₙ₊₁ again.

It was no longer merely a destination reached after a run.

It was a participant in whatever happened next.

This gives evolvability a slightly different shape.

A system does not remain evolvable merely because change is technically possible.

It remains evolvable because previous passages can alter its capacity to meet later ones without locking the answer in advance.

That is a delicate balance.

If nothing from a passage survives, the next encounter begins from amnesia.

If too much hardens into prescription, the next encounter begins from a script.

Evolvability lives somewhere between those two failures.

Enough survives to alter responsiveness.

Not enough is predetermined to make judgment unnecessary.

That was the part I had been missing when I thought of stable states as places where motion temporarily stopped.

The motion had not necessarily stopped.

Some of it had become disposition.

A different readiness.

A changed sensitivity.

A different distribution of resistance.

No EvolutionRun needed to be active for those differences to matter.

And this made the old image of stream and banks suddenly more concrete.

The stream could affect its banks.

The banks could alter the next stream.

But now the “banks” were not simply passive boundaries reshaped by flow.

They included what the previous passage had made the current state capable of noticing, permitting, resisting, and questioning.

The next boundary, then, was not always sitting in the landscape waiting to be discovered.

Sometimes it became visible only in the encounter between what arrived and what the state had become.

That was a more unsettling idea.

Because if a signal depends partly on what can receive it, then even the beginning of an EvolutionRun is not as simple as it first appeared.

The Beginning Has a History

The diagram above introduced a consequence I had not expected.

I had been drawing a signal as the beginning of an EvolutionRun.

Something happens.
It becomes relevant.
The run begins.

Clean enough.

But Sₙ₊₁(r) made that beginning less innocent.

The same event can meet two outwardly similar states and become important to one of them in a way it does not to the other. Or it can make a different boundary visible. Not because reality changed between the two encounters, and not because either state is free to invent whatever meaning it likes.

Because the states arrived with different histories of responsiveness.

So an event and a signal were not quite the same thing.

An API response can exist whether anyone notices it or not. A colleague can make the same observation twice. A model can produce the same strange answer. A production metric can cross the same numerical threshold.

Those are occurrences in the world.

They become signals for RecurseWright when they meet a state for which they are capable of disturbing sufficiency.

event → encounter with current disposition → possible signal

Not a formula. More like a reminder that relevance happens in an encounter.

One more comfortable fiction disappeared from the diagrams.

The beginning of a run was not outside history.

Previous passages could change what the next state was capable of noticing, what it would dismiss as noise, which contradiction would feel ordinary, and which tiny mismatch would suddenly make an old boundary visible.

The consequences of one EvolutionRun could therefore alter the conditions at the beginning of another.

That was a much more interesting kind of recursion than a loop.

A simple loop diagram suggests a return to the same place.

This did not.

Sₙ → passage → Sₙ₊₁(r)

and then, later:

event → encounter with Sₙ₊₁(r) → signal?

The question mark mattered.

Nothing in the previous run got to pre-write the answer.

Residual disposition could alter sensitivity. It could not abolish judgment.

Otherwise RecurseWright would eventually become a machine for confirming its own history: previous runs would determine what could be noticed, what could be noticed would determine future runs, and the whole thing would slowly learn how never to surprise itself.

That would be recursion of a sort.

Just not a very useful one.

So evolvability required another tension.

History had to matter enough to change responsiveness.

Reality had to remain free to contradict that history.

A state could become better prepared for one class of encounter and, because of that same preparation, become less sensitive to another. A method could learn where failures usually hide and begin looking there earlier - while creating a new blind spot somewhere else. A human could develop an excellent instinct for one kind of architectural debt and become slightly too quick to see it where the real problem was authority.

No retained disposition was entitled to call itself complete.

And now the latent inspection points in the earlier visual made more sense.

They were not emergency exits from stability.

They were ways for stability itself to remain corrigible.

This gave the phrase reachable by evidence later more weight than I had intended when we first drew it.

Evidence did not merely need a route into the next judgment.

It needed the ability to challenge the very disposition produced by earlier evidence.

That is a harder requirement.

It means yesterday's successful adaptation cannot become tomorrow's immunity from contradiction.

And somewhere there, the recursive shape finally stopped looking circular to me.

The previous passage changes the conditions of the next beginning.

The next beginning can expose limits in what the previous passage changed.

And what follows can alter those conditions again.

Not return.

Return-with-history.

But also, crucially, history-with-an-open-door.

It Was Starting to Look Like a Methodology

By now, RecurseWright had acquired enough structure to become dangerously easy to recognize.

There were states and boundaries. Signals and passages. Evidence, judgment, retained consequences. There was even a way for the method itself to become revisable without dissolving into arbitrary change.

Put enough of those diagrams beside one another and a familiar conclusion begins to form.

This is a methodology.

I could hardly blame anyone for arriving there.

I had arrived there too.

A methodology would be a comfortable place to stop. It could give us a vocabulary, a sequence of moves, perhaps a few reusable diagrams and rules. Different teams could learn them, apply them, compare outcomes, improve the practice.

And much of that would even work.

The trouble was that the more faithfully I followed RecurseWright, the less certain I became that the same description of RecurseWright should determine the same concrete result twice.

Not because the method was vague.

Because the state was not empty.

It arrived with history.

Its boundaries were local. Its authority was local. Its retained consequences were local. The people, tools, artifacts and uncertainties participating in the passage were not interchangeable. Even a state that had settled could retain a directionality produced by what it had already survived.

So two passages could respect the same distinctions, use the same vocabulary, and remain recognizably RecurseWright...

without becoming replicas of one another.

That sounded simple enough when written down.

I wasn't sure it was simple enough to believe.

Let's go back into the work.

The past became richer.

The future became wider.

Safer?

For whom, under which conditions, and what would we need to observe to know?

What we might do next was already changing what we needed to establish here.

The present became more precise.

RecurseWright is shared, but never instantiated identically.

---

One quick question for you: What did AI change in you before it changed your work?

---

Beyond the Article

To the colleagues who challenge a thought at the right moment, the teachers who change how I notice, and the readers who lend their attention and questions: thank you.

You are part of the work even when you do not appear in its diagrams.

Useful links

Rachel Laycock, "The Conductor Developer" - martinfowler.com, 31 July 2026. https://martinfowler.com/rachels-ramblings/conductor-developer.html

Rachel Laycock, "Why I'm Writing Rachel's Ramblings" - martinfowler.com, 28 July 2026. https://martinfowler.com/rachels-ramblings/intro.html

Neal Ford, Rebecca Parsons, Patrick Kua, Pramod Sadalage, "Building Evolutionary Architectures", 2nd edition - O'Reilly, 2022.

Giorgi Kobaidze, "Show Me the Article You're Most Proud Of And I'll Read Every Single One of Them" - DEV Community. https://dev.to/georgekobaidze/show-me-the-article-youre-most-proud-of-and-ill-read-every-single-one-of-them-1l53