← Back to Blog

Why I Built Darwin

The short answer: I kept failing to prioritize my own work, and every task app I tried made the problem worse, not better. So I built a different kind of tool—one that asks you to compare two tasks instead of ranking a whole list. It took longer than I expected, taught me more than I anticipated, and turned into something I actually use every day.

Here's the longer version.

The Problem I Was Trying to Solve

In early 2025, I was drowning in tasks. Not an unusual situation—lots of people have too much to do—but I was struggling with the specific moment of choosing what to do next. I'd open my task manager, look at forty items, and freeze. Everything seemed important. Nothing was clearly the place to start.

I tried the standard advice. Make the list smaller. Use tags and filters. Assign due dates. Separate urgent from important. Every method helped a little, but none of them solved the core issue: when I sat down to work, I still had a list of "important" things and no clear way to decide which one to tackle first.

The task apps themselves didn't help. They were great at storing tasks but useless at prioritizing them. Manual drag-and-drop to reorder a list? That was part of the problem, not the solution. I'd spend more time reorganizing the list than working on anything from it.

I needed something that would tell me what to do next. Not a calendar (which is about when, not what). Not a to-do list (which is about capturing, not choosing). Something that would cut through the noise and give me a clear answer.

The Core Idea

The insight came from a conversation about voting systems. Someone mentioned that when people vote by ranking all candidates, they often produce inconsistent results—but when they just pick between two candidates at a time, the results are much more reliable.

It clicked. What if prioritization worked the same way? Instead of asking "rank these forty tasks," ask "which of these two matters more right now?" Make that comparison over and over, and eventually the priority order emerges.

This is called pairwise comparison, and it's used in everything from product testing to psychological research. The math was well-established. The question was whether it could work for personal task management—whether I could turn it into something useful on a daily basis.

I built the first version in January 2025. It was a web app, rough and minimal: you'd see two tasks, swipe (or tap) toward the more important one, and the ranking would update. Within a few days of using it, I could tell the core idea worked. After a handful of swipes, the important stuff floated to the top. No manual dragging required.

The First Version (and Its Problems)

That initial prototype had a simple interface—two cards, swipe to choose—but the ranking algorithm was primitive. It worked okay for small lists, but as I added more tasks, the rankings became inconsistent. Something would win a bunch of comparisons, then lose to something it should have beaten, and the whole order would shuffle in unexpected ways.

I spent weeks tweaking the algorithm. Tried Elo ratings (the chess system). Tried Bradley-Terry models. Each approach had trade-offs, and none of them felt quite right for how task priorities actually work.

The breakthrough came when I looked at TrueSkill, a system Microsoft developed for Xbox matchmaking. Instead of just tracking wins and losses, TrueSkill tracks two things: a rating (how good something is) and a confidence (how sure we are about that rating). New items start with low confidence and high uncertainty. As they win or lose comparisons, the confidence increases and the rating becomes more stable.

This made a big difference. Tasks that had been compared many times had stable positions. New tasks could move around without disrupting everything. The ranking felt more reliable, and I stopped second-guessing it.

Going Native

The web version worked, but it didn't feel right. Swiping on a phone browser is clunky compared to a native app. And I wanted something I could pull up instantly, make a few comparisons, and put away—the kind of quick interaction that works best with native gestures and animations.

So in mid-2025, I rewrote everything in React Native. This was a bigger undertaking than I expected. Not just the code—React Native itself has its quirks—but all the details of making a swipe-based interface feel good. Gesture recognition. Animation timing. Card physics. The space between "it works" and "it feels right" turned out to be enormous.

I spent an embarrassing amount of time on the swipe animations. Left swipe, right swipe, up swipe, down swipe—each does something different, and each needed to feel responsive and clear. When you choose a task over another, the winner should fly off the screen in a way that feels satisfying. When both tasks exit, the transition to the next pair should be seamless. These details seem minor, but they make the difference between an app you use once and an app you actually come back to.

What Darwin Actually Does

The final product centers on that core comparison mechanic. You see two tasks. You swipe toward the one that matters more. After enough swipes, you have a ranked list of what to do, with the most important things at the top.

But prioritization is only part of the story. What happens after you know what's most important?

I added a Focus mode that lets you take the top-ranked task and turn it into a timed work session. The idea is that ranking without action is useless—you need to actually do the thing. So Darwin includes a simple timer and a way to track what you accomplished during focused work.

I added Goals to organize tasks into larger outcomes. Instead of a flat list, you can group related tasks under a goal and rank within that goal or across everything. This helps when you have multiple projects competing for attention.

I added ways to capture tasks quickly—typing, voice, importing from iOS Reminders—because the friction of adding tasks matters. If it's annoying to get things into the system, you'll stop using the system.

And I added Insights to show how your priorities are changing over time. Which tasks keep rising? Which keep falling? Where are you spending your focus? This isn't about productivity metrics or gamification—it's about noticing patterns that help you understand your own priorities better.

The Harder Problems

