The Problem With Task Delegation (And Why Most Apps Get It Wrong)
Task delegation in most productivity apps requires both people to use the app. That's a feature request disguised as a prerequisite. Here's a better model.
Every project management tool in existence has a feature called “assign task.” It works like this: you create a task, you pick a person from a dropdown, and the task appears in their inbox. Simple. Elegant. Completely broken in practice.
Here’s why.
The two-account problem
For task assignment to work, both people need to be in the system. The assigner needs an account. The assignee needs an account. They need to be in the same workspace, or the same team, or at minimum the same universe of authenticated users.
This is fine inside a company that has already bought Asana or Linear or Jira. Everyone’s in the system. The dropdown is populated. The plumbing works.
But most task delegation doesn’t happen inside a company. It happens between:
- Partners splitting household chores
- Friends planning a trip
- Freelancers and their clients
- Managers and contractors who aren’t in the org chart
- Anyone and anyone else, in any context where one person wants another person to do something
In all of these cases, the “assign task” feature requires solving an unrelated problem first: getting the other person into your tool. This is not a small ask. You’re requesting that someone create an account, learn a UI, and commit to checking a new inbox — all so you can tell them to buy napkins for the party.
The friction isn’t technical. It’s social. Asking someone to sign up for your task manager is a bigger imposition than the task itself.
What delegation actually looks like
In practice, people delegate tasks the same way they have for decades: they send a message.
“Hey, can you pick up groceries on the way home?”
“Reminder: the slide deck is due Thursday.”
“Please take out the trash. I’m not asking again.”
The medium varies — text, email, Slack, a note on the fridge — but the pattern is identical. One person tells another person what to do. The recipient doesn’t need to install anything. They don’t need to log in. They just need to read the message and decide whether to do the thing.
This is the mental model that works. Not “both people manage tasks in a shared workspace.” Just: one person sends a request, the other person sees it.
A link is a better primitive than a shared workspace
We recently added something to AnotherTodo called Submission Links. The mechanic is simple: you generate a link, you send it to someone, and they can add todos to your list through that link. No account required on their end. They see a form, they type the task, they submit. Done.
This inverts the usual model. Instead of assigning tasks to other people, you’re opening a channel for other people to assign tasks to you. The link is the interface. The recipient of the link doesn’t need to understand your productivity system. They don’t need to learn a new app. They just need to type words into a box.
This turns out to be closer to how delegation actually works in the real world. The person who cares about the task getting done — the person with the todo list, the person whose productivity system is at stake — is the one who owns the tool. Everyone else just needs a way to talk to that system.
A URL is that way. It’s the most universal interface in computing. Everyone knows how to click a link and fill out a form. No sign-up, no onboarding, no adoption curve.
The accountability layer
The interesting problem isn’t getting tasks into the system. It’s closing the loop.
When someone sends you a text saying “please buy milk,” there’s no structured way to confirm you did it. You can text back “done” and they can choose to believe you. Trust is the only mechanism.
With submission links, we added a small accountability layer. If the person who submitted a task provided their email, they get notified when you mark it complete. The notification includes a dispute button. If they click it, the task gets un-completed.
This is not a workflow engine. There’s no escalation path, no SLA, no approval chain. It’s a single binary signal: “yes, this was actually done” or “no, it wasn’t.” That turns out to be sufficient for most real-world delegation. You don’t need a Jira ticket to know whether the trash was taken out. You just need a way for the other person to say “I checked, and it wasn’t.”
The broader point
Most productivity tools are designed as if everyone involved in a project is equally committed to using the tool. That’s rarely true. Usually, one person is the organiser — the one who cares about tracking, systems, and completion — and everyone else just wants to be told what to do and left alone.
Building for that asymmetry means building interfaces that work for the less committed party. Links instead of accounts. Forms instead of dashboards. Emails instead of notifications.
The goal isn’t to get everyone into the app. It’s to let the app work with everyone, even the people who will never sign up.
That’s the model we’re building toward. Start with a link. End with a completed task. Everything in between should be as invisible as possible.