Every new session, you explain the project again.
The constraints, the settled calls, the half-built plan — they were in yesterday's chat, and yesterday's chat is gone. So you type it out from memory, and hope you didn't leave out the one thing that mattered.
Sketch it once on a canvas your AI works on too. It reads the board before it types, so nothing has to be said twice.
The build gets a shape — and keeps it between sessions.
You say what “done” means. Once.
Talk the feature through and the brief and the acceptance criteria land as cards you can both point at — must, should, could, won't. Change a line and the build changes with it. Done stops being something you remember and starts being something you can see.
You watch the build, not the diff.
While it works, the board keeps score: the checklist ticks itself, and a plain-language log lands at the end saying what changed and what's next. You stay on top of a build you didn't have to read a single line of output to follow.
Tomorrow's session starts where this one stopped.
Open a fresh terminal next week and say “continue”. It reads the decisions and their reasoning before it types — so the settled calls stay settled, and the bug you flagged from the train is still there, waiting.
You stop being the thing that remembers.
Nothing gets re-explained
Every session opens with the project already in front of it — the constraints, the decisions, the state of the build.
A build you can see
The plan, what's done and what's still open, at a glance — instead of buried in output you'll never scroll back through.
Decisions that stay decided
The why is written down in the one place your AI actually reads, so it stops re-litigating calls you made weeks ago.
Caught on the train, fixed that night.
Real prompts. Real cards. Try them today.
Everything on this page is something you can say to your AI on a connected canvas.
“Write the brief and acceptance criteria for the waitlist feature as cards — must/should/could/won't.”
“Keep a build checklist on the board and tick it as you go; log the session when you stop.”
“Record the auth decision as a decision card — options, trade-offs, and why we chose magic links.”
“The signup button is broken on small screens — capture it on the bug board with a repro.”
“Read the board and pick up where we left off.”
“What's still open before the beta? Check the board.”
Works with the AI you already use — Claude Code at your desk, the Claude app on your phone. One canvas between them.
Every screenshot here is a real canvas
No mocked UI. This board was written by an AI over a live connection while it was building, captured from the board itself on 3 September 2026.
Your terminal stays your terminal
duetpad doesn't replace Claude Code — it sits beside it. The code happens where it always did; the thinking finally has somewhere to live.
What builders ask first.
Does this replace my terminal or editor?
No. Your AI keeps building wherever it builds today. duetpad is the shared surface beside it — the plan, decisions and state of the build, visible and persistent.
How does my AI connect?
A couple of minutes, no keys to juggle. Once connected, your AI can read and write the canvas — from Claude Code, the Claude app, or another assistant you have connected.
Do I have to maintain the board myself?
No — that's the point. Your AI writes the checklist, logs and decision cards as part of working. You edit and veto; it does the bookkeeping.
What happens between sessions?
The board persists. A new session reads it — decisions, open bugs, what's next — and continues, instead of starting from a blank chat.
What does it cost?
A 14-day free trial — the whole canvas, no card. After that it’s $24 a month or $228 a year, and you bring the AI you already pay for.
Stop explaining your project twice.
14 days free, no card. Works with the AI you already use.
Start free See a real board →