The agentic SDLC

Humans move to the edges.

Humans hold the vision and do the validation. In the middle, agents do the implementation.

VisionWhat should we build, and why?

ImplementationAgents write, test and fix the code

ValidationIs what we built correct?

Scroll ↓

The shift

From writing the code to defining it and verifying it.

Until now, a human's attention was mostly in the middle: turning intent into code, line by line.

With agents doing the implementation, that attention moves outward. To one side: defining what should be implemented. To the other: making sure what was implemented is correct.

Before

Visiona ticket

writing code{ … }

Validationa code review

Now

defining

agents implement

verifying

The question everyone asks

How will I know the code is any good?

There are two different questions hiding in there.

1 · Does it work?

It does what it should, and doesn't fail in undefined ways at runtime.

Answered by a validation strategy, and only a human can provide it.

Validation ↓

2 · Is it built well?

It's implemented without defects, like duplication, that erode future safety and maintainability.

Answered by the structure of the codebase: the garden work.

Structure ↓

1 · Does it work?

“How do I know this is any good?” is validation.

The answer to that question is something the human has to provide. It isn't in the code, and an agent can't invent it. So the human creates a validation strategy.

That strategy becomes the acceptance criteria: the bar the agent climbs to in its agentic loop. Implement, check, fix, repeat, until every rung passes.

It's more than unit tests. It might include manual testing, integration with other systems, or deployment to an alpha channel.

The human sets the bar →

Compiles & type-checks

Unit & property tests pass

Manual testing scenarios

Integration with other systems

Deployed to the alpha channel

Accepted

Agentic loop

implement

2 · Is it built well?

Code can pass every test and still be getting worse.

Duplication creates drift surfaces: two copies of the same rule that are supposed to agree. Today they do. Then one of them changes.

Nothing fails today. But the codebase is now less safe to change, and every agent that reads it learns two contradictory versions of the truth. At agentic speed, drift compounds fast.

checkout/validate.ts

const MAX_ITEMS = 50;
function canOrder(cart) {
  return cart.items.length
    <= MAX_ITEMS;
}

api/orders.ts

const MAX_ITEMS = 50;
function isValid(order) {
  return order.items.length
    <= MAX_ITEMS;
}

Two copies of one rule…

2 · Is it built well?

Make the right way easy, and the wrong way impossible.

This is the garden structure work. Instead of hoping each change is good, shape the codebase so bad changes can't be expressed: make illegal states unrepresentable.

Type systems: the compiler rejects states that must never exist.
Architectural rules: module boundaries and dependency rules, enforced in CI rather than by review.
One source of truth: a single place for each rule, so there's nothing to drift.
Paved paths: the obvious way to do something is the correct way.

Representable → it will happen

type Order = {
  status: string;
  paidAt?: Date;
  trackingNo?: string;
};
// "shipped", never paid, no tracking number:
const o: Order = { status: 'shiped' };  // compiles

Unrepresentable → it can't

type Order =
  | { status: 'pending' }
  | { status: 'paid'; paidAt: Date }
  | { status: 'shipped'; paidAt: Date; trackingNo: string };

const o: Order = { status: 'shipped' };
// ✗ Property 'trackingNo' is missing

An agent can't take a wrong turn the structure doesn't allow, and neither can a human.

2 · Is it built well?

Growth brings entropy. Structure is never finished.

The codebase has to be set up for this, and then continuously refactored to deal with the entropy that comes with growth. The trellis bends under fruit; new beds need new irrigation.

Refactoring isn't a rewrite. It's the human's structural work, carried out with agents:

KEEP what worksTAKE OUT what doesn'tMOVE things into better placesADD what's missing

growth without structural workcontinuous refactoring

So, where are the humans?

Vision. Validation. Structure.

Agents implement. Humans decide what should exist, define how we'll know it's right, and shape the codebase so that building it well is the easy path.

VisionDefine what should be implemented

ImplementationAgents climb to the acceptance criteria

ValidationA strategy that answers “is it any good?”

StructureTypes, architectural rules, one source of truth, continuous refactoring: the garden everything grows in

Next: The organisation of agents → ← From Dark Factory to Software Garden Contents Back to the top ↑