ClaudeDo

A Windows desktop app that turns your to-do list into a work queue for Claude Code.

Write down what you want done. ClaudeDo picks the task up, runs Claude in an isolated git worktree, and hands you back a diff to review. Your main branch is never touched until you approve.

It looks and feels like a normal task app — lists, My Day, stars, due dates — except every task can also be executed.

---

Contents

• Is this for you?
• Requirements
• Install
• The window
• The core loop
• Lists and repositories
• Writing a task
• Ways to run a task
• Watching work happen
• Reviewing and merging
• Resolving conflicts
• Worktrees
• Staying inside your usage limits
• Your daily rhythm
• Settings
• Letting Claude drive ClaudeDo
• Updates
• Where your data lives
• Keyboard shortcuts
• Troubleshooting
• For developers

---

Is this for you?

ClaudeDo is built for one person running many small-to-medium coding jobs across several repositories, mostly unattended.

It fits when you:

• have a backlog of contained changes ("rename this", "add that endpoint", "fix this bug")
• want them worked on while you do something else
• still want to read every diff before it lands on main

It is not a CI system, not a team tool, and not a chat window. There are no pull requests, no reviewers but you, and no cloud component (unless you deliberately turn on the optional online inbox).

Requirements

• Windows 10/11
• Claude Code CLI, installed and signed in (ClaudeDo runs claude as you — it never handles your credentials)
• Git
• .NET 8 Desktop Runtime — the installer itself needs it, so install it first if the installer refuses to start

Install

Run ClaudeDo.Installer.exe. It downloads the current release, writes its config, and starts the background worker.

The wizard asks for:

Page	What it decides
Welcome	Install folder, and whether Claude may manage your tasks via MCP (see below)
Data paths	Where the database, logs, sandboxes and worktrees live
Worker	Port, path to the claude binary, and whether the worker starts at logon

Re-running the installer later gives you Update, Repair and Uninstall instead of the full wizard. Uninstall asks separately before deleting your tasks and settings.

ClaudeDo has two parts: the window you see, and a background worker that does the actual running. The worker starts at logon and keeps going even when the window is closed — so a long task finishes whether you are watching or not.

The window

Three panes ("islands"), plus a footer:

┌──────────────┬────────────────────────────┬───────────────────────────┐
│  LISTS       │  TASKS                     │  DETAILS                  │
│              │                            │                           │
│  My Day      │  ▸ Add a task…      ENTER  │  Fix login redirect       │
│  Important   │                            │  ─────────────────────    │
│  Planned     │  OVERDUE                   │  Steps      ▢ ▢ ▣         │
│              │  ● Fix login redirect      │  Details    (markdown)    │
│  Queue    3  │                            │  Files      (drop here)   │
│  Running  1  │  TASKS                     │                           │
│  Review   2  │  ● Add CSV export  RUNNING │  Worktree · Diff · Merge  │
│              │  ● Bump deps      QUEUED   │                           │
│  MY LISTS    │  ● Write changelog         │  Output │ Git │ Session   │
│  LagerApp  7 │  ● Call the tax guy MANUAL │  ┌─────────────────────┐  │
│  LogX      2 │                            │  │ live Claude output  │  │
│  ClaudeDo 12 │                            │  └─────────────────────┘  │
├──────────────┴────────────────────────────┴───────────────────────────┤
│ ● Online   5h 41% · 7d 22%   worker log line…                    logs │
└───────────────────────────────────────────────────────────────────────┘

• Lists (left) — smart lists, virtual work lists, and your own lists (one per repo)
• Tasks (middle) — the selected list, grouped into Overdue / Tasks / Completed
• Details (right) — everything about the selected task, including its live output
• Footer — worker connection, usage pill, and the latest worker log line (clickable)

On a narrow window the side panes fold away automatically.

The grid icon in the title bar opens Mission Control, a separate window for watching several running sessions at once.

The core loop

   write it down  →  queue it  →  Claude runs it  →  you review  →  merge
      (Idle)         (Queued)       (Running)      (Waiting for      (Done)
                                                      Review)

