A process is worth more now that an agent writes the code

Strip a software development process down to its bones and it is five things: decide what to build, decide how, build it, check it, ship it. Every team does all five whether or not anyone writes them down. A process just makes them happen in order, out loud, and on purpose instead of by accident.

The point of saying them out loud is timing. "What happens when this list is empty?" and "who is actually supposed to approve this?" are cheap questions to answer before anyone writes a line of code, and expensive ones to answer after. A process is a way of forcing those questions early, while they are still cheap.

Find the edge cases, name the things nobody has decided yet, put the real decisions in front of the person who should be making them. Do that consistently and the result is predictability: fewer surprises, less work redone, fewer features that quietly do the wrong thing.

That is the case for process in general. It gets more interesting once an agent, not a person, is the one doing the building.

Agents make the process worth more

The obvious objection: if an AI coding agent can write a feature in twenty minutes, who has time for all that upfront ceremony? The answer is that the ceremony is worth more now, not less, for three concrete reasons.

It wastes less effort. Point an agent at a vague instruction and it explores: it reads files it doesn't need, tries one approach, backs it out, tries another. Every file it reads and every attempt it backs out of costs tokens, and you pay for those tokens whether or not anything useful came out of them. A process that writes down exactly what the task is, checks that nobody already solved it, and hands the agent a finished plan means it starts where the last run left off instead of re-deriving everything from scratch. And when an agent and its reviewer start going back and forth without converging, something should notice and stop the loop rather than let it spin forever.

The output is better. Most bad agent output isn't bad code. It's confident code that answers a question nobody actually checked. "What should happen when the list is empty" is exactly the kind of thing an agent will quietly guess at if nobody surfaces it first. A process that forces the unknowns into the open before implementation starts turns a silent guess into a decision someone actually made.

One mistake stays small. Speed is only useful if the cost of a bad attempt is low. Give each piece of work its own copy of the code, running in its own disposable environment, with credentials that expire quickly and a short list of places it's even allowed to reach. Then the worst outcome of a bad run is a branch you throw away, not a system you have to repair.

A process maximizes the chance that every edge case gets covered, every unknown gets found, and every real decision gets put in front of a person instead of guessed at. That was always true. Agents raise the stakes because they're fast enough to travel a long way down the wrong road before anyone notices.

It only works if it's actually enforced. A process written in a document is a suggestion, and an agent, like a person in a hurry, will take whichever shortcut is actually open to it. Enforce it, and the worst a bad run can do is get caught.

This is the case for ampm

ampm is built around exactly that bet: that a well-formed, enforced process is what makes agent-written software trustworthy, not an obstacle to it.

Work moves through a fixed sequence — checked against what's already being tracked, described clearly, planned, built, reviewed, and opened as a change for a human to merge — rather than whatever order a given run picks. At a handful of points, the system stops outright and waits for a person to decide: what the work actually is, whether the plan before any code looks right, whether to merge, whether to ship it. The work does not move until someone answers. Review happens before any change is proposed for merging, not after.

Every task also gets its own private copy of the repository, in its own disposable environment, and it can only reach the small number of places it's explicitly allowed to reach. Its credentials to the code host expire within the hour. And the plan behind the work is written down and kept with it, so the next run — whether that's an agent or a person — starts from a real record instead of reconstructing it from scratch.

None of that is free. It is friction, deliberately placed, in exchange for predictability. Agents made that trade a much better deal.