Notes
Notes on planning and running coding agents
Notes from building Ordewell: how a plan is written, how its tasks run side by side, and how a finished task is checked. Each one stands on its own.
For Ordewell set beside other tools, see the comparisons. For setup and settings, see the docs.
Before anything runs
- Ask first: the questions a planner asks before it writes the plan: The questions a planner asks before it writes the plan, why they come one at a time, and what happens when there is nobody to ask.
- Do you need a PRD before a coding agent starts?: When a PRD pays off, when it is busywork, and what it does not guarantee.
- Plan first orchestration vs parallel worktree sessions: One ordered plan you review before anything runs, or several agents in parallel worktrees you watch.
- Editing a plan without reprompting the model: What a plan looks like when changing a task is a field edit instead of a conversation.
- How big should a task be in an agent plan: What task size decides, the slicing rules, the two exceptions, and the part you still fix by hand.
- Why the planner should not be the executor: Planning, executing and verifying are three jobs, and what each side of the seam is allowed to do.
- One plan, several models: choosing an executor per task: How per task runner, model, effort and mode assignment works, and where it still bites you.
- Read only exploration: letting an agent look without letting it touch: What a read only envelope is, how each CLI enforces it for the planner, and the failure mode where the sandbox is broken.
While the plan runs
- Task order: when a task is ready to run, and what can run in parallel: The readiness rule: which tasks may start, in what order, and why a dependency counts as met only when its work is merged.
- Running several coding agents on one repo without them overwriting each other: One git worktree and one branch per task, how the results are integrated, and what still blocks.
- What each task in a plan is handed, and what it is not: What a task is handed from its predecessors, and what it has to pull through the graph.
- When a coding agent runs out of context mid task: Why a long session forgets earlier decisions, what compaction buys, and the structural fix of bounded tasks.
- What a coding agent may run without asking you: What a coding agent may run unattended, why a grant is keyed on a scope, and what an unanswered prompt does.
- Orchestrating coding agents without a second API key: Driving the coding agent CLI you already signed into instead of holding a key, and what the preflight can honestly check.
After the verdict
- How to tell when a coding agent has actually finished: Why exit codes and an agent saying it is done are weak signals, and the attempt-bound tool call Ordewell uses instead.
- The transcript is the record: reading what a coding agent actually did: Where Claude Code, Codex and OpenCode keep their transcripts, and why the record is not proof of work.
- When one task fails, what happens to the rest of the plan: What a failed task keeps, why only its dependents park, and how to retry one task without rerunning the plan.
- Where the plan lives when the terminal closes: Where a plan and its work live between sessions, how to come back to one, and how to land the branch a run produced.