1. Capture. Type into the add box. That is it — a task starts out as a plain reminder.
2. Queue. Right-click → Send to queue. The worker claims queued tasks in order, as many at a time as Max parallel executions allows.
3. Run. ClaudeDo creates a git worktree off your repo (branch claudedo/<id>), runs Claude there with your task as the prompt, and streams the output into the detail pane.
4. Review. On success the task lands in Waiting for Review with a committed worktree and a diff. Nothing has touched your working copy.
5. Merge. Approve & merge merges the branch into the target you pick, then marks the task Done. Or reject it with feedback, park it, or cancel it.

A task that fails is marked Failed and keeps its worktree and its log, so you can look at what happened and either continue the same session or reset and retry from scratch.

Lists and repositories

A list becomes runnable by giving it a working directory — a git repo. Tasks in that list get worktrees off that repo; tasks in a list without a working directory can still be run, but in a scratch sandbox with no git.

• Add repos as lists (Repositories menu, or the folder icon) scans folders you point it at and creates one list per git repo it finds. This is the fastest way to get started.
• List settings (right-click a list) sets the name, working directory, default commit type, the agent defaults for that list, and an optional verify command.
• Manual list — mark a list as reminders-only. New tasks in it start out manual, so automation never touches them. Good for a "Errands" or "Phone calls" list.
• Drag a task onto another list to move it. ClaudeDo refuses to move a running task and warns you when the two lists point at different repos.

Smart lists are always there:

List	Contains
My Day	What you (or the daily prep) picked for today, plus a pinned Notes row
Important	Starred tasks
Planned	Everything with a date
Queue / Running / Review	Live work — waiting, in flight, and awaiting your review

Writing a task

The detail pane is where a one-line reminder becomes a brief Claude can act on:

• Title + Details — markdown, with an edit/preview toggle. This is the prompt.
• Steps — a checklist. Handy for you, and included when you copy the task out.
• Files — drag files onto the pane (or use Add file…) to attach reference material. Attachments are handed to Claude as read-only paths, not pasted into the prompt.
• Star / Schedule / Add to My Day — the usual task-app affordances.
• Agent settings — per-task overrides for model, turn budget, extra system prompt, agent file and skills. Anything you do not override shows an inherited badge pointing at the list or global default.
• Refine — hand the task to Claude to sharpen it: it rewrites the title and details into a proper brief. Useful when you captured something in three words.
• Mark as manual — a MANUAL badge; the queue, the daily prep and every automation skip it. Use it for things only you can do.

Ways to run a task

Way	What it does	Use it when
Send to queue	Worker picks it up in order	The normal path
Run now	Skips the queue, starts immediately	You want this one first
Continue	Resumes the last session with a follow-up	"Almost right, now also…"
Reset & retry	Throws the worktree away, re-queues from scratch	The run went sideways
Open ConPTY session	Opens the real Claude terminal for this task in Mission Control	You want to drive it yourself, with the task as the starting brief
Open planning session	An interactive session whose job is to break the task into subtasks	The work is too big for one run
Let Claude handle it	Hands a whole list over in one go	You have a pile of small tasks

Planning sessions

A planning session is a conversation whose output is structure, not code. Claude creates child tasks under the parent. You then:

1. Finalize plan — children are chained (each waits for the previous one) but stay Idle.
2. Queue plan — when you are happy with the list, this queues them all.
3. The parent waits in Waiting for Subtasks until every child is terminal, then surfaces for review once — you review and merge the whole unit, not each child.

A parked planning session is remembered; the next launch offers to resume, finalize or discard it.

"Let Claude handle it"

Right-click a list → Let Claude handle it. You get a checkbox list of that list's open tasks. Confirm, and one Claude session works the selection end to end: it reads them, de-duplicates overlaps, enhances thin descriptions, queues the work, and merges the results. It shows up as its own MANUAL task so you can see what a given run covered, and you review the combined diff when it is finished.

Watching work happen

