Enter the Fold

Before any of this, writing software already had a shape, and some of it was not even typing.

A programmer started by working out what to build — reading the problem, talking to whoever had it, sketching the data, reaching for a pattern that had solved something like it before. Often they didn’t work alone: two developers would pair at one keyboard, one driving and one navigating, because a second mind caught what the first drove past. Then came the loop everyone pictures: write a little, run it, watch it fail, fix it, run it again. And underneath that fast loop ran a slower one — the project teaching you what it actually was, the third week quietly redefining what the first week had been for. You held the whole thing in your head, and the holding was the job. The code was the residue the process left behind.

That practice was a stack of capabilities. It is worth naming them, because the story of AI in this work is the story of a machine climbing that exact stack, one rung at a time — matching each capability, then outrunning it.

Climbing the stack

The first rung was the lowest: recall. Autocomplete — Copilot at the cursor — matched the part of the craft that had gone to muscle memory, the API signature you had typed a thousand times, the boilerplate your fingers already knew. Then it surpassed it: the machine’s recall is total and instant, and nobody misses memorizing argument orders. But it reached only the keystrokes. Everything above stayed yours.

Above the keystrokes sat conversation. The chat assistant — a model in a side panel you talk to, paste into, argue with — matched something older than autocomplete: the pair at your shoulder, the navigator you think out loud to. It outran that pair in patience and recall, and it never wanted a turn at the keyboard. You were still driving; it navigated, and you kept what you chose. The keyboard stayed in your hands.

The next rung was production. Describe what you want and take the block that comes back — vibe coding, the term Andrej Karpathy coined in early 2025 for giving in to it. The machine matched the programmer’s knack for turning an intention into a chunk of working code, and surpassed it in speed: an afternoon’s work in the time it takes to read a paragraph. But it climbed past the keystrokes by leaving the discipline on the ground. Vibe coding matches the producing and skips the deciding and the iterating that used to surround it — which is why it feels like magic on a toy and comes apart on anything that has to last.

Then the loop. Hand the machine a goal it can check — a failing test, a spec to satisfy — and it will run the programmer’s inner loop on its own: write, run, read the error, fix, run again, until the light goes green. It matched the iterative core of the craft and surpassed it in stamina; it never tires of the four-hundredth iteration. This is the shape the field is settling on — Valentina Alto named it loop engineering in 2026: an autonomous cycle that finds the work, acts, checks, remembers, and goes again. It is a real advance. But notice its one condition: the goal has to hold still. The loop converges on a target that was fixed before it began. It matches the programmer’s loop exactly where that loop was easiest — where you already knew what done meant.

Above the loop, the graph. One agent cycling becomes many, wired into a network — steps and sub-agents with the work routed between them, run in parallel and merged at the end. It matched the senior developer’s other move: break the thing down, coordinate the parts, keep several threads alive at once. And it surpassed it in breadth — a person holds a few threads; the graph holds fifty. But the graph is still a lattice of fixed goals. Each node converges on its target. Nobody is learning what the thing should become while it gets built.

A fold, not a loop

Which leaves the last rung, and it was always the hardest, because it was never really about producing code at all.

Go back to the slow loop under the fast one — the project teaching you what it was, the goal moving because you were inside it, moving it. That is not a loop that converges. It is a loop that carries: each turn’s understanding folded into the next, the target shifting as the picture sharpens, and no green light at the end because the end was never fixed. A loop spins in place until it converges. This ratchets forward and never spins. The word for carrying a result forward across a sequence is not loop. It’s fold. Programming has the two shapes exactly. A map runs the same operation over every item and hands each result back on its own — nothing passes between them. A fold — some languages call it reduce — carries an accumulator: a running result that each step folds the next item into and hands to the step after, so the output of one turn is the input to the next. Loop engineering is the map, its runs independent. This is the fold — each result folded into the next, under a goal you are allowed to move. It needs a name of its own, set against Alto’s: not loop engineering but fold engineering — the shape that stops pretending the target stood still.

And what it folds is not only state. It’s attention. There is one loop the machine and the person now both hold in view: the machine attending by mechanism, weighting every token it reads; the person attending by judgment, deciding at every turn. The thing being built is neither the model nor the human but the loop the two of them keep together, each turn folded into the next, across the whole life of the work. That is the rung the machine has finally reached — the outer loop, the one where understanding accumulates and the goal moves.

The rung that never transfers

Trace the whole climb and something shows at the top. Rung by rung the machine matched a capability the programmer used to embody, then surpassed it — recall, production, iteration, coordination, and now the accumulating loop itself. Each time, a piece of the old craft came off the person and onto the tool.

But the ladder ends on the one thing that never transfers, because it was never a capability. Deciding what to build. Judging when the thing is actually good enough. Answering for the call. That is not a skill the machine can match and outrun; it is an accountability, and a tool answers for nothing. So the fold does not close the human out. It hands the machine the entire stack — all the way up to the loop that used to be the most human thing in the room — and leaves the person exactly one rung, the one at the top. The gate.

Not only software

The fold does not care what the artifact is. Watch a designer and a tool work a piece over many passes — wireframe, read it back, cut what stopped earning its place, go again — and it’s the same shape: gather, decide, carry forward, let the piece become what it’s turning out to be. Watch any hard problem worked over months, the question sharpening as the answer comes into view, and it’s the shape again. The artifact changes; the fold doesn’t. What’s being built here was never a better way to write software. It’s a way for a person and a machine to accumulate understanding across time — and software was only the first place it showed.

So the trajectory is not the machine walking toward the exit with your job under its arm. It is the machine climbing the stack of the old craft, rung by rung, until you are standing on the one rung that was never climbable — deciding, at the gate, from higher up than you could have reached alone.

---

On the names: “vibe coding” is Andrej Karpathy’s, coined February 2025. “Loop engineering” is Valentina Alto’s, from “Introducing Loop Engineering” (July 2026). “Fold engineering” is coined here, set against Alto’s term — a reduce, not a map.