Five stars — how you write it, who checks it, who decides, what can contradict the implementation, and what breaks. They align on one of eighteen signs.
No stars were consulted. Five picks, one lookup table, and arithmetic you can read in the source.
How does the code get written?
How does the code get written?
Star 1 of 5
Nothing is stored. The five stars and the sign live in the URL.
All eighteen signs
Eighteen positions on a three-by-three map of how code gets written against how it gets verified, with four of the nine houses splitting at Sandbox stakes and one splitting on who decides. There is no best sign and no maturity ladder — vibe coding is the right answer for a prototype and the wrong one for a payments platform, and agentic coding under human review is neither more nor less mature than writing it by hand. What the app measures is the mismatch between a position and its consequences: automation is cheap, and independent verification is the scarce thing. AI code review counts as verification only when the model checking the code is not the model that wrote it — two instances of the same model on both sides of the loop is the case that fails silently, because the priors that produced the bug are the priors used to look for it.
Five stars produce the answer: how the code gets written, who is the last set of eyes before it ships, who decides it is correct, whether the acceptance standard is one the code-and-review loop can change, and what happens when it breaks. The first two place you on the map. Judgement and stakes decide what the position costs — and in the lights-out house, where agents write it and a machine clears it, Judgement decides the name too: a dark factory where a person, a team, or a codified gate can still contradict the machines is not the same posture as one that takes the model at its word.
The fourth star, Reference, is asked separately from Judgement on purpose. Reference asks who controls the acceptance standard; Judgement asks who or what applies it and declares the result correct. A codified gate earns its own credit because enforcement is consistent — but a test suite the same loop generates and freely rewrites is not a standard held outside that loop, and counting it as both is the mistake the pair of questions exists to avoid. The standard is allowed to evolve. What matters is who can change it, which is why neither Waterfall against Agile nor written-first against discovered-later is scored anywhere on this map.
Forged · Every lineLive service · Under audit
The Craftsman
nothing ships unread
Hand-written, human-read, real consequences
Hand-written and human-read in an environment that has consequences. The highest independence of any position in the matrix and the lowest throughput. Everything that ships has been understood by a person who could be asked about it.
Breaks when
The review queue becomes the bottleneck and the team routes around it
Throughput expectations rise without the verification model changing to match
Forged · Second pairSandbox · Live service · Under audit
The Practitioner
hand-made, machine-checked
Hand-written, machine-assisted review
Writes by hand and accepts a machine as a second pair of eyes. Keeps the authoring muscle while cutting the cost of the first review pass — and because the model did not write the code, its review is genuinely independent of the priors that produced the bug.
Breaks when
The AI pass becomes the only pass without anyone deciding it should
Reviewers learn to trust a green check they have not calibrated
Every line hand-written and no human reads it. Common in a team of one inside a larger org, or a senior engineer nobody feels qualified to review. The model checking the work is at least independent of the person who wrote it — which is why this sits well above the fully delegated corner.
Breaks when
No human has read this code in months and the model does not know what the business cares about
A bus factor of one, in a system somebody is paying for
Assisted · Every lineSandbox · Live service · Under audit
The Pair Programmer
two hands, one pen
AI drafts, you edit, you review
AI drafts, human edits, human reviews. The most conservative way to take the productivity gain: authorship moves to the machine, verification does not move at all, and independence stays at the ceiling.
Breaks when
Reviewing generated code at the same depth as hand-written code, and quietly halving the gain
Accepting a suggestion that is locally right and globally wrong, because it reads well
Assisted · Second pairSandbox · Live service · Under audit
The Centaur
half and half, both ways
Human and machine on both sides of the loop
Human and machine on both sides of the loop, with a human still holding the pen on anything load-bearing. The most common serious-team position right now, and a defensible one — provided somebody can say which class of change gets which treatment.
Breaks when
The split is habit rather than policy, so nobody can say which class of change gets which treatment
Under deadline the human half of the loop is the half that gets dropped
Assisted · Machine-gatedSandbox · Live service · Under audit
The Shipper
merge and move
Fast iteration, machine verification
Fast iteration with machine verification. Works when the blast radius is small and reversibility is high — and both of those are assumptions about today, not properties of the code.
Breaks when
The code that ships this way outlives the assumption that made it safe
Reversibility quietly degrades — a schema, a payment path, an integration — and the posture does not change with it
Agents generate, humans verify, on systems that matter. The deliberate high-risk posture: the highest independence available at high automation, bought with human attention. Delegating authorship costs nothing in independence provided verification stays human — that is the substantive claim of this whole model.
Breaks when
Review capacity, not generation capacity, sets the ceiling, and it does not scale with headcount
Reviewer fatigue turns a real gate into a rubber stamp nobody has measured
Summoned · Second pairSandbox · Live service · Under audit
The Orchestrator
fleets, not diffs
Fleets of agents, harnesses instead of diffs
Runs fleets of agents and spends their own time on harnesses, evals, and specs rather than diffs. The unit of work is a pipeline, not a change. Independence holds up because the verification layer is engineered rather than delegated wholesale.
Breaks when
Nobody can reconstruct why a given decision was made, because no human made it
The evals measure what was easy to measure, and the gap is invisible until production finds it
Machines write, machines check, humans watch the dashboards. Real throughput, and the position with the least independent verification in the entire matrix — the priors that produced the bug are the priors used to look for it. When judgement sits at Own taste or The oracle, no external oracle exists at all: the single most exposed state this tool can report.
Breaks when
Correlated failure: the model that wrote the bug is the model that cleared it, and it fails silently
The first serious incident is also the first time anyone reads the code
Summoned · Machine-gatedLive service · Under auditJudgement: The oracle
The Believer
takes the model at its word
Machines write it, machines check it, and the machine says it is correct
Agents write it, an AI reviewer clears it, and when someone asks how you know it is right, the answer is that the model said so. The Dark Factory next door keeps at least one authority outside the model — a person, a team, or a codified gate can still contradict what the machines produced. Here the final authority is the model's own opinion, so the thing that generated the code, the thing that reviewed it, and the thing that ruled on it all share a set of priors, and a wrong answer gets confirmed three times instead of caught once. This is the lowest independence the map can reach, and it is the only sign that gets there by trusting rather than by cutting corners — which is exactly why it is invisible from the inside.
Breaks when
Every oracle in the loop shares its priors with whatever wrote the code, so the mistakes it is worst at finding are the ones it is most likely to make
Confidence rises while independence falls, and nothing in this posture can detect that direction of drift — the model reports the same clean result either way
When nothing is at stake there is no consequence to define the sign, so what remains is who controls the target: with a standard held outside the loop the work is directed — you are aiming at something you cannot quietly move — and with a loop-owned one it is exploratory, because what counts as done is settled by the same loop that writes the code. That is the whole difference between a Learner and a Hobbyist, or a Benchmarker and a Skeptic. Above Sandbox the consequence defines the sign and an independent reference is a risk modifier instead.
Forged · Every lineSandboxIndependent reference
The Learner
the long way round
Hand-written, self-reviewed, nothing at stake
Writing it all yourself on something that cannot hurt anyone. The slowest path and the only one that builds the intuition every other archetype spends down. The friction here is not waste — it is the deliverable.
Breaks when
Mistaking tool avoidance for rigour
Staying here past the point of return, so the first agent-heavy job is a cold start
You type it, you read it, and nothing was written down about what done means. The project is the point — you find out what you are building by building it, and the only reviewer is the person who wrote it. This is the most independent position on the map and the least consequential, which is exactly why it is a good place to learn things that would be expensive to learn anywhere else.
Breaks when
Nothing here transfers automatically — the habits that work when you are the only stakeholder are the ones that break first at Live service
Nothing was written down, so returning to it later means reconstructing the intent from the code, and the code is all there is
Interview prep, katas, deliberate practice. Writing everything unaided is the point; the model is a grader, not a collaborator. Independence is high for the same reason as the Practitioner — nothing the model checks is anything the model wrote.
Breaks when
Optimising for a rubric that no longer resembles the job
Practising generation while the job has moved to specification and verification
hand-written, machine-checked, whatever you feel like building
You write the code yourself and let the AI reviewer be the gate, because it is your project and the stakes are your Saturday. The target moves as you go. It is a fast, genuinely pleasant way to work, and the reason it is fine is the stakes — the same posture at Live service is a Lone Author with a thin margin.
Breaks when
The model's approval is the only signal you get, and you will not notice the day it stops being a good one, because nothing here fails loudly
The identical posture at Live service is a Lone Author on a thin margin, and it does not feel any different from the inside
agents write it, you read all of it, and the target was set in advance
You hand agents a task whose answer was settled before they started — a kata, a benchmark, a rubric, a spec you wrote yourself — and read everything that comes back. You are not shipping; you are finding out what these things can actually do, which requires a target they cannot influence and eyes that read every line. This is how most people who trust agents at work earned the trust.
Breaks when
Benchmark results are not delivery results — the task with a known answer is the task agents are best at, and the gap between that and your codebase is what you have not measured
Reading every line does not scale past the experiment, so conclusions drawn here quietly assume attention you will not have later
Lets the agents write and reads every line anyway. Usually someone evaluating the tools rather than depending on them — which is exactly the right way to find out whether they can be depended on.
Breaks when
Reading output at a volume no human sustains, then stopping without noticing
You write down what done means, point agents at it, and let the AI reviewer decide whether they got there. Nobody reads the diff. At Sandbox this is the cheapest way there has ever been to find out whether a written target is machine-checkable — and finding that out is worth more than the code it produces.
Breaks when
The spec is the only oracle in the loop, so an ambiguous line becomes a silent wrong answer that nothing downstream is positioned to catch
Success here reads as proof the loop works, when what made it safe was that nothing was at stake
Describe it, run it, keep it if it works. Genuinely the right answer for prototypes, demos, and things that are allowed to break — the machine closed both halves of the loop, and at these stakes that costs nothing.
Breaks when
The prototype gets users
The demo becomes the codebase and nobody marks the moment it happened