• Detail pane, three tabs — Output (live Claude stream), Git (worktree, diff, merge), Session (result, token/turn counts, subtask outcomes).
• Mission Control — one tile per running or interactive session, in Focus or Overview mode. ConPTY tiles are the real Claude TUI, embedded: keyboard, colors, / commands, all of it. New session opens an ad-hoc one that belongs to no task.
• Roadblocks — when a run gets stuck it reports a roadblock instead of silently failing. The Session tab shows it as its own card with a reply box: answer the question and the same session picks up where it stopped.
• Claude is asking — an interactive session can put a question in front of you mid-run; answer it inline in Mission Control and the run continues.
• Footer log strip — the worker's latest event. Failures of your own actions flash here too, instead of vanishing. Click it for the last 30 minutes of worker logs, with a warnings-and-errors filter.

Reviewing and merging

When a task reaches Waiting for Review you get four actions:

Action	Result
Approve & merge	Merges the work into the target branch, then Done
Reject	Asks for feedback and re-runs the same session with it
Park	Back to Idle so you can rewrite the task yourself
Cancel	Done with it; the worktree stays until you clean it up

You have to look before you approve. When there is a diff to inspect, Approve & merge stays disabled until you have opened the diff viewer once. It re-locks after any new run. (The quick-approve on the task row itself is a deliberate bypass for when you already know.)

The diff viewer shows a file tree on the left and the diff on the right, and can show a dirty worktree, a branch against its base, or a commit range. For a parent with children, Review combined diff shows per-subtask diffs plus a combined preview of the whole unit.

Verify command (optional, per list) — a command that must exit 0 after a merge lands before the task is allowed to reach Done. Typically a build or a test run. If it fails, the merge stays (nothing is rewritten behind your back) but the task is held out of Done and the failure output is reported.

Resolving conflicts

If a merge conflicts, ClaudeDo opens a three-pane merge editor in-app:

┌──────────────────┬──────────────────┬──────────────────┐
│ MAIN             │ RESULT           │ INCOMING         │
│ merge target     │ (editable)       │ task branch      │
│                  │                ▐ │                  │
│  ›               │  ← you build     │               ‹  │
│                  │     the result   │                  │
└──────────────────┴──────────────────┴──────────────────┘

• Whole files, syntax-highlighted, scrolling in sync
• Each conflict starts empty. The gutter arrows toggle each side in or out — take main, incoming, both (in the order you click), or neither
• Only conflict regions are editable in the middle pane; type your own resolution if neither side is right
• F8 / Shift+F8 jump between conflicts; the ruler beside the result pane maps every conflict in the file
• A counter tells you how many files still need attention. Resolve & continue is disabled until they are all done, and Abort merge always leaves the target branch as it was

Binary conflicts cannot be resolved here — ClaudeDo says so and lists the paths.

Worktrees

Every run gets its own worktree, so parallel tasks never fight over your checkout.

The Worktrees overview (per list or global) lists them with state, diff size, age and outcome. From there you can show a diff, jump to the task, merge, batch-merge a selection into one target, mark one Kept or Discarded, or force-remove a leftover. Worktrees whose directory is gone from disk are flagged as phantom.

Finished worktrees are auto-cleaned after a number of days you choose in Settings.

Staying inside your usage limits

The footer pill shows your Claude usage: 5h 41% · 7d 22%. Click it for the Usage Monitor:

• Gauges for the 5-hour session window and the 7-day windows, each with a reset countdown
• Models — token usage per model over a range you pick, split into ClaudeDo's own consumption and everything else
• Tasks — your biggest consumers, with run counts and totals

And the part that matters when you are asleep: the usage limit stop. Set a percentage per window in Settings, and once usage reaches it the queue simply stops picking up new tasks. Running tasks finish normally, and the queue resumes by itself as the window rolls over. 0 turns a stop off. Manual actions — Run now, Continue, interactive and planning sessions — are never blocked.

Your daily rhythm

