On this page
“Build the whole thing” is a hard instruction to resume after an interruption. A long coding task may span several sessions, change direction, or uncover a failure in an early assumption. A transcript can show what happened, yet still leave the next session unsure what to do.
A staged plan is a small working record of the current goal, the next bounded step, and the evidence needed to move on. It helps a person and an agent coordinate; it is not a replacement for judgment, testing, or the user’s permission to take an action.
Start with the outcome, not a long task list
Write a goal that can be checked by someone who did not write the plan. Include constraints such as which data may be used, what must stay unchanged, and which actions need approval. Then identify the next uncertainty: an API contract, a missing fixture, an environment, or a choice that would affect later work.
For example, imagine a fictional project that turns a small public CSV into a searchable page. The goal is “produce a searchable page whose results match the supplied fixture,” not “finish the frontend.” A possible plan is:
| Stage | Deliverable | Evidence before moving on |
|---|---|---|
| 1. Define | Input fields, expected output and a tiny fixture | Requirements and example results are agreed |
| 2. Build a slice | One input-to-search path | Fixture works end to end locally |
| 3. Check | Edge cases and regression tests | Empty input and malformed rows behave as specified |
| 4. Handoff | Instructions, known gaps and a reviewable change | Checks are reported; publication happens only if authorized |
The order matters: the fixture makes “correct” observable before the interface grows. A failed check keeps the stage open; a deployment is a separate decision, not an automatic consequence of a green test. This table is an illustration, not a claim about a real project or its results.
Give every stage an exit criterion
A stage should be small enough to finish or reassess without losing the overall goal. For each one, record:
- Purpose and dependency: why this stage comes now and what it needs from earlier work.
- Output: a concrete artifact, decision, or reproducible test—not just “investigate.”
- Exit criterion: what observation is sufficient to move on, including a way to report failure or uncertainty.
- Boundary: actions that are allowed, actions requiring confirmation, and what must not be changed.
“Add tests” is an activity. “A test distinguishes an empty input from a malformed row, and both expected outcomes are documented” is an exit criterion. Passing that test says those cases behaved as checked; it does not prove the whole project correct.
Avoid inventing exact estimates for work whose scope is unknown. Timebox exploration if helpful, but leave a stage blocked when evidence or permission is missing. A blocked item is useful information, not a completed task.
Keep one active goal and a short handoff
At the end of a session, save a checkpoint in the project’s approved workspace. For the fictional CSV project it might look like this:
Goal: searchable page matching the agreed CSV fixture.
Current stage: build one input-to-search path.
Done: field contract and fixture approved.
Observed: local parser test passes; search is not implemented yet.
Next: implement search against the same fixture.
Blocked / risks: malformed-row behavior still needs a decision.
Constraints: no publication or external data changes without approval.
Keep links to tests and changes when they are available; record their version and actual result. On resumption, inspect the current workspace and rerun relevant checks rather than trusting an old status blindly. A handoff should distinguish done, in progress, blocked, and not yet tested.
Do not put credentials, private data, or sensitive logs in a shared checkpoint. The amount of detail and location of the record should follow the project’s access rules.
Change the plan when evidence changes
If the fixture reveals that an input assumption was wrong, pause before building the remaining stages on top of it. Record the new evidence, the options considered, the decision and its consequence, then update the dependent stages. A short decision record is often more useful than rewriting history as though the original plan was always correct.
Do not use a fixed checklist as an excuse to ignore a more urgent issue. In an incident, mitigation may need to come before a clean investigation. For a small, obvious edit, a full staged plan may be unnecessary overhead.
The plan answers “what is the next deliverable?” The hypothesis tree answers a different question: “which explanation should we test next?” They can link to each other without turning every task into a large tree.
What this borrows from existing practice
This approach combines familiar ideas: small, testable increments; documented decisions and trade-offs; and a state record that makes handoffs possible. Continuous integration describes a specific practice of frequent integration and automated builds, not merely having stages. An incident-state document serves an incident, not every project. Neither source proves that this particular plan format makes agents faster; use the format only where it helps.