Most mornings now I move through three levels of a business before lunch.

Board-level questions early: what we’re doing, why, whether the direction still holds. By mid-morning it’s operational — how to break a body of work into pieces that can actually be executed, which questions have to be settled first so everything downstream runs clean. Then an afternoon hour arguing about an implementation three functions deep. These used to be different jobs. They used to be different points in a career, and getting from one to the next took years and somebody’s permission.

The tempting description is that everyone’s a project manager now, and I’ve caught myself saying it. It’s wrong in a way that matters. A project manager was someone who occupied one level and didn’t descend, and the role existed because the levels were separable: somebody had to stay put and translate between them. That translation is what the artifacts do now. The spec is the interface between the level where you decide what matters and the level where somebody builds it, which is precisely the job the role was invented for. The translation stopped being labour and became an artifact. A project manager’s version was continuous and interpersonal, made of meetings and corrections and someone carrying intent between rooms. A spec is written once and handed to something that executes without a person on the other end, and that is what lets one person stand on all three levels at once.

What made me notice was smaller and stranger than the job change. When agent skills started appearing, the noise was all about teaching machines technical capability, and what I actually reach for most days is method. Matt Pocock’s set is the one I’ve used most: grill a hazy idea until it’s concrete, turn the conversation into a spec, break the spec into thin vertical slices, implement, review. One of them is called wayfinder, and its whole job is planning work too big for a single agent session. Its documentation says, flatly, that it plans and does not build. Another enforces a glossary before anything gets built on top of it.

None of that is a technical skill. It’s requirements analysis, a decision record, a work breakdown, and a phase gate.

Which should worry anyone who was paying attention between about 1995 and 2010. The industry didn’t abandon those artifacts because engineers were lazy or contemptuous, though we were both. It abandoned them because they didn’t work. You can’t know the requirements in advance, so the elaborate document is a confident description of the wrong system, and the effort spent producing it is effort spent being wrong more expensively. Agile’s actual argument was never that documents are bad. It was that feedback is cheaper than planning.

Implementation cost has now collapsed, which makes finding out cheaper than it has ever been. By the plain reading I should be planning less than at any point in my career, generating the thing three times and picking the one I like best. Instead I’m writing more specs than I did when code was expensive. There’s an obvious answer to that, and it’s a decent one: when the economics of a practice flip, the practice becomes viable again, and big design up front failed because doing it properly cost weeks where it now costs an afternoon. That’s partly right, though it isn’t the thing that changed for me.

What I’m compensating for is that the thing doing the work can’t remember anything. No continuity between sessions, no recollection of the argument we had on Tuesday, no accumulating sense of why the codebase is shaped the way it is. Big design up front degraded on contact partly because the team’s real understanding lived in the heads of people who’d been there eight months, and the document was a lossy snapshot of something that mostly lived elsewhere. Now there is no elsewhere. The artifact isn’t a plan. It’s memory.

Except that isn’t the whole of it either, and I worked out why by watching a piece of the apparatus die.

A year ago it was worth writing very detailed execution plans, and the reason was money. You had an expensive model that was good at thinking and a cheap one that was good at typing, and the plan was the interface between them — the smart one wrote it, the cheap one carried it out. As the price of the good models came down I stopped needing to over-specify. Not because I got better at it. Because the arbitrage went away. Part of what everyone is calling methodology was never methodology at all. It was a handoff protocol between an expensive model and a cheap one, dressed as engineering discipline, and it evaporated inside a year. The same document had been doing interface work twice over: between two levels of a business, and between two tiers of model. Only one of those jobs had a future.

So the pile of documents on my disk is at least three different things wearing one costume, and they have different lifespans. Some of it was cost arbitrage, and that’s going. Some of it is memory for something that can’t remember, which is a limitation several extremely well-funded companies are attacking directly, and if they win it goes too. And some of it is for other people, which sounds like the dullest of the three and is the only one without a clock on it.

There’s a serious objection to all of this, and it belongs to someone who has spent more time with these systems than I have. Birgitta Böckeler, a distinguished engineer at Thoughtworks, worked through Kiro, spec-kit and Tessl, the three most prominent spec-driven tools, and came away unconvinced. Her verdict on the artifacts was blunt: “I’d rather review code than all these markdown files.” The sharper charge is the one I keep returning to. She writes that she frequently saw a false sense of control. Her complaint isn’t about tedium: reading code is tedious and it tells you what’s true, where reading a spec tells you what somebody intended, which may bear no relationship to what exists, while producing the sensation of having checked. Reading every pull request isn’t feasible either, but if both are infeasible and one of them additionally manufactures confidence, hers is the better failure. Unreviewed code at least doesn’t lie to you about having been reviewed.

