Agentic engineering, Developer tools

Stop adding AI to your SDLC. Redesign it as a loop.

Written by Nicolas Dao. · 11-minute read

New posts land in The Stack Weekly email, every Tuesday, with the week's news. Free, and one click to leave.

Or follow by RSS

We took a lifecycle built for human handoffs and sprinkled AI on every stage. With agents, one session can take a piece of work from an idea to its outcome in production, and back to the drawing board when the outcome isn't there. The lifecycle stops being a line. It becomes a loop, and its memory is the spec.

In short

  1. We bolted AI onto a lifecycle built for handoffs between people. With agents, one session owns a piece of work from the idea to its outcome in production, and back to the idea when the outcome isn't met.

  2. The session's memory isn't its context window. It's the spec folder: the intent, the objectives, the plan, and an audit of every step, insight and roadblock, next to the code and its git history.

  3. After the release, the factory spawns bespoke observers for each objective, with their own tools, for as long as that objective needs watching.

  4. Humans are available, not present: decision APIs measure the agent's certainty at every decision point, and call a person when it's low.

  5. A session ends when its objective is met, abandoned, or has drifted so far that it's archived and a new session forks from it, with everything the old one learned.

We bolted AI onto a lifecycle built for handoffs

Look at how most teams work with AI today. The lifecycle is the one we've always had: a ticket, brainstorming, prioritisation, implementation, QA, CI/CD, a release, and some telemetry nobody reads unless something breaks. AI has been added to each stage: a copilot in the editor, a bot that reviews pull requests, a generator for tests.

We're still using the normal steps of a development lifecycle, and we're adding AI on top of it.

That lifecycle was designed for people. Every stage is a handoff, because no one person could hold the whole thing: the product manager hands to the developer, the developer to QA, QA to operations. Each handoff loses context, and each one needs a document to carry it: a ticket, a pull request, a release note.

Agents don't need those handoffs. In my post on software factories I said the work isn't done when the ticket closes, but when the outcome is met. This post is about what that does to the lifecycle itself.

The lifecycle becomes a loop

Here's the lifecycle we have. It's a line, and it ends when the ticket closes.

  1. The lifecycle we have

    1. A ticket
    2. Brainstorm and prioritise
    3. Build
    4. QA
    5. CI/CD and release
    6. Ticket closed

    Every stage hands the work to the next. Done is a closed ticket.

The lifecycle we have: a ticket handed from stage to stage, from brainstorming to release, until the ticket is closed.

With agents, one session can take an idea, question it, write it down as a spec, build it, verify it, release it, and watch what happens in production. And when the outcome isn't there, it doesn't stop at a bug fix. It can go all the way back to the drawing board, and carry on, in the same session. The line closes on itself.

The lifecycle agents make possible: one session takes an idea through its spec, the build, verification, release and observation, and if the objective isn't met it goes back to the idea, in the same session. It leaves the loop when the objective is met, abandoned, or has drifted into a new session.