• My Day — the day's shortlist. Clear day empties it.
• Prime Claude (Settings → Prime Claude) — schedules for the days and times you pick. At that time ClaudeDo runs a short prep session: Claude looks at your idle tasks, picks an effort-aware subset up to your daily cap, and fills My Day. It also warms your usage window for the day. Only runs while ClaudeDo is open; if you start the app within 30 minutes of a scheduled time it fires right away. Plan day runs it on demand.
• Notes — a pinned row in My Day: dated bullet notes with a day navigator, for the thoughts that are not tasks.
• Weekly report (Help menu) — pick a range (defaults to "since your standup weekday") and Claude writes up what actually happened, from your task and session history. Paths you do not want in reports can be excluded in Settings.

Settings

Most settings exist at three levels — global → list → task — and the more specific one wins. Overridden fields carry an override badge with a one-click reset; inherited ones say where they come from.

General

• Default instructions applied to every task
• Default model, and a per-model table of reasoning effort and turn budget — so haiku can be cheap and short while opus gets room to think
• Permission mode for autonomous runs
• Max parallel executions
• Usage limit stops (see above)
• Session skills applied to every task
• Report exclusions, standup weekday
• Accent color (Moss / Peat / Sea) and language (English / German)

Worktrees — sibling or central placement, auto-cleanup age, and the manual cleanup and force-remove-all buttons.

Files — open the prompt templates (system, planning, retry, daily prep, weekly report) in your editor, and restore the bundled default agent files.

Skills — install a skill from a git URL, update it, remove it. Skills selected globally, per list and per task combine.

Prime Claude — the schedules and the daily task cap.

Online Inbox (optional, off by default) — mirrors your idle backlog to a server so you can capture tasks from your phone. Disabled means zero network traffic. Enabling it needs a URL plus a sign-in; the refresh token is stored encrypted on your machine, never in a config file.

Letting Claude drive ClaudeDo

If you allowed it during install, ClaudeDo registers itself as an MCP server with the Claude CLI. Any Claude session on your machine can then read and manage your tasks: list and create tasks, add subtasks, queue and cancel runs, read logs and diffs, merge, review, manage lists and per-list config.

Concretely, you can sit in a normal Claude Code session and say "put these five things in the ClaudeDo backlog for the LagerApp list", or "check whether the CSV export task is done".

The MCP surface is deliberately narrow on the dangerous end: it can start and observe work, but it cannot rewrite your app settings, and a task with an active worktree cannot be forced to Done behind your back.

Updates

ClaudeDo checks for new releases and shows a banner when one is out. Update now relaunches the installer, which stops the worker, swaps the binaries and starts it again. Your database, worktrees and settings are preserved. You can also check manually via Help → Check for updates.

Where your data lives

Everything is under %USERPROFILE%\.todo-app:

Path	What
todo.db	Your tasks, lists, runs and worktree records (SQLite)
ui.config.json	Window and UI settings
worker.config.json	Worker settings — paths, port, worktree strategy
logs/	Worker and task logs
agents/	Your agent definition files
attachments/	Files you attached to tasks

Help → About links straight to these folders. Nothing leaves your machine unless you turn on the online inbox.

Keyboard shortcuts

Key	Action
Ctrl+K	Focus search
Ctrl+N	Focus the add-task box
Enter	Add the task
Esc	Leave the current text field / close a dialog
F8 / Shift+F8	Next / previous conflict (merge editor)

Troubleshooting

"Worker not reachable" — the background worker is not running. The dialog offers to start it; Worker → Restart worker does the same later. If it keeps happening, re-run the installer and choose Repair.

A task failed immediately — usually the claude CLI is not signed in, or the list's working directory is not a git repo. Check the Output tab and the footer log.

A task is stuck in Running after a crash — the worker sweeps orphaned runs to Failed on startup. Restart the worker.

Nothing is being picked up — check the usage pill: if a usage stop is active the queue is paused on purpose. Also check whether the tasks are MANUAL, blocked by a predecessor, or scheduled for later.

For developers

Architecture, build commands and per-project docs live in CLAUDE.md (root and one per project under src/). Short version: .NET 8, Avalonia UI, SQLite via EF Core, and a SignalR-connected worker process on 127.0.0.1:47821.

dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release
dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj -c Release
dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release

License

Private — not licensed for redistribution.