Indie Dev Productivity: The Case for Plain Text

The productivity software industry has a vested interest in convincing you that your problem is tooling. You're not shipping because you're using the wrong Kanban board. You need more integrations, better sprint tracking, AI-powered prioritization. Buy the premium tier.

Imphenzia, the solo developer behind games like Unfair Rampage: Knightfall and SILKRUN, recently pushed back on that entire premise in a short video aimed squarely at indie developers who are spinning their wheels. His argument isn't new, but the specificity he brings to it is worth examining—because he's not theorizing. He shipped a commercial game using a text file called [to-do.txt](http://todotxt.org/) sitting on his desktop.

The question worth sitting with is not whether a text file "works." Clearly it can. The more interesting question is what that tells us about where solo developers actually lose time, and whether the simplicity argument has limits the video doesn't fully explore.

What the System Actually Is

Strip it down and here's the mechanic: open Notepad, write tasks as they occur to you, work from the top of the list, append "done" to finished items and move them to the bottom, append "skip" to deliberately deferred items. That's the whole system. No time estimates. No priority labels beyond physical position in the file. No tooling overhead.

"Productivity is simply knowing what to do next so you don't freeze up," Imphenzia says in the video. That framing is doing a lot of work, and it's worth taking seriously. Decision fatigue is a real cognitive load problem, not a self-help trope. For a solo developer sitting down at 9am with seventeen things that could plausibly be worked on, the absence of a clear starting point doesn't just feel unpleasant—it burns time and mental energy before a single line of code gets written. The text file solves exactly that problem, and nothing more. Which is the point.

The detail about keeping completed tasks rather than deleting them is small but psychologically sharp. Imphenzia notes he "kind of likes to keep a track record of what I've done and get that sense of achievement." For solo developers who have no team, no standup, no one to report progress to, the completed list is its own accountability structure. It's the only external record that anything happened today.

The "skip" notation is similarly underrated. Most task systems treat items as binary: done or not done. The skip marker acknowledges a third state that actually happens constantly in development—"I considered this, evaluated it against my current scope, and deliberately chose not to do it." That's a decision, not a failure, and naming it as such matters for how you relate to your own backlog.

Where It Scales—and Where It Doesn't

Imphenzia doesn't pretend this system works for every context. When he moved from solo development on Unfair Rampage to working as a two-person team on Line War, he shifted to Azure DevOps—the same underlying logic (task list, priority order, completion tracking), but with the shared visibility and coordination overhead that a second person requires.

The numbers he cites there are notable: 6,000 tasks tracked across the development of Line War. That's not a text file problem anymore. At that scale, the value isn't the simplicity of the input—it's the audit trail, the version control integration, the ability to connect a commit to the task that motivated it. "If it's not in the task list, either add it or it doesn't exist," he says of the team workflow, framing scope control not as a creative constraint but as an operational discipline.

For developers already embedded in GitHub, his mention of GitHub Projects as a free alternative is practical. Notion gets a slightly ambivalent endorsement—his "personal favorite for everything else, but not quite for this"—which is honest in a way that a lot of tooling recommendations aren't. Notion is genuinely excellent at many things and genuinely mediocre at fast, frictionless task capture. That's a real distinction.

The Tension the Video Doesn't Resolve

Here's where I'd push back a little, or at least open the question the video doesn't linger on: the text file system works if your scope is already under control. Imphenzia describes evaluating every potential task against "scope and time frame" before it goes in the list. That judgment call is doing enormous upstream work that the system itself doesn't help you make.

Scope creep—the thing he correctly identifies as one of the central killers of indie projects—isn't just a task management problem. It's a product vision problem. A text file with excellent friction-free capture is still perfectly capable of accumulating forty tasks that collectively represent two more years of development. The system doesn't tell you when your game has become too large. It tells you what to do next within whatever size your game already is.

That's not a knock on what he's proposing. It's a clarification of what it actually solves. For developers who already have a reasonably bounded concept and are losing time to tooling friction or daily decision paralysis, the text file is a legitimate answer. For developers whose project is quietly expanding into something unshippable, no task management system—simple or otherwise—is the intervention they need.

The video gestures at this with the scope control point: "When I identified something that I needed to do, I made sure to decide if it fit in the scope and the time frame." But that evaluation happens before the task enters the system. The system itself is downstream of the harder creative and strategic decisions.

Why This Conversation Keeps Happening

It's worth noting that this type of argument—simple tools beat complex ones, ship something rather than optimize your workflow—recurs in indie development discourse with unusual regularity. That pattern says something.

Part of it is genuine. The indie development space has a real problem with developers who spend months evaluating productivity tools, setting up elaborate Notion databases, researching Agile methodology, and never shipping anything. That's not a caricature; it's a recognizable pattern, and the friction-removal argument addresses it directly.

But part of the recurrence is structural. Solo and micro-team developers are marketing targets for every productivity tool that exists, and the counter-reaction against tooling complexity is its own kind of content niche. "You don't need the expensive software" is a message that resonates, gets shared, builds audiences. That doesn't make it wrong—Imphenzia shipped the game, the receipts are on Steam—but it's worth being clear-eyed about the ecosystem these conversations exist within.

The honest version of the advice, which is more or less what Imphenzia actually gives once you read carefully, is this: match your tooling to your actual context. Solo dev, small project, struggling to start each day? Text file. Two or more people, shared codebase, longer development arc? Invest in something with shared visibility and an audit trail. Don't let either choice become a form of procrastination.

That's less viral than "just use Notepad," but it's also more durable. The text file isn't magic. It's just less in the way.

---

By Mike Wierzbicki