The diagram as text
  • One session (Its memory is the spec folder): An idea (The intent, and the objective it serves) → Interrogate and refine (With the stakeholders, then prioritise) → The spec (Intent, objectives, the plan, how it's measured) → Build and verify (The change, and the observers it needs) → Release (To a few, then everyone) → Observe the outcome (For as long as the objective needs) → back to An idea (Not met: back to the idea).
  • Out of the loop: Met (The spec moves to -DONE); Abandoned (The spec moves to -ARCHIVED); Drifted too far (Archived, and a new session forks with what it learned).

That's the big difference. The session isn't a feature's implementation. It's the life of an objective, and it can last days, through several turns of the loop. It changes what a session has to remember, what happens after the release, where the humans sit, who owns the code, and when anything is done.

The spec is the session's memory

A session that lives for days can't keep everything in its context window. Context gets compacted, agents restart, the work moves between them. So the memory has to live in files: written down incrementally, as the work happens, so the session survives any compaction by reading it back.

Where do those files go? I'm very opinionated on this: every project needs clear specifications. A spec is the intent made concrete: the objectives, what will count as meeting them, and the implementation details. In my projects there's a specs/ folder, with one folder per specification, and everything about that objective lives there:

In the spec's folder Why it's there
The intent and the objectives Every later decision is checked against why the work exists
How the objective will be measured and observed Decided before the build, not after the release
The plan and the implementation details So any agent can pick the work up where it was left
Progress, step by step So the session knows where it is after a compaction
Insights, roadblocks and dead ends So nobody walks into the same wall twice
Every decision, and every answer a human gave An audit log: if the work has to rewind, the session knows why it went that way

Combined with the git history, it's a complete record: what was intended, what was tried, what changed, and why. The teams furthest along work the same way. Anthropic's long-running agents make incremental progress in each session "while leaving clear artifacts for the next session", a progress file and the git log. OpenAI's team made the repository itself the system of record for its agents.

A spec has a life of its own. When its objective is met, it moves to specs/-DONE/. When it's abandoned or becomes irrelevant, it moves to specs/-ARCHIVED/. Either way it stays under source control, so it can always be pointed to.

Here's something I didn't expect: in all my projects, the folder that grows fastest isn't the source code. It's the specifications. The documentation is the project's memory too, but it's the latest version of the current state, so it grows slowly. The specs keep every objective, every intent and every audit, so they keep growing.

In my projects, the folder with the most text isn't the code. It's the specifications.

Testing and release become one loop

In the old lifecycle, testing comes before release, and release is a gate you pass once. With a session that owns the outcome, they alternate: release to a few users, watch, check again, widen, watch again.

The checks get more specialised, too. Instead of one QA stage, independent verifiers each look at the work from their own angle: performance, security, regressions, the business domain. And as I wrote in the verification post, the gates that decide whether the work may go further stay outside the session's reach. The session can run the checks. It can't rewrite them, and it can't widen its own rollout past what the policy allows.

After the deployment: bespoke observers

The release is where it gets interesting. The session has to watch the outcome, and the outcome is different every time: conversion on a new checkout, the error rate of a migrated service, whether a billing change reconciles to the cent. No generic dashboard watches all of that.

So the factory spawns observers: agents that belong to the factory but are completely bespoke, created for one objective, with the tools that objective needs. One walks the new journey every few minutes. Another compares users with the feature on and off. Another reconciles the new numbers against the old ones. They report into the spec's folder, so their findings are part of the session's memory. I wrote about why the factory has to build these for itself in the factory builds its own observers.

How long they watch depends entirely on the change and the objective: how often the thing happens, how long until the numbers mean something, what a business cycle looks like. A copy fix might need an hour, a feature used once a week needs weeks. That's why the objective, and what will count as meeting it, have to be defined at the very start, in the spec. The observation window comes from there.

This is early. I'm working on it right now, and I think it's one of the biggest opportunities in this whole shift.

Humans: available, not present

Where do the humans sit in a loop like this? Not at a desk watching it run. The rule I work by: a human doesn't have to be present. A human has to be available.

At every decision point (refining the objective, writing the tests, coordinating sessions, deciding to widen a rollout) the harness asks how certain the agent is about what to do. That's what decision APIs are for: a model built to decide, that returns a verdict and how confident it is, quickly and cheaply enough to run at every step (which decision model to use). When the certainty is high, the work carries on. When it isn't, a person is called in, and a conversation starts to clear it up. Until then, that part of the factory pauses, and waits. The question and the answer both go into the spec's audit log.

So the human isn't a stage in the lifecycle. The human is on call for all of it, and the factory knows when to call.

Many sessions, one product

If every session lives until its objective is met, a busy product will have many sessions live at the same time, each watching a different number. Session A watches checkout conversion, session B search success, session C an error rate. They share one codebase, one database and one production.

A proposal: several sessions each watch their own outcome on the same live product. A coordinator orders their releases, guards the shared state, and sends each session the evidence that belongs to it, read from telemetry tagged by session and deploy.

The diagram as text
  • The live product (One codebase, one production): Feature flags: One per session's change; Shared services and data; Telemetry: Tagged by session and deploy.
  • Outside: Session A: Watching checkout conversion; Session B: Watching search success; Session C: Watching an error rate; The coordinator: Orders the releases, guards shared state, routes the evidence.
  • Session A → The coordinator.
  • Session B → The coordinator.
  • Session C → The coordinator.
  • The coordinator → Feature flags: Ships.
  • The coordinator → Shared services and data: Guards.
  • Telemetry → The coordinator: Evidence.

That raises three problems, and they're the real design work:

  • Coordination. Two sessions can want to change the same service, or one session's fix can undo another's experiment. Something has to order the releases and say no. Lauren Tan already runs coordinator agents that do nothing but delegate and supervise other agents; in her words, a chief of staff. A lifecycle built on long-lived sessions needs one at the product level, with a human available when it isn't sure.
  • Shared state. A migration in one session changes the data every other session depends on. Shared services and data need an owner that isn't any one session.
  • Attribution. When conversion drops, which change did it? Telemetry has to carry the session and the deploy that produced it, and each change needs its own switch (a feature flag per change), or nobody can tell one session's effect from another's, or from an ordinary Tuesday.

Who owns the code now

In my first post I said that when agents write the code, who owns the code changes, and that pull requests may die. I'm not 100% sure yet. But I suspect they will, and here's why.

A pull request is a handoff between people: one person wrote it, another reads it and takes on some of the responsibility by approving it. When one session owns the outcome from the idea to production, there's no handoff left to make. The session record (the spec, its audit, the git history) says more about the change than any pull request description ever did.

Branches stay, for sure. What changes is how a branch gets into master. I see a dedicated agent responsible for the merge: it runs the merge gate, with its own series of checks against criteria written in the spec, and it works with the session that made the changes to explain and fix what fails. But the decision is the gate's, read from the record, not an agreement between two agents. Ownership moves from whoever typed the code to the session that owns the outcome, and to the human who owns the objective. This part is still vague, and we're experimenting with it.

When is it done?

Done is decided at the start, not at the end. The spec defines the objective and what will count as meeting it, and the session runs the loop until one of four things happens:

  1. The objective is met. The evidence (the checks and the observers' findings, over the window the spec set) says so. The spec moves to -DONE.
  2. It isn't met yet. Back to the idea, in the same session: rethink, rebuild, release, observe again.
  3. The objective is abandoned. The business changed its mind, or the cost outgrew the value. The spec moves to -ARCHIVED.
  4. The objective has drifted. After enough turns of the loop, what we're chasing isn't what we started with. At some point the old objective is archived and a new session forks from it, carrying everything the first one learned.

When that fork happens is a judgment call. It depends on the team and the business, and that's fine: what matters is that it's explicit and recorded. Changing the success criteria is a human's call, on the record. Without that, you get the two classic failures: sessions that never end, and criteria that quietly relax until the work counts as done.

What would prove me wrong

  • Long-lived sessions cost more than they find. If watching for days rarely changes a decision, short sessions with good monitoring win.
  • My factory turns into a team. This week, Anthropic published Worse Together, a study of agents that each act for a different user while sharing one resource: a budget, a calendar, a merge queue. In its main case, one agent per person with a chat channel between them and nobody in charge, the team lost to a single agent handling every request in all four environments, by roughly 10 to 45 points. The team agents acted too little and too late, often committed before they'd read their peers' messages, and made unsupported claims about each other in more than half of the episodes. It's a study of agents serving different people, not one product. But the authors say a similar coordination problem arises when one person runs eight Claude sessions building features in the same codebase, which is exactly my case.
  • Attribution is too noisy. If most products can't tell one change's effect from another's, "done when the objective is met" can't be measured, and teams will fall back to "done when it shipped".

Here's why I don't think it sinks the idea. Those teams were a free-for-all: agents left to figure it out among themselves. A software factory isn't designed like that. It's a series of gates, each with a clear intent, encoded as deterministically as possible. The intelligence does what it's designed to do, and the gates decide. Decision APIs route each step, and call a human when they aren't sure. The shared resources (the merge, the rollout, a migration) go through the platform one at a time. And on anything complex, there's a human in the loop: only the simplest changes run in the dark.

The study's own best fixes point the same way. What fixed the failures wasn't more conversation between agents: it was a platform check that wouldn't let an agent commit before it had read its messages, priorities set by a person, and authority narrowed to one role. Those are gates.

A race condition isn't fixed by intelligence. It's fixed by design.

So the real risk is any place where my design still lets agents negotiate: a merge agent agreeing with the session that wrote the change, a coordinator ordering releases on its own judgment, a gate that takes another agent's word instead of reading the record. Those have to be gates that read their facts from the spec, the telemetry and the git history. Where they can't be, the study wins. I'm also relentlessly optimistic: models are getting better at this fast, and I expect much of it fixed within 12 months. But I'd rather design for the problem than wait for it to go away.

My bet

The lifecycle we have was shaped by the limits of people: how much one person can hold, and how work moves between them. Agents remove most of those limits. The teams that win won't add AI to each stage. They'll redesign the lifecycle as a loop around an objective, with a spec for a memory, observers built for each outcome, humans available at every decision, and a clear rule for when it ends.

The agent session doesn't end at deployment. That's where it starts to matter.

On this site

Sources

  1. Anthropic: Effective harnesses for long-running agents (26 November 2025)
  2. OpenAI: Harness engineering, leveraging Codex in an agent-first world
  3. Matt Pocock: LIVE: Poteto (creator of pstack) on shipping 1,000's of PR's a month at SpaceX (YouTube, 2 October 2026)
  4. Anthropic: Redesigning source control at Anthropic (13 October 2026)
  5. Anthropic: Worse Together, how performance breaks down in multi-user multi-agent teams (Paliskara, Namchittai, Tay, Griffin, Lampinen, 11 November 2026)

Written by Nicolas Dao. · 11-minute read

Get the next one

Each new post is announced in The Stack Weekly email, every Tuesday, with the week's news read against the stack I build with. Free, and one click to leave.

One email a week. Confirm by email, unsubscribe in one click. Your address goes to Resend, our email provider, and nowhere else.

Want this thinking on your system?

Cloudless Labs is a Sydney consultancy. I build AWS systems and AI agents for startups, enterprises and government, and coach teams to ship with coding agents. The first 30-minute call is free.

Talk to us

Contact Us

For general inquiries, please contact us at:

For e-learning capabilities, please contact: