Verified against Claude Code · 2026-07-26
Structure a long Claude Code session with TodoWrite instead of losing track of what's left
A task-tracking discipline prompt that has Claude Code decompose a long task into a TodoWrite list at the start, keep exactly one item in progress at a time, and treat an item marked complete without stated verifiable evidence as not actually complete — closing the gap between looking organized and actually staying on track.
The prompt
Ready to copy — highlighted parts are example details you can swap.
This task is long enough that tracking it in a TodoWrite list from the start matters more than it would for a quick change — the list is not a status report written after the fact, it is the actual working plan this session follows. TASK Migrate all 40 prompt-library category files to the new tier field, verifying each file individually against the updated schema. HOW GRANULAR EACH TODO ITEM SHOULD BE One todo item per category file, not one item for the whole migration and not one item per individual prompt entry. WHAT COUNTS AS VERIFIABLE EVIDENCE AN ITEM IS ACTUALLY DONE A category file counts as done only once tsc --noEmit passes with no errors in that file and the prompt count matches the target stated for that category. DEFINITION OF DONE FOR THE WHOLE TASK Every category file has the tier field, tsc is clean repo-wide, and the full test suite still passes. RISK OF THIS SESSION BEING INTERRUPTED PARTWAY This will likely run across a context compaction given the number of files involved, and may also be paused and resumed manually. BEFORE STARTING Write the full TodoWrite list up front, broken down per One todo item per category file, not one item for the whole migration and not one item per individual prompt entry. — not so coarse that one item silently contains four days of hidden sub-steps, and not so fine that the list itself becomes more overhead than the work it tracks. WHILE WORKING - Keep exactly one item marked in_progress at any given moment. Do not mark a second item in_progress before the first is either completed or explicitly abandoned with a stated reason — a list with two simultaneous in-progress items has stopped functioning as a record of what is actually happening right now. - Update an item's status the moment its real state changes, not in a batch at the end of a work stretch — a todo list updated after the fact is a summary, not a tracker, and provides none of the mid-session recovery value a live list gives if the session is interrupted. - Do not mark an item completed unless it meets A category file counts as done only once tsc --noEmit passes with no errors in that file and the prompt count matches the target stated for that category. for that specific item — a step that looks finished because the code was written is not the same as a step confirmed against its actual verification bar, and marking it done regardless quietly lowers the bar for every item after it. - If a new sub-step is discovered mid-task that the original list did not anticipate, add it to the list explicitly rather than folding it silently into whichever item is currently in progress, so the list continues to reflect the actual scope of remaining work rather than a stale plan from before the discovery. IF THIS SESSION IS INTERRUPTED Given This will likely run across a context compaction given the number of files involved, and may also be paused and resumed manually., the list itself should be detailed enough that a fresh session, or a compacted continuation of this one, can reconstruct exactly what remains without re-deriving it from scratch — a todo item's own text should name enough specifics that its current state is obvious from reading it cold. AT THE END Compare the completed list against Every category file has the tier field, tsc is clean repo-wide, and the full test suite still passes. explicitly — a list where every individual item shows completed is not automatically proof the overall task is done if the original definition of done named something the list never captured as its own item.
Customize
Optional — swap in your own details for the highlighted parts above.
Why this works
A todo list maintained as a genuine working plan and a todo list maintained as an after-the-fact status report look identical the moment either one is glanced at, but they diverge completely in what they actually protect against — a list updated live, one status change at a time, as the real state of the task changes, is the only version that has any value if the session is interrupted partway through, while a list batch-updated at the end of a work stretch is reconstructed from memory at that point and carries exactly the same risk of drift and omission as any other after-the-fact summary. The single in_progress constraint is not a cosmetic rule about list hygiene — a session that marks two items in progress at once has implicitly started working on both simultaneously in a way that is very hard to actually track faithfully, and the discipline of finishing or explicitly abandoning one before starting the next is what keeps the list's in_progress marker meaningfully synchronized with what is actually happening in the session at any given moment, rather than becoming an optimistic aspiration about what will get done soon. Requiring a stated verification bar per item, rather than accepting 'the code is written' as sufficient to mark something done, targets the same gap the scope-locked bug fix and behavior-preserving refactor prompts target elsewhere in this category: writing code that looks correct and confirming it actually meets its bar are different activities, and a todo list that conflates them silently degrades the entire list's credibility, since a human trusting a completed marker later has no way to tell which items were actually verified and which were marked done on the strength of looking finished. The instruction to add a newly discovered sub-step explicitly rather than folding it into the current item matters because a task's real scope is frequently only fully visible once work on it has started, and a list that absorbs discovered work invisibly into existing items understates the actual remaining effort to anyone reading it, including a future compacted version of this same session trying to reconstruct where things stand. Comparing the finished list against the task's stated definition of done as a final explicit step, rather than trusting a fully-checked-off list by default, closes the last gap between 'every item I wrote down is done' and 'the actual task is done' — those are only the same claim if the original list was a complete decomposition of the task, and that completeness is exactly the thing worth verifying once, at the end, rather than assuming it was true from the moment the list was first written.
Verified against
Claude Code Sonnet 4.6 · 2026-07-26
Changelog
- 2026-07-26 — Initial publish, verified against Claude Code TodoWrite tracking (Sonnet 4.6).
Building this for real?
This is a free starting point. If you'd rather have custom software built and running for your business, that's Scult's day job.
EXPLORE CUSTOM SOFTWARE
