In Part 2, pycalc went through its planning interview. A side product you may have noticed: the interview generated ideas we deliberately rejected — Claude itself deferred the ** power operator with the note that right-associativity is "the ideal v2 exercise". Reading from stdin dropped out too. The non-goals now say "Do not add * or % in this version."*

But a non-goal is a rule, not a plan. It says what must not happen now — it doesn't say what should happen someday. So where does "someday" go?

I know all three bad options from my own practice: your head (you forget), an IDEAS.md file growing forever (exactly the documentation pile mini stands against), or creating it as a phase right away (and the project state silts up with a future that may never come).

mini todo is the fourth option: a backlog for things that aren't phases yet.

Zero tokens

First the most important part, faithful to Part 0: mini todo never starts Claude. It's pure TypeScript over one markdown file — adding an idea costs exactly 0 tokens. You pay only at the moment the ideas become useful: mini next offers them as candidates, each as a single line.

And because the command needs no TTY and no interaction, it works the same from the terminal and as the /mini:todo slash command in the middle of a Claude Code session — when an idea shows up while you're working on something else, the agent stashes it with one call and nobody loses the thread.

pycalc gets a backlog

cd pycalc
mini todo

The todo archive is empty. Add an idea with `mini todo add "<text>"`.

Let's pour in what the interview deferred:

mini todo add "Power ** and modulo % — right-associativity of ** is the v2 parser exercise"
mini todo add "Read the expression from stdin so pycalc works in pipes (echo \"2+2\" | pycalc)"
mini todo add "Interactive REPL mode"

[ok] Added: Power ** and modulo % — right-associativity of ** is the v2 parser exercise
[ok] Added: Read the expression from stdin so pycalc works in pipes (echo "2+2" | pycalc)
[ok] Added: Interactive REPL mode

mini todo

Ideas & changes
  1. [ ] Power ** and modulo % — right-associativity of ** is the v2 parser exercise
  2. [ ] Read the expression from stdin so pycalc works in pipes (echo "2+2" | pycalc)
  3. [ ] Interactive REPL mode
  3 open / 3 total
  Actions: list · add "<text>" · edit <n> "<text>" · done <n> · remove <n> · clear

And immediately, the first act of curation. That third line is a mistake — not because a REPL is a bad idea, but because one-shot evaluation is the identity of the tool, not a version constraint. "What I'm building" from Part 2 says evaluates one expression and exits. A REPL isn't a deferred idea; it's a different program. The backlog deserves the same strictness as the non-goals:

mini todo remove 3

[ok] Removed: Interactive REPL mode

That's the whole curation lesson: done <n> ticks off (built), remove <n> deletes (we changed our mind), clear sweeps out everything ticked.

One file, readable without mini

The entire archive is .mini/todo.md — a plain markdown checklist:

# Ideas & changes

> Archive of future ideas and changes for this project. Managed by `mini todo`
> (`add` / `done` / `remove`); `mini next` offers the open items as candidate
> phase ideas. You can also edit this checklist by hand.
- [ ] Power ** and modulo % — right-associativity of ** is the v2 parser exercise
- [ ] Read the expression from stdin so pycalc works in pipes (echo "2+2" | pycalc)

The last sentence of the header isn't decoration: you can edit the file by hand and mini won't mind. The parser only takes checklist lines and ignores everything else — the state can't break because you scribbled a note into the file.

The payoff: the backlog reports for duty

Here's where it connects. The next time we run mini next, this block gets bundled into the prompt — verbatim:

# Ideas in the backlog
The project keeps an ideas/changes archive (`mini todo`). Open items (numbered
by their archive position), any of which could become the next phase:
- [1] Power ** and modulo % — right-associativity of ** is the v2 parser exercise
- [2] Read the expression from stdin so pycalc works in pipes (echo "2+2" | pycalc)
If one of them fits as the next step, propose it. When you save such a phase,
add `--from-todo <n>` (the bracketed number) to `mini next --apply` so the
source item is ticked off automatically.

Note the last rule: when an idea becomes a phase, the agent saves it with --from-todo <n> and the item ticks itself off in the archive. No manual reconciliation of "which backlog items did we already do". It works the other way too — when you let mini next propose freely and it generates more candidates than fit into one phase, it offers to stash the surplus into todo so nothing gets lost. The backlog fills and drains from both ends.

What todo deliberately can't do

No priorities, labels, due dates, owners. It's a one-line checklist, not an issue tracker — if a project needs Jira, it should have Jira. One practical consequence follows, worth keeping in mind as you write items: the one-line text is all that survives. The discussion that led to the idea doesn't exist here. So write items that carry the why — compare "Add *" with "Power * and modulo % — right-associativity of ** is the v2 parser exercise". Half a year later, the second one still makes sense; the first one is a riddle.

Next time

We have a backlog, the project has a vision — and not a single line of Python exists yet. That changes next time: mini's main loop, next → plan → do → done, takes one item and carries it all the way to a finished phase.

mini is open source: npm install -g mini-orchestrator, then mini install-commands in your project. Source and docs on GitHub.