# Judgement stays with people

Status: draft. Owner: Andrew Flett. Last reviewed: 2026-09-03.
Canonical: https://agentic.madebymany.com/principles/judgement-stays-with-people

A person decides what to make, whether it is good, and whether it ships. Agents produce the code, the checks, the drafts and the assembly. Nothing goes out without a person deciding it should, and the parts of the work that need a person did not get faster when the parts that do not did.

## Where the split is real

Software, prototypes, and whatever else a brief turns out to need. The agentic lifecycle runs Plan, Design, Build, Verify, Ship, Operate, spec-driven and gate-enforced, with every stage naming what a person does and what an agent does. This is where the principle was proven, and it is the part we can show working end to end. Proven on our own prototypes; it has not yet run a client engagement, and we say so rather than implying otherwise.

```lifecycle
{
  "title": "The lifecycle, and who does what",
  "lanes": {
    "person": "What a person does",
    "agent": "What an agent does"
  },
  "stages": [
    {
      "key": "plan",
      "label": "Plan",
      "note": "define what to build",
      "person": "Frame the problem, interview for the spec, decide what is out of scope, and say what success would look like.",
      "agent": "Draft the spec from the interview, break it into dependency-ordered tasks, and revise it when the build contradicts it.",
      "gate": null
    },
    {
      "key": "design",
      "label": "Design",
      "note": "the system and the screens",
      "person": "Art direction, and the judgement about whether what is on screen is any good.",
      "agent": "Generate the token system from one brand colour, and build every screen against a floor it cannot skip: the three states, the accessibility bar, tokens instead of literals.",
      "gate": null
    },
    {
      "key": "build",
      "label": "Build",
      "note": "scaffold, run, test, commit",
      "person": "Say what to make next. Look at it. Say when it is wrong.",
      "agent": "Write the code and the tests together, run the dev loop, checkpoint after every working change, and drive each change through the gates until it is merge-ready.",
      "gate": "commit"
    },
    {
      "key": "verify",
      "label": "Verify",
      "note": "a gate at every trigger",
      "person": "Review every change on its way in. Run the passes no machine can: keyboard, screen reader, real devices, and the exploratory look.",
      "agent": "Nothing is invoked here. The gates fire on their own at four moments, and the agent's job is to react to a red one.",
      "gate": "pr"
    },
    {
      "key": "ship",
      "label": "Ship",
      "note": "the engine, and the link",
      "person": "Decide it goes live. That decision is recorded against the deployment, not said in a channel.",
      "agent": "Run the pipeline, produce a preview for every push, resolve the real link, and prove the page rendered rather than that it responded.",
      "gate": "promote"
    },
    {
      "key": "operate",
      "label": "Operate",
      "note": "measure, monitor, iterate",
      "person": "Decide what the numbers mean and what to do about them.",
      "agent": "Surface problems without being asked, and turn a production issue into a proposed fix for a human to merge.",
      "gate": "live"
    }
  ],
  "footnote": "The lime lane is the part we deliberately did not automate."
}
```

Planning is spec-driven. An intent becomes a spec, the problem, the scope, the riskiest assumptions, the success criteria, and the spec is written to be proved wrong by the build and revised. It is a best guess that improves, not a contract.

The checks are not a person's job. Formatting, types, tests, accessibility, visual regression and performance budgets run on every commit and every pull request, and a person reviews what the gates have already proven. Who reviews, who signs off and what is recorded is [a principle of its own](/principles/governance-is-how-the-work-is-made).

What this replaced, and why each of agile's ceremonies stopped paying for itself, is a position of its own: [product management in an agentic SDLC](/positions/product-management-in-an-agentic-sdlc).

## What still takes time

The build compresses until it runs continuously underneath the work, and shipping becomes a rhythm rather than an event. The calendar does not follow it. A build that takes hours does not make a user interview take less than an hour, and most of a project is not the lifecycle: the stretch the agents act on sits inside framing, research and the judgement around every release, none of which got faster.

Where that time goes is [its own principle](/principles/ai-takes-people-further). The short of it: the saving buys loops and the certainty they bring, not fewer days.

```track
{
  "title": "Build used to be the biggest block. It is now one of the smallest.",
  "segments": [
    {
      "label": "Framing, research and design",
      "note": "Interviews take an hour because a person is talking. Exploration takes as long as it takes to be surprised.",
      "kind": "elapsed"
    },
    {
      "label": "Spec, Build, Verify, Ship",
      "note": "Where the skills act.",
      "kind": "compresses"
    },
    {
      "label": "Operate, measure, monitor",
      "note": "You find out what it did once people have used it, which happens at their pace.",
      "kind": "elapsed"
    }
  ]
}
```

```callout Elapsed, not billable
Research and exploratory design need calendar time even when they are not consuming billable days. Interviews run at the pace of other people's diaries, exploration runs until it stops surprising, and prototyping cannot start until they have run. That distinction matters commercially: the build compresses, the calendar around it does not, and how the two phase together in an engagement is something we have not settled yet. We flag it here rather than draw a phasing plan we have not tested.
```

## The checkpoints we did not automate

Review, the assistive-technology passes and release sign-off are the parts we deliberately did not automate. Compressing them is not speed, it is removing the thing that makes the speed safe.

## Where the split already runs

Where software is built, the split is written into every stage and the gates enforce it. In communicating, a person judges and finishes while the studio skills assemble a draft out of the positions, which is the same split with less machinery under it. Across the rest of the studio, each discipline is working out what it delegates and what it keeps, in practice rather than from a table written here.

## Related agentic skills

- [mxa-plan](https://agentic.madebymany.com/playbook/skill/mxa-plan)
- [mxa-verify-promote](https://agentic.madebymany.com/playbook/skill/mxa-verify-promote)
- [mxs-positions](https://agentic.madebymany.com/playbook/skill/mxs-positions)