Fifteen concrete ways TwigDo gets used — on your own, across a team, and with an agent working a standing board without being told twice. Every one of them is the same tree; only who touches it changes.
A flat list is where a big thing goes to become invisible. These are the cases where the shape does the remembering.
A long write-up is a tree pretending to be a list. Chapters branch into sections, sections into the paragraph you have been avoiding for a week. Written flat, the avoidance is invisible; written as a tree, the ring on that chapter simply refuses to fill.
The shape: One project, a branch per chapter, leaves for the sections. Derived progress means you never mark a chapter done — it becomes done when its sections are.
Half of moving is admin nobody warned you about: searches, surveys, redirecting post, telling the council. It arrives in no order and each item spawns two more.
The shape: Add tasks as they turn up and drag them under the right limb later. Due dates on the ones with deadlines, and the Gantt view when you need to see what has to happen this week.
The cost of an occasional project is re-reading your own mind every time you come back. A tree holds the shape so you do not have to.
The shape: Hide completed, so Sunday opens on what is left rather than on what you already did. Snap the limbs together and the whole thing fits on one screen.
Syllabus in, revision out. The exam board publishes a hierarchy already; you are just filling it in.
The shape: Import the syllabus as main tasks, break each into what you actually need to revise, and let the percentage tell you where you are weak instead of guessing.
Everything in your head, in any order, as fast as you can type it — then shape it afterwards. Sorting while capturing is what stops people capturing.
The shape: Type into the add bar without thinking about structure, then drag the pile into limbs. Re-ordering on the map is a drag; nothing has to be right first time.
Delegation in TwigDo is structural: a limb becomes someone else's project, and its progress still counts towards yours.
Three groups who need to see their own work and one person who needs to see all of it. The usual answer is three boards and a weekly meeting to reconcile them.
The shape: One tree, one limb per discipline. Everyone works their branch; the top-level ring is the launch, and it is honest because nobody types it in.
A contractor should see their piece and nothing else — not your other clients, not your internal roadmap.
The shape: Spin the branch into its own linked project and share that. They see their limb; progress still flows back into your parent tree, and the shell node in your plan keeps counting.
Sprint boards usually mean re-entering work that already exists somewhere as a plan.
The shape: Name a fortnight, give it a goal, and pull tasks into it from any branch of any project. The tree stays the source; the sprint is a lens on it.
The risk in a handover is not the work, it is the context — what was tried, what was decided, what is still open.
The shape: Assign the branch, and the notes and activity travel with it. Whoever picks it up reads what happened rather than asking.
First-week checklists rot because they live in a document nobody owns.
The shape: Keep the onboarding tree as a template project, duplicate it per starter, and watch the ring fill instead of chasing.
The agent claims a branch before touching it, plans it where you can see the plan, and reports what it built. A run leaves an account of itself.
This is the one TwigDo was really built for. Point an agent at a project — or add it as a collaborator — and stop instructing it per task. You add work to the board as you think of it; the agent claims the next item, plans it, does it, and reports back. The list doubles as the agent's standing stream of instructions, so there is no second channel to keep in sync and nothing to re-explain each session.
The shape: One long-lived project. You write tasks; the agent claims, plans, works and reports against each. The protocol is enforced server-side, so it cannot quietly skip the plan.
File defects the moment you hit them, in whatever words you have at that second. Triage later, or not at all.
The shape: Each defect is a task with a note. The agent takes them in order, and closes each with a sentence on what the fix was — so the log is also the changelog.
Ideas arrive constantly and most of them are worth writing down and not doing yet.
The shape: One intake limb. Anything you want built moves out of it into a real branch; the rest sits there costing nothing, visible, and not blocking.
The agent works while you do not. The question the next morning is what changed and whether you agree with it.
The shape: A scheduled run claims from the board and reports into it. You read the tree over coffee — the account of the work is the work's own record, not a terminal you have to scroll back through.
The risk with an agent is not that it works too slowly, it is that it confidently builds the wrong subtree.
The shape: Hand it a goal, have it plan the breakdown into the tree, and approve or redirect before a line is written. The plan is a thing you can argue with.
