I started building the tools behind this essay in February 2026 with one question: if AI is going to build everything, what happens to the next generation of developers? The developers I learned from did not hand me a code generator. They handed me judgment: what to build, what to refuse, when “it works” is not the same as “it is done”. That judgment took a career to collect. If an agent can now write the code, the judgment is the part that still has to come from somewhere, and a newcomer deserves to stand on it from day one instead of discovering it one production incident at a time.

This essay is about where that judgment goes when agents write the code. The short answer is: into a lifecycle, written down where the agent has to read it, with a person in two seats that do not move.

1. Generating code is solved; shipping is not

Any current AI client can produce a working function in seconds, a whole feature in an afternoon. That problem is solved well enough that it no longer deserves the argument. The argument is about everything a team does between “we want this” and “it is live and we trust it”: deciding what to build, agreeing on how, checking that the result does what was asked, reviewing it, merging it, deploying it, and remembering why it was done that way when the next change arrives.

That is a lifecycle, and agents do not shorten it. They shorten one step in it, the typing, to almost nothing, and leave the rest exactly where it was. In practice they make the rest harder, because code now arrives faster than anyone’s judgment about it. A team that lets an agent loose without a lifecycle does not get faster. It gets a larger pile of unreviewed changes, and the same number of people who can say whether any of them is right.

2. Where the person sits

“Human in the loop” is usually said as a comfort, not as a design. It helps to be exact. There are two seats a person keeps, and they have names.

The first is deciding the what: the requirements, the acceptance criteria, the trade-offs, the things this change must not break. An agent can draft all of it, and should. A person decides it, because the agent cannot know what the business will regret.

The second is approving the change: the exact diff, before it lands anywhere that matters. Not a summary of the diff, and not a green badge. The change itself, read by someone who will be on call for it.

Everything between those two seats is the agent’s work, and it is a lot of work: the architecture draft, the story breakdown, the code, the tests, the first review. The person’s seat moves from the keyboard to the gate. What a lifecycle for agentic development has to do is make that gate real, and make everything between the two seats bounded enough that a person can afford to sit at it.

3. The loop

The lifecycle I use has six steps, and each one consumes the artifact the previous one produced:

  1. Plan. A feature description becomes a requirements document with testable acceptance criteria.
  2. Architect. The requirements become architecture decisions and a list of stories small enough to implement in one sitting.
  3. Implement. The agent takes one story at a time, writes the code, commits once per story, and keeps a progress file of what it learned.
  4. Test. The tests run against a coverage threshold, and the results are kept as evidence, not summarised away.
  5. Review. A second pass reads the diff as an adversary: several lenses, a pass/warn/fail table, graded severity, and stable ids so a finding can be tracked to its fix.
  6. Ship. A pull request, a real merge-and-test against the target branch, a version bump, and the one human gate: approval, with a rollback plan.

Steps 3 to 5 are the loop. Implement, test and review repeat until the story passes, and this is where “agentic” either means something or becomes a bill. The loop has to be bounded, and these are the bounds that have held up for me:

  • A story that is stuck after three attempts is marked stuck and skipped, not retried until the budget runs out.
  • At most two fix loops for coverage, and two for review findings. After that, the loop stops and reports.
  • Any high-severity finding blocks. The loop does not argue its way past a high finding; a person reads it.
  • Each iteration starts with fresh context. The only memory between iterations is the story list, the progress file and the git history. An agent’s failed approach should not poison its next attempt.
  • One human gate, at pull-request approval. Not ten small approvals that a person stops reading by the third one.

An unbounded loop is not autonomy. It is a meter running with nobody watching it.

Here is the whole lifecycle on one page. The two seats from section 2 are at the top and the bottom. Between them, every step leaves a file in the repository (the blue boxes) and the next step starts from that file, which is what makes this a chain and not a loop with planning bolted on. The loop and its bounds are the dotted edge; the standards every step reads are the box at the side. Sections 4 to 6 are about the blue boxes.

The Spell Loop lifecycle. A person decides the what. Plan writes requirements and acceptance criteria; Architect writes architecture and stories; Implement writes code, one commit per story, and the progress file; Test writes test evidence; Review writes a review table with graded findings and stable ids. If the story does not pass, it goes back to Implement within bounds: three stuck attempts and the story is skipped, two fix loops for coverage and two for review, and any high finding blocks. If it passes, Ship writes the pull request, decision records and journal, and a person approves the change. The next session rebuilds from those files. Standards installed as files, each rule labelled as checked by a tool, done by the workflow or a convention, are read by every step.
The six steps, the file each one leaves for the next, the loop with its bounds, the standards every step reads, and the two seats a person keeps. The last file is where the next session starts. Open the diagram full size.

