Philosophy
Most productivity tools treat projects and tasks as fundamentally different things — different object types, different screens, different fields, different rules.
At first that seems harmless: you can usually toss a quick thought into an inbox. But real work grows, and that’s when the wall appears. Sub-tasks only nest so deep — one level in some tools, four or five in others — and past the ceiling, your task must be converted into a project. Where a conversion exists at all, it’s one-way and lossy: comments and attachments stay behind, time tracking disappears. And coming back down — turning the project that fizzled into the simple task it should have been — is something almost no tool allows. Their own help pages say why: the two objects are too different for your data to survive the trip.
So you learn to guess. Is this going to be big? Should I make it a project now, just in case? You end up managing your tool instead of managing your work.
We checked
As of mid-2026, from the tools’ own documentation: Todoist caps sub-tasks at four levels and has no task↔project conversion — a third-party extension exists just to fill the gap. Asana’s “Convert to project” leaves your comments and attachments behind, and converting back has been an open feature request since 2017. ClickUp warns its conversion “is permanent and cannot be reversed.” And Amazing Marvin explains why it won’t turn projects back into tasks: “information would likely be lost.”
MakeTimeFlow doesn’t force you to guess: you don’t decide up front — just let it flow.
You capture because something is notable — a thing you might do, an idea worth keeping, a half-thought you want back. Often you’ll jot your first thinking right into its notes. What it is comes later, once you’ve decided what you want to do about it. Some things stay tasks. Some grow into outcomes bigger than any single sitting. Some turn out to be shelves that organize other work. Some were never things to do at all — they were things to keep.
When you notice what something has become, you can tell MakeTimeFlow — one action, fully reversible. That’s not categorization. That’s recognition. You’re not filling in a form field; you’re naming what your work already turned into. And once the system knows, it can finally get out of your way: shelves stop showing up in your today list, projects earn honest time on your calendar, and reference material stops nagging you like an overdue chore.
The Six Kinds of Nodes
Everything lives in one tree, side by side, with the same interactions. A node’s type just tells MakeTimeFlow what kind of thing it is:
| Type | What it is | Can you complete it? | Can you make time for it? |
|---|---|---|---|
| Task | Something you can do in a single focused sitting | Yes | Yes — schedule it, time it |
| Project | An outcome you’re committed to that’s bigger than one sitting | Yes — when the outcome is reached | Yes — block time to work on it |
| Folder | A shelf: pure organization (“Home”, “Team”, “Someday”) | Never asks to be — retire it when its work is done | Never asks for time — but you can time working on it |
| Info | Something worth keeping in context: a decision, an observation, a reference | Nothing to do — completing it just says “seen, done with this” | Never asks for time |
| Event | A time commitment synced from your calendar | It happens at its time | It already has its time |
| Marker | A visual divider that organizes a view | No | No |
The anchor definition is the task: something you can accomplish in a single focused session. That’s the unit your day is actually built from. Every other type exists to protect that definition — so that when you look at today’s list, everything on it is genuinely doable. It’s also a great principle for you to know when you have “finished” breaking something down enough. It also makes it a lot easier to plan out your day.
Types change what MakeTimeFlow expects of you — never what you’re allowed to do. Non-actionable types stay out of your buckets and never nag. But every node keeps every verb: complete a folder to retire it (its contents complete with it, reversibly), or start a timer on one while you tidy it up. Your tool doesn’t tell you no.
You already know two of these
Events and markers have been in MakeTimeFlow for a while. Node types simply give the whole family one name — and add the three that real-world planning was missing.
Why Not Just Tasks?
For a long time we said everything is a task, and structure emerged from nesting alone. That simplicity was right — and honest use at scale revealed three places where it quietly broke down:
Shelves in your today list. Nodes like “Home” or “Marketing” exist to organize, but the system saw them as tasks — so there they sat, in your buckets, pretending to be work. You can’t do “Marketing” this afternoon.
The dishonest complete button. What does it mean to complete “Team”? Nothing — it’s ongoing by nature. A button that can’t mean anything trains you to ignore your own system.
Projects you couldn’t schedule honestly. A multi-week effort isn’t doable in one sitting, so putting it in @today always felt wrong. But the alternative — pre-decomposing every step before you could make time for it — is exactly the upfront planning tax MakeTimeFlow exists to remove. Real planning often sounds like “I’ll spend two hours on the redesign tomorrow morning” — commitment to the outcome, before you know every step.
Node types fix all three, not by adding ceremony, but by letting the system finally see what you already knew.
Fluid by Design
Here’s what makes this different from every tool that made you dread the project/task question:
You never pre-decide. Capture is unchanged — one line, no questions asked. What you capture rests in your inbox as simply notable, until you act on it — add @today and it’s a task; drag it onto your calendar, same — or tell it what it is. Types come later, if ever.
Recognition is one action. That quick task that grew into a three-week effort? Mark it a project. The “project” that turned out to be one phone call? Make it a task again. Nothing is lost either way — no migration, no data ceremony, not even its place in your buckets.
Nothing moves. Converting a node doesn’t relocate it, doesn’t open a different screen, doesn’t change how you expand, collapse, drag, or nest it. The tree is the tree.
Home <- folder: a shelf, never "due"
├── Renovate the kitchen <- project: an outcome you'll make time for
│ ├── Get contractor quotes <- task: one sitting
│ ├── Choose countertops <- task
│ └── Contractor said May at the earliest <- info: keep, don't do
└── Book dentist appointment <- task: lives on a shelf, still just a task
Actionable: What Your Buckets Show
Tasks and projects are actionable — they can be completed, scheduled, and timed. Folders, info nodes, and markers are not; they live in your outline, holding structure and context, and stay out of your way everywhere else.
This is what makes the Task Trust System trustworthy: @today and @next contain only things you can act on. When you plan your day, every line is either a doable task or a project you’re committing time to. No shelves. No reading material dressed up as work.
And projects earn their place honestly: drag a project onto your calendar and you’re not pretending it fits in one sitting — you’re blocking time to work on it. Progress without pre-decomposition.
Hierarchy Is Primary, Tags Are Cross-Cutting
The parent-child relationship is still your main organizational structure: one tree, unlimited depth, where every node has exactly one home.
Tags slice across it:
| Tag type | Examples | Purpose |
|---|---|---|
| Domains | #work #personal #health | See one life area across every folder and project |
| People | @sarah @john | Who’s involved |
| Timing | @today @next @later | When you’ll act |
Folders answer “where does this live.” Tags answer “how else do I want to see it.” Learning Spanish lives in one place in your tree, but it can be #career and #joy at the same time. You’ll see tags grow more powerful over time — filtering and focused views built on them — without ever changing where your work lives.
Quick Capture, Optional Structure
| What you type | What happens |
|---|---|
Buy milk | Captures a notable to your inbox — it becomes a task the moment you act on it |
Buy milk /Grocery Run | Creates it under the “Grocery Run” parent |
Buy milk @today #errands | A task in Today with a tag — acting on it is the recognition |
Kitchen renovation type:project | Creates it as a project |
Contractor prefers May type:info | Creates an info node |
type:project, type:folder, and type:info work anywhere task text does — quick add, the outliner, import. (The full spelling type:information works too.)
Traditional Tools vs MakeTimeFlow
| Traditional approach | MakeTimeFlow |
|---|---|
| Decide upfront: project or task? | Capture what’s notable; recognize types when they help |
| Projects and tasks live on different screens | One tree, one set of interactions |
| Choosing wrong means migrating your data | Converting is one reversible action — nothing moves, nothing is lost |
| Folders are rigid containers you must architect first | Folders are just nodes — make one when a shelf would help |
| Your list mixes actions, containers, and reference | Buckets show only actionable work |
The User Win
For the busy professional: capture fast, recognize later. Your today list finally contains only things you can actually do today.
For the ambitious planner: deep hierarchy, honest projects you can block real time for, and shelves that organize without cluttering.
For the overwhelmed: the system quietly stops showing you non-work. Less noise is less load.
For everyone: you still never have to answer “is this a project?” before writing it down. You just get to say so when it becomes one.
Summary
The MakeTimeFlow way: capture everything notable — only the doable reaches your day. Types are recognition, not decisions — one reversible action that lets the system see your work the way you already do. Simple primitives, powerful composition, minimal cognitive overhead.
Related
- Tasks, Projects, Folders, and Info — how types work day to day, and the FAQ
- Task Trust System — how buckets build daily trust
- Markers - Section Dividers — the original organizing node
- Task Text Format — the full text syntax
- Organizing Your Tasks with Mindmaps — the outliner, where structure lives