I Tried Every To-Do App and Came Back to One Text File

The to-do app you keep abandoning loses to one plain-text file because the file outlives every app. A flat .txt file wins on capture, portability, and longevity. You only step up to something structured when the file actually breaks — not before. That is the whole arc, and almost everyone takes it backward.

The pattern is old enough to have a paper trail. Jeff Huang, a computer-science professor at Brown, has run his life out of a single file for over a decade: "I have been using it as my main productivity system for 14 years now."¹ The format he leans on has a name and a spec — todo.txt — whose reference command-line tool carries 6,104 GitHub stars, and whose format repository carries another 3,255.^{2 3} This is not a fringe habit. It is a maintained ecosystem built on the smallest possible idea: one line, one task.

What you keep hoping an app will fix

The belief is reasonable, and almost everyone holds it. The right to-do app will finally organize you. It will remind you, sync everywhere, sort by project and priority, and turn your scattered intentions into a system. So you download the new one, import your tasks, and start again — for the third time this year, with the third app.

The hope is not foolish. Apps do things a flat file cannot: push notifications, recurring reminders, shared lists, calendar sync. For genuinely collaborative or time-triggered work, those features earn their keep. The trouble is that the feature you actually use most is the one no app sells you on — the empty line where you type the next thing before you forget it.

Why the app keeps losing

The app loses because almost everything that makes it an app is overhead between you and that empty line. Onboarding, accounts, sync conflicts, a settings screen for the settings screen. Each migration costs you the one thing the system was supposed to protect: continuity. The todo.txt project states the alternative plainly.

"Plain text is software and operating system agnostic. It's searchable, portable, lightweight, and easily manipulated. It's unstructured. It works when someone else's web server is down or your Outlook .PST file is corrupt. There's no exporting and importing, no databases or tags or flags or stars or prioritizing or insert company name here-induced rules on what you can and can't do with it."³

Read that list as a description of what apps add and then charge you to escape. The exporting and importing. The company-induced rules. A file has none of it. There is nothing to migrate away from a file, because there is nothing holding it hostage in the first place. The friction an app removes from one task it quietly re-adds to the system around the task.

What a single file actually does

A single text file wins on the three things that matter for tasks: capture, portability, and longevity. Capture, because the next line is one keystroke away. Portability, because the file opens in anything. Longevity, because a .txt you wrote a decade ago still opens, unchanged, today. The format is almost nothing — that is its strength.

Cal Newport, the computer scientist who coined the term "deep work," runs his weekly planning this way. "Once a week, usually on Mondays, I open a small text file named plan.txt and jot down my action plan for the week."⁴ He keeps the rules deliberately loose: "There are no hard rules for this plan. Some weeks it's a few sentences. Usually, it's a few paragraphs."⁵ No schema, no fields, no app deciding what a plan is allowed to look like.

The structure, when you want it, is conventions you invent — not features you rent. The todo.txt format adds exactly one rule before getting out of the way: "A single line in your todo.txt text file represents a single task."³ From there you can prefix a +project or an @context if you like, or you can ignore all of it. The file does not care. That indifference is the point.

One file scales further than you think

A single file scales much further than app marketing assumes, because plain text refuses to slow down. Huang's file is not a toy: "I have 51,690 handwritten lines in one file now, documenting everything I have done as a professor."⁶ Fifty thousand lines, one file, no database, no lag — a fourteen-year record where most people feared a collapse.

What the file becomes is the quiet surprise. Huang describes it as "a to do list that turns into a what done list" — "a record of everything I have ever done and when I did it."⁷ You start by writing what you intend to do. What you are left with is an honest log of what you actually did, searchable to the line. No app sells "a record of your life" as a feature, because no app can promise to be around long enough to keep it.

This is the longevity argument that the wider plain-text world has made for years. Steph Ango, CEO of Obsidian, put the general case in one line: "Apps are ephemeral, but your files have a chance to last."⁸ For tasks specifically, that abstraction becomes concrete. The app you used three years ago is gone or changed past recognition. The file is exactly where you left it.

When one flat file stops working

A single file stops working at the moment you need three things it was never built for: links, structure, and search across many separate notes. A flat .txt is perfect for a stream of tasks. It is poor at connecting a task to the meeting that spawned it, the person who owns it, and its project.