4. Evidence before “done”

“Done” is a claim. The lifecycle asks for the evidence instead: the tests that ran and their results, the coverage number against the threshold, the review table, and a disclosure of what the agent’s sandbox could not verify before it asked for a merge. If the agent could not run the integration tests, the pull request says so, and the person decides what that is worth.

This changes what a review is for. A review that must find three things finds three things, whether or not they matter. The reviews in this lifecycle have no finding quota. They grade what they find, give each finding a stable id, and lift their own block when the fix lands. A review that finds nothing says so and shows its lenses, which is a different statement from “looks good”.

At the end of a session, the same rule applies to every piece of work that ran in the background: it is classified as succeeded, failed, pending, dispatched or unverifiable, and only “succeeded” may be called done. Most of the harm I have seen from agents came from the gap between “I started it” and “it finished”, reported as if they were the same thing.

5. Memory in files, not in a vendor’s cloud

Everything the loop produces is a plain file in the repository: the requirements, the architecture, the stories, the progress file, the decision records, the session journal. Anything that reads text can read them, people included. Git keeps their history. If you change vendors next year, nothing is lost, because nothing lived in a chat window.

Two habits make this work. A session opens by rebuilding its context from the repository, and it closes by writing a dated journal entry and a handoff that the next session reads first. And decisions are recorded as numbered records, superseded in place with a link back, so that a branch cannot silently undo a choice the team made in March. When drift appears, a decision id that skips a number, an installed standard that no longer matches its source, it is caught at session open, and high-severity drift stops the session until a person decides.

The point is not nostalgia for files. It is that judgment has to live where the agent will read it on every run, and a repository is the one place every agent and every person already has to look.

6. Say how every rule holds

A rule nobody checks should not read like one that is checked. This is the rule I would ask of any lifecycle, any team standard, and any product that claims to enforce them, including mine.

Every rule in this lifecycle carries one of three labels. A tool does it: a command, or a hook it installs, performs the check, and a person cannot skip it by forgetting. The AI client does it when the work runs through the workflow: the step is real, but only inside the workflow. The standards ask for it, and nothing checks it: it is a convention, and it is written as one, so that nobody mistakes advice for enforcement. About a quarter of the rules I ship are conventions. Saying so is the honest version of “best practices”.

The same candour applies to what the lifecycle does not do. It does not run your agents or call an AI model; the workflow is a set of instructions your client follows. It does not intercept raw git: a commit you type by hand skips the approval and test gates, by design, because the gates are for the workflow, not a cage for the person. Its credential scan looks for known patterns and can find a leak, never prove a commit clean. Its push controls stop an accidental push, not a determined operator. A lifecycle that claims more than that is selling you a feeling.

7. A reference implementation

The lifecycle above is not a thought experiment. It is what my company runs on its own work, and it is published as the Arcane framework, open source under the MIT license, installed with npm as arcane-cli. One command installs the lifecycle into any repository as plain files: the governance documents, the workflow prompts (we call them spells, hence the name), and the agent definitions, with a manifest that records a hash of every file it placed, so that your edits are three-way merged on update instead of overwritten. It is tested with VS Code + GitHub Copilot, the GitHub Copilot app, Claude Code and Codex, and it also writes agent files for OpenClaw.

It borrows from two open-source projects that worked out the patterns before us, and it says so: the autonomous story loop of Ralph, with fresh context on every iteration, and the phased planning and adversarial review of the BMAD Method. What it adds is the operational layer around them, the bounds in section 3, the evidence rule in section 4, the file-based memory in section 5, and the labels in section 6, applied to the framework’s own documentation and to its own marketing. Every capability it claims is listed with how it holds at arcaneai.net/capabilities, and the source is at github.com/codemagicianhq/arcane.

Which brings me back to the question I started with. If AI is going to build everything, the next generation of developers does not need a faster code generator. They need the judgment written down where the agent has to read it, and the two seats, deciding the what and approving the change, kept for a person. That is what a lifecycle for agentic development is for.