The method: specify, verify, then delegate

The method behind every workflow on this site has three rules: record each change as a chain of committed artifacts before code exists, build checks that can fail before an agent gets more autonomy, and have humans judge intent, spec and evidence at the gates rather than every diff. It works the same in Claude Code, Codex and Cursor.

You gave the agent a ticket, got 400 plausible lines, and must now read them all or merge on trust. Reading every line caps throughput at your reading speed; merging on trust ships the bug no test looked for. The method moves your attention earlier, to the spec, and later, to the evidence.

What are the three rules of the method?

1. Specify before you generate. Every change travels as the artifact chain: intent.md, spec.md, plan.md, the diff with its test output, and the review findings. A named person accepts each file before the next stage reads it.
2. Verify before you raise autonomy. Let the agent run longer or unattended only when a check exists that goes red on the wrong behaviour: a failing test written first, acceptance criteria mapped to tests, and an oracle the agent cannot edit. If you cannot name the check, keep the agent on a short leash; How strong is your oracle? measures it.
3. Judge at the gates, not line by line. Humans read intent, spec, the evidence bundle and the risk class. Code reading is reserved for the escalation classes: authentication, money, schemas, data migrations, the tests themselves, and anything no check covers.

The Autonomy Ladder places your team on this path; the AI-native lifecycle runs the rules as six looping stages.

How does each tool run plan, execute and verify?

The discipline is identical; the controls differ.

Claude Code

Plan read-only with claude --permission-mode plan, /plan, or Shift+Tab. Execute in Manual mode (you approve each edit and command) or acceptEdits. From v2.1.283 on the latest channel, interactive sessions start in auto mode, where a classifier reviews each action (except on models auto mode does not support, or where settings set disableAutoMode); Shift+Tab switches modes. Verify with a PostToolUse hook that runs your tests after each edit, then /code-review on the branch.

Codex

Plan with /plan in the terminal UI. Execute under a permission profile (beta), for example codex --worktree -c default_permissions=":workspace", which also isolates the run in its own Git worktree. Do not combine a profile with --sandbox: OpenAI says the two systems do not compose (checked on Codex CLI 0.157.1). Verify by having Codex run the tests, then /review locally or @codex review on the pull request.

Cursor

Plan in Plan Mode, which writes the plan before any code. Execute in the agent, in a Worktree for parallel attempts. Verify with your test command and Hooks, then let Bugbot review the pull request on the Git host.

The tool map holds the full command set per stage.

Prompts that start the method on your next change

Copy-paste prompt: plan against a spec, with its proof

Stay in plan mode and do not edit files. Read spec.md and the files it names. Write plan.md: a numbered task list where each task names the files it changes and the exact command that proves it (a test name, a lint rule, a build step). Add a Proof section mapping every acceptance criterion in spec.md to one check. List any criterion you cannot map as UNCOVERED, and any assumption as CONFIRMED or GUESS. Stop for my review.

Copy-paste prompt: evidence instead of a diff to read

Before I review this branch, produce an evidence summary. For each acceptance criterion in spec.md, name the test that covers it, show its result, and state whether it failed before your change. List every file you changed outside plan.md, every test you modified or deleted, and any dependency you added. Flag anything touching auth, payments, schemas, migrations, tests or CI config as NEEDS HUMAN READ.

A test that did not fail before the change proves nothing, and an edited test is the first place to look.

Where each part of Workflows & method helps

Subgroup	Start with	Reach for it when…
The lifecycle	The AI-native lifecycle	you want the six stages, their artifacts and signers
Principles	Principles	you need tool-independent rules: plan read-only, tests first, small batches
Context	Context management	the agent ignores conventions or runs out of context
Harness	The harness	you set permissions, hooks, skills and sandboxes
Plan & specify	Plan and specify	you turn a ticket into a spec with executable acceptance criteria
Build	Build patterns	the codebase is large, a monorepo or a set of services
Test & verify	Testing with agents	you need checks strong enough to trust without reading
Review & ship	Review and ship	a pull request needs an evidence bundle and a production gate
Operate & learn	Operate	production signals should feed the next intent.md
Automate	Automate	work should run from an issue to a pull request unattended

For a flat list of every cross-tool workflow, see Workflows, all tools.

Named methods such as Superpowers, Spec Kit and BMAD live under agentic development frameworks. The Developer Scorecard answer key maps each question to the page that improves it.

What breaks when a team adopts the method?

• Artifacts written after the code. A spec.md generated from the finished diff describes what was built, not what was wanted. Recovery: no plan-mode session before spec.md is accepted; the pull request links that commit.
• Autonomy raised before the checks exist. The agent’s own tests pass against broken code. Recovery: break the implementation on purpose and confirm the test goes red; move protected tests out of the agent’s write path.
• Gates that became rubber stamps. After ten green pull requests nobody opens the evidence. Recovery: keep escalation classes mandatory and fully read one routine pull request a week.
• Plan drift in long sessions. The agent wanders from plan.md. Recovery: one fresh session per task, given its number and proof command.

Where to go next with the method

Place your workflow on the Autonomy Ladder, then read the AI-native lifecycle and the artifact chain. Tech leads rolling this out continue with the adoption roadmap and governance and autonomy.