The honest concession is this. Apps win on reminders, recurring schedules, shared lists, and calendar sync — anything time-triggered or collaborative. A file has no idea what tomorrow is. If your work is genuinely driven by deadlines and other people, the file is the wrong tool, and you should not pretend otherwise. The flat file's claim is narrow and true: it wins on capture, portability, and longevity, and it loses on automation and structure-at-scale.

So the question is not "file or app." It is: at what point does one flat file actually break for you — and what is the smallest step up that does not surrender what made the file good?

The graduation path: keep the text, add the links

The smallest step up from one flat file is many small plain-text files that link to each other. You keep everything the .txt gave you — plain text, no lock-in, openable in anything — and you add the two things it could not do: connections between notes, and structure across them. Markdown is the natural next file.

The move is undramatic. A weekly plan.txt becomes a weekly note. A recurring project gets its own note, linked from each week that touches it. A person, a meeting, a topic — each can be its own note when, and only when, it earns one. You are not migrating into a database. You are still writing plain text; you have simply let one file become a few, joined by links instead of scroll position.

This is the lane MNMNOTE is built for: linked markdown notes stored locally on your own device, that open as plain text and work offline. It is the same plain-text bet the flat file makes, extended to the point where one file stops scaling. You graduate when the file breaks — not because an app convinced you that you needed more. For the deeper case on why plain text lasts, see Plain Text Is a Love Letter; for what a folder of small notes can do that a file cannot, see Your Notes Are Already AI-Ready.

What to actually do this week

The practice is small, and you can start it in the next minute. Open a single plain-text file. Name it something you will find. Put the next thing you have to do on the first line, and then keep the system stupidly simple until it visibly fails you.

1. Create one file — todo.txt, plan.txt, whatever you will reopen.
2. One line, one task. Add a +project or @context prefix only if you miss it.
3. Don't delete finished tasks; mark them done. The to-do list becomes a done list.
4. Review weekly, the way Newport does — a few sentences, no ceremony.
5. Only when you need links between notes, split the file into linked markdown — not before.

Frequently Asked Questions

Is a text file better than a todo app?

For capture, portability, and longevity, yes. A plain-text file opens in any editor, on any device, with nothing to import or export, and it still opens decades later. Apps win on reminders, recurring schedules, shared lists, and calendar sync. If your work is time-triggered or collaborative, use an app; if it is mostly capture, the file is hard to beat.³

Why use a plain text file instead of an app?

Because a file has no lock-in, works offline, and outlives the tool that made it. The todo.txt project puts it bluntly: plain text "works when someone else's web server is down," with "no exporting and importing, no databases or tags or flags or stars."³ An app adds features, then adds friction around them. A file removes the friction by having almost no features at all.

What is todo.txt?

todo.txt is a plain-text task format whose single rule is that "a single line in your todo.txt text file represents a single task."³ It is widely credited to Gina Trapani, who introduced it around 2006, and it has since grown a maintained ecosystem — the reference command-line tool alone carries 6,104 GitHub stars.^{2 3} You can use it with no special software at all.

Does one big text file actually scale?

Further than most people expect. Jeff Huang's file holds "51,690 handwritten lines in one file now, documenting everything I have done as a professor," after running it as his main system "for 14 years."^{6 1} Plain text does not slow down as it grows. It scales until you need links and structure across separate notes — that is the point to step up, not before.

When does a single text file stop working?

When you need three things it cannot do: links between notes, structure across many notes, and search across all of them. A flat file is a stream; it cannot connect a task to its project and its owner when those live elsewhere. At that point the smallest step up is many small plain-text (markdown) files that link to each other — keeping the format, adding the connections.

How do I organize a big text file before splitting it?

Use conventions, not features. Prefix a +project or an @context tag so you can search by them. Keep finished tasks in place, marked done, so the file doubles as a log. Newport keeps his loose on purpose — "no hard rules… a few paragraphs."⁵ When grep and scrolling stop being enough, that is your signal to split into linked notes.

A to-do app is a bet that a company will outlast your tasks. A text file is a bet that you will. Only one of those bets has ever paid off for fourteen years in a row.

mnmnote.com is a browser-based markdown editor that keeps your notes on your own device — the place a single .txt file goes when it finally needs links.