I can’t answer that with the thing I actually have, which is that it feels like it’s working, because confidence is the quantity in dispute. And the version of her charge that lands hardest is one I arrived at on my own. I read the map. An agent traverses what’s beneath it and reports back. Another checks the implementation against a spec a third one wrote out of a session I ran. The middle of that pipeline is boring and I skim it. The verification chain terminates inside the same system it is verifying, and the artifacts are what make that comfortable enough to live with. She might be wrong. I’m unfalsified, which is a weaker and different thing.

What I’d say back is narrow: it answers her complaint about volume and does nothing about the termination, because a better-shaped artifact is still something I read instead of the code, and still something an agent wrote for me. What it answers is shape. The systems she tested hand you markdown in proportion to the work, and Tessl goes furthest, treating the spec as the source and marking the generated code do-not-edit. A document is read front to back or not at all, which is how you get a folder nobody opens. What I’ve ended up with is closer to a graph. A map sits at the top, broad enough that four people can argue about it in a meeting, with everything else hanging beneath it and traversed on demand rather than read through. Sessions stop before the model’s attention degrades instead of running until the context is exhausted. The glossary pins what the words mean, which is the one artifact that doesn’t get worse for being complete. Nobody reads the whole thing and nobody is meant to. Her verdict is right about what she tested and I don’t think it generalizes.

Unreviewed code at least doesn’t lie to you about having been reviewed.

The numbers do not flatter me here. Faros AI ran two years of telemetry across 22,000 developers and more than four thousand teams : moving from low to high AI adoption, incidents per pull request are up 242 percent, and pull requests merged with no review at all, human or agentic, are up 31 percent. Median review time is up roughly fivefold, which on its own could mean more scrutiny — the incident figures say otherwise. A Google DORA survey found thirty percent of respondents reporting little to no trust in AI-generated code while more than eighty percent believed it had made them more productive. DORA calls the gap the verification tax. None of that describes review moving upstream into better specifications. It describes review being quietly dropped.

Those are population figures, describing what everybody is doing rather than what any particular practice achieves, and the temptation is to say they don’t bind me. The tool is indifferent and the method is the variable, and I think mine is better than the average. Everyone in that dataset thinks that.

And I am describing a practice here, for other people to use, which makes the number at population scale the relevant one rather than the number in my week.

There is a defence of the whole arrangement that I believe, and I want to be exact about where it stops. Responsibility doesn’t require inspection — it never has, and every command structure ever built has run on someone answering for what happened while they were asleep. A team lead answers for their team without micromanaging every decision, and being on the hook is what produces the discipline. But a team lead delegates to people who are themselves accountable. Every link in that chain is someone who can be held to it, who’ll be embarrassed, who carries it into next time.

Those links had names and job titles. The junior engineer who took the ticket was the accountable rung: someone who could be embarrassed by what they shipped, and who carried the embarrassment into the next thing they shipped. Those were never two properties. Embarrassment that persists is what learning is, which means the thing that made the junior an accountable link and the thing that turned them into a senior engineer were one mechanism running once. An agent has neither, and it doesn’t have them separately. The chain loses its middle, and nobody forms judgment in the space where the middle used to be. The accountability didn’t move down the chain. It contracted.

I’ve argued before that engineers who never wrote code by hand won’t have the instinct to feel when generated code is subtly wrong. That’s the weaker version of the worry, and two hundred years of the same objection have flattened every version of it — apprentices stopped grinding pigment, programmers stopped writing assembly, and every senior generation has been certain the next was being cheated of the suffering that formed them. The stronger version is structural. The tactical rung wasn’t only training, it was rate limiting: it kept the surface area small enough to survive while judgment formed. Entering at the top is possible and I’ve watched it work, but it means learning to articulate intent, manage agents, read technologies for their failure modes and judge what comes back, all at once, with no bounded box to stand in. I find the breadth taxing and I’ve had twenty years to build up to it. The people currently doing this well were produced by a ladder that isn’t there anymore.

The accountability didn’t move down the chain. It contracted.

Two of the three things in that pile have expiry dates on them. The arbitrage is nearly gone. The memory problem is a limitation, and limitations get engineered away — I’d bet on the labs over my markdown, and sooner than I’d like.

What’s left is the one I called dullest. Other people. I can’t share an understanding I haven’t put outside my own head, and no model release changes that. You cannot delegate work you can’t articulate, which is a fact about you. Add a second person with their own agents and it doesn’t add, it multiplies: everything you knew and never said is now invisible to two humans and however many machines they’re driving, and none of them will tell you it’s missing. They’ll just proceed.

That’s the only part of this that survives the next two years, and it’s the part that was never about AI in the first place. The glossary is worth having because four of us disagreed about what a word meant and didn’t know it. The decision record is worth having because in March nobody will remember why we ruled the other thing out, and because whoever joins in October has no rung to stand on and nobody’s memory to sit next to. The documents supply the second of those and not the first. It’s half of what went missing, and it’s the half I can do something about.

I always knew that. Knowing was never enough to make me write any of it, because the payoff went to somebody else, later, and I was busy. It took a collaborator that couldn’t work without them, and the people those documents were always for are getting them by accident.