Building the app was one thing. Getting it into people's hands was another.

I launched on the App Store in mid-2026, after more than a year of development. The first few weeks were humbling. Downloads were low. Retention was inconsistent. Some people loved the comparison mechanic; others found it confusing or tedious.

One consistent piece of feedback: the app needed more guidance. Pairwise comparison is an unusual approach, and people weren't always sure what they were supposed to do or why. I added onboarding flows, tutorial overlays, explanatory text—all the things I'd initially skipped because "the interface is self-explanatory" (it wasn't).

Another issue: people would add tasks but then never compare them. The ranking only works if you make comparisons, and making comparisons requires coming back to the app. I experimented with notifications, visual cues, and surfacing the ranker more prominently. Getting the balance right between "present enough to be useful" and "annoying enough to uninstall" is still a work in progress.

What I Learned

Building Darwin taught me a few things that I hadn't expected going in:

The core mechanic matters more than features. I kept wanting to add things—more settings, more views, more ways to organize tasks. But whenever I added complexity, the app got worse. The magic is in the simple comparison: two tasks, one choice. Everything else is just scaffolding to support that moment.

Feel is harder than function. Making the comparison mechanic work correctly took a few weeks. Making it feel right took months. The difference is in timing, animation curves, haptic feedback, subtle visual cues—stuff that's hard to measure but obvious when it's wrong. Users don't say "the animation duration is too long"; they say "this app feels sluggish." You have to reverse-engineer the feeling from the feedback.

You can't think your way to good design. I had endless theories about how the app should work. Most of them were wrong. The things that actually improved the product came from using it daily and noticing when something felt off. The ideas I was most confident about often failed; the throwaway experiments sometimes turned into core features.

Building for yourself is both a strength and a weakness. I built Darwin to solve my own problem, which meant I understood the problem deeply. But it also meant I had blind spots about what other people needed. Features that seemed obvious to me needed explicit explanation. Workflows that I'd internalized were opaque to new users. Testing with other people, especially people different from me, became essential.

Where It Is Now

Darwin is on the App Store, used by people who struggle with the same prioritization problem I had. It's not a massive success by any conventional measure—this isn't a story about hockey-stick growth or venture funding. It's a tool that does a specific thing, used by people who need that specific thing.

I still use it every day. Not because I built it, but because it actually helps. When I sit down to work and don't know what to do first, I open Darwin, make a few comparisons, and start on whatever wins. It's not a perfect system, but it's better than staring at a list and freezing.

The development continues. There are bugs to fix, features to refine, and new ideas to try. But the core is stable, and the core works. Two tasks. One choice. Repeat until you know what matters.

What I'd Tell Someone Starting Something Similar

If you're thinking about building a product to solve your own problem, a few thoughts:

Start smaller than you think. I could have launched faster with less. The first version that actually worked didn't need half the features I built before showing it to anyone. Get to the core mechanic quickly and validate that before building around it.

Use it yourself, constantly. If you're building something you don't use daily, something is wrong. Either the problem isn't real, or your solution doesn't actually solve it. The fastest feedback loop is you, frustrated, wishing your tool was better.

Don't over-explain. I wasted time writing documentation and onboarding for features that should have been obvious. If something needs extensive explanation, it probably needs simplification instead. The best products teach you how to use them by using them.

Be ready for slow. Consumer apps are brutally hard. Even when your product is good, getting people to discover it, try it, and keep using it is a separate challenge entirely. Expect it to take longer than you want, and make sure you're okay with that pace.

Darwin took longer than I planned, cost more than I budgeted, and taught me more than I expected. Would I do it again? Yes. Would I do it differently? Also yes. That's probably how these things always go.

Try the result of all that work. Darwin helps you figure out what to do next by comparing two tasks at a time.

Get Darwin for iPhone

Frequently Asked Questions

Is Darwin your full-time job?

Darwin is part of Phoenix Strategies, where I work on software products and consulting. It's not a venture-backed startup—it's a bootstrapped product built to solve a real problem. The goal is sustainability, not hypergrowth.

Why is it called Darwin?

The name comes from natural selection. Tasks compete in pairwise comparisons; the fittest (most important) survive and rise to the top. It's a loose metaphor, but it captures the idea that priorities emerge from repeated selection rather than being assigned upfront.

Will there be an Android version?

It's on the roadmap. The codebase is React Native, so much of the work translates, but there are platform-specific details to handle. No timeline yet, but it's something I'm working toward.

How is Darwin different from other task apps?

Most task apps are built for capturing and organizing tasks. Darwin is built for deciding what to do next. The core mechanic—comparing two tasks to build a priority order—isn't something you'll find in standard to-do apps. If you're fine with manual prioritization, Darwin probably isn't necessary. If you struggle with prioritization specifically, that's where Darwin helps.

Can I export my data or use it alongside other apps?

Darwin includes Reminders import and CSV import, so you can bring tasks in from other systems. Export options are something I'm evaluating for future updates. The goal is to be a useful tool in your workflow, not a locked garden.