Dispatch: Will Coders Work Like Delivery Riders?
Chinese programmers like to joke that they're 码农, "code farmers." Lately I've been wondering whether we're about to become 外卖小哥 instead: delivery guys.
Order lunch on Meituan, China's biggest delivery app, and the platform picks a rider, hands them a route and a deadline, and lets you watch their little icon crawl across the map. If the food is late, the rider pays for it. When it shows up, you rate them. Nobody holds a meeting about your noodles.
I keep wondering whether software is headed the same way. Someone posts a task, whoever's free picks it up, everyone can watch the progress, anyone can step in, and the result gets checked against a standard that was written down up front. Then I read Anthropic's write-up on how its teams work with agents, and that future looked a lot closer than I'd thought.
Why coding never worked like this
A delivery order is easy to describe and easy to check. "Get this bowl from A to B by 12:40" fits on a phone screen, and either it arrived on time or it didn't.
Most software tasks are the opposite. "Make onboarding better" could mean fifty different things. Half of what you need to know lives in someone's head, and the other half came up in a meeting you weren't in. Even checking the result can eat another engineer's afternoon.
Back in 1937, the economist Ronald Coase asked a simple question: if markets are so good at matching work to workers, why do companies exist at all? His answer was that using the market isn't free. You have to find someone, agree on terms, and check what they hand back. When those costs run high, it's cheaper to hire people and manage them in-house.
I've come to think a lot of what we call teamwork in software is us paying that cost. Standups and endless Slack threads exist because the task is fuzzy, so we keep talking until it isn't.
What agents change
Agents can't pay that cost the way we do. They don't overhear things in the hallway. Anthropic's article puts it bluntly: for an agent, "if it's not written down and accessible, it doesn't exist."
At Anthropic, the agents live in Slack with their own memory, skills and credentials. Three habits from the article stuck with me:
- They write everything down where agents can find it. New channels are public inside the company by default, and docs and meeting notes are written with agents as one of the main readers.
- Every agent has a job. One might own data analysis while another guards the design standard. One engineering team keeps a written roster of its people and its agents, and when its projects got more complex, it added a release-manager agent.
- Work gets checked before a human ever sees it. Code has tests, docs get rubrics and style guides, and often one agent does the task while a second one checks it.
Once a task is written down with a check attached, Coase's cost is paid up front, and it matters a lot less who picks it up. People and agents work in the same Slack threads, so a half-finished task can change hands in either direction. Meetings shrink, too: teams guard people's calendars and save meetings for the work that matters most.
Anthropic's engineers have sent agents off to handle 500 bug fixes on their own, though it didn't start that way. One engineering lead inherited a team with a huge backlog and split the agents into two crews. The first read every item, checked whether anyone already owned it, and gave each unowned one a complexity score. The second took the low- and medium-complexity items and wrote the fixes.
Swap the bug list for lunch orders and you've basically built Meituan: a queue, a dispatcher that sizes up each order, and workers who take the ones they can handle.
So who's the delivery rider?
My first reaction was the gloomy one. If coding turns into dispatch, then coders turn into riders: grab a ticket, race the clock, get rated, repeat.
In Anthropic's version, though, the riders are the agents. They're the ones taking the orders, and in their own way they get rated too. Teams track which kinds of tasks each agent has proven it can handle alone, and only widen its scope, one task type at a time, after it has gotten them right again and again. Delivery apps run something similar for riders: more orders, better on-time rates and better reviews earn points and a higher level. Push that one step further and the dispatcher simply sends each task to whoever has done that kind of work best, person or agent.
That changes who's competing. In Chinese we call the endless grind 卷, "involution." If agents do the deliveries, the grind moves from people to agents, and from there to whoever builds the harnesses and trains the models behind them. (I wrote about harnesses in my post on harness engineering: the loop is the cheap part, and most of the work goes into everything around it.)
The part that runs the other way
Meituan's system squeezed its riders. In 2020, Renwu magazine ran a long investigation called "Delivery Riders, Trapped in the System." A former Meituan station manager told the reporters that the time allowed for a 3 km delivery dropped from an hour in 2016 to 45 minutes in 2017, then to 38 minutes in 2018. To the people who built the system, every cut was progress, proof that the algorithm was learning. The riders kept up by speeding and running red lights.
Anthropic's article describes pressure running the other way. The scarce resource is human attention, and the whole setup is built to protect it. Agents learn to batch their questions, restate the context so a person can catch up quickly, and limit how much lands in front of anyone at once. Some teams keep an agent whose only job is deciding which messages are worth a person's time. Others cap how much work the agents do each day, so the people can keep up and don't let their own skills go rusty.
On a delivery platform, the bottleneck is the worker's speed, so the platform pushes the worker. On a human-agent team, the bottleneck is the reviewer's attention, so the team has to hold the workers back.
Where the humans go
People still work in the same threads as the agents, but the human jobs move to the two ends of the order.
At the front, someone has to decide what to deliver. On Anthropic's teams, people always set the north star, the long-range goal that decides which tasks are worth doing. Then the work has to be cut into pieces an agent can take. In Adam Smith's pin factory, making a single pin took about eighteen separate steps. Ten workers splitting them up turned out more than 48,000 pins a day, where each of them working alone, Smith wrote, couldn't have made twenty. Where you make the cuts decides what the whole line can do, and these days people make those cuts together with the agents: a project at Anthropic starts with people and agents talking through who takes which role.
At the back, someone has to check the work. The backlog story has a detail I love. At first, people reviewed every decision the agents made and flagged the ones that needed a human. Then they taught the agents to bring those calls straight to a person, so anything with a hard trade-off still ended up with a human. Every week the agents wrote up their own mistakes so they wouldn't repeat them, and over time the lead handed them bigger changes and spent less time steering.
What I want to practice
- Write tasks a stranger could pick up. If an agent can't do the job from the ticket alone, fix the ticket first.
- Set up the check before the work starts: a failing test, or a short rubric for anything that isn't code.
- Keep work out of DMs. Agents can't see them, and neither can whoever picks the work up next.
- Track what each agent can handle on its own, one kind of task at a time, and widen it slowly.
- Protect review time. My attention is the bottleneck now, so I want agents that save up their questions.
I still don't know how this plays out for people. The same machinery that protects a team's attention could just as easily be turned around to put a timer on every engineer. The riders never got much say in how their timer was set. Engineers might still get one, at least for a while, because we're the ones building the dispatch systems.
Sources: Kristen Swanson, Building effective human-agent teams, Anthropic, June 2026. Lai Youxuan, 外卖骑手，困在系统里 ("Delivery Riders, Trapped in the System"), Renwu, September 2020. Ronald Coase, The Nature of the Firm, Economica, 1937. Adam Smith, The Wealth of Nations, 1776, Book I, Chapter 1.
Photos: Meituan rider by TurnOnTheNight and driverless delivery vehicles by Anonymousfox36, both CC BY-SA 4.0.
Cover: the pin-maker's workshop, from the "Épinglier" plates in Diderot and d'Alembert's Encyclopédie, 1762, drawn by Goussier and engraved by Defehrt. Public domain. Adam Smith drew on French accounts of pin-making, the Encyclopédie among them, when he wrote about the pin factory.