The case for tri-state task models

Most task management apps operate on a binary model. You have a list. Items are either done or not done. Check the box, it's done. Empty box, it's not. Simple.

This binary model is everywhere because it's familiar, easy to implement, and works for a large percentage of tasks — especially personal, low-complexity ones. If you're managing a grocery list, you don't need a "currently buying" state.

But for collaborative work coming out of a meeting — the action items from a planning session, a retro, a client workshop — binary breaks down. Here's the detailed case for why.

### The semantics of an empty checkbox

In binary task models, an empty checkbox means exactly one thing: not done. But in practice, "not done" covers a huge range of states:

• Not started
• In progress (started but not finished)
• Blocked (can't proceed)
• Waiting on someone else
• Deprioritized (deliberately deferred)
• Abandoned (implicitly dropped)
• Not yet relevant (a future item)

All of these display the same way: empty checkbox. The visual representation collapses all this nuance into a binary that doesn't exist in the real world.

The consequence: a task list full of empty checkboxes looks identical whether the team is sprinting hard through six in-flight items or has completely abandoned the entire project. The list can't tell you the difference.

### Why "in-progress" is the right middle state

Out of all the states I listed above, "in-progress" is the one that provides the most signal at the lowest cost.

Here's why:

It requires a human commitment. You don't mark something in-progress automatically — you do it intentionally, when you've started working on it. This creates a micro-contract: I said I started this, so I'm accountable for finishing it in a way that an untouched open item isn't.

It makes partial progress visible. When three of six items are in-progress, the list communicates "we're moving" rather than "nothing happened." This is valuable both for the individual (motivation) and for the team (accountability without micromanagement).

It filters attention. In-progress items are the things you should be focused on. Open items are the backlog. Done items are history. With one state, you can filter to "what I'm working on right now" — a view that binary lists can't produce.

It's not ambiguous. Unlike "blocked" or "waiting" (which require subjective classification), in-progress has a clear definition: you've started working on it. Everyone agrees on what that means.

### Why most apps don't ship it

Binary is the default because it's lower friction at the design level. Every state you add to a task model increases the cognitive overhead of the task list. You have to decide what state to put something in. That decision takes time and creates confusion.

The graveyard of task apps with too many states is real. Any app with more than 5–6 states starts requiring training and enforcement to use consistently. The overhead of classification exceeds the value of the information.

The trick is that three states hits the right balance. Open, in-progress, done. These three states are:

• Unambiguous (everyone agrees on definitions)
• Exhaustive (every task fits)
• Mutually exclusive (no task belongs in two states)
• Low-overhead to assign

Every additional state breaks at least one of these properties. Four states often means "blocked" and "in-progress" blur together. Five states add "waiting" which is often indistinguishable from "blocked." The information value of the additional states goes down while the overhead goes up.

### BoardSnap's implementation

In BoardSnap, the tri-state model is surfaced as three icons:

• Open: empty ring
• In-progress: ring with a filled center dot
• Done: filled ring with a checkmark

Tap an item to cycle: open → in-progress → done → open. One tap to advance. Two taps to mark done directly. Three taps to reset.

The icons were designed to be readable at a glance — you can scan a full list of 10 items and understand the state of each in under a second, without reading the item text. This is important for a board summary that might have 10–15 items. A list you can read at a glance is a list you'll actually look at.

AI assigns open or done on the initial read. In-progress is always user-assigned — it means work has started since the snap was taken, which is context the AI doesn't have.

### The one case where binary is fine

Personal, single-session tasks. If you're making a list of things to do this morning, you probably don't need in-progress. Everything on the list is something you're working on; the session itself is the progress signal.

For ongoing, team-tracked action items from a meeting or workshop: tri-state every time.