Dispatch: Will Coders Work Like Delivery Riders?
Programmers in China sometimes call themselves 码农, "code farmers." Lately I keep picturing us in a different job: 外卖小哥, the delivery guy.
On Meituan, the biggest delivery app in China, you place an order and the platform picks a rider, gives them a route and a deadline, and shows you their icon crawling across the map. If the food is late, the rider gets penalized. When it arrives, you rate them. Nobody holds a meeting about your noodles.
I've been wondering whether software work is heading toward the same shape. Someone posts a task and whoever is free picks it up. Everyone can see how it's going, anyone can take it over, and the result is judged against a standard written down in advance. Then I read Anthropic's article on how its teams work with agents, and it looked closer than I expected.
Why coding never worked like this
A delivery order is easy to describe and easy to check. "Bring this bowl from A to B by 12:40" fits on one screen, and it either arrived on time or it didn't.
Most software tasks are the opposite. "Make onboarding better" can mean fifty different things. Half of what you need to know is in someone's head or in a meeting you missed. Checking the result can take another engineer's whole afternoon.
Ronald Coase asked in 1937 why companies exist at all, if markets are so good at matching work to workers. His answer was that using the market costs something. You have to find someone, agree on terms, and check what they deliver. When those costs are high, it's cheaper to hire people and manage them inside a firm.
I think a lot of software teamwork is us paying that cost. Standups and long Slack threads exist because the task is fuzzy. We talk until it isn't.
What agents change
Agents can't pay that cost the way we do. They don't overhear anything 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 stood out to me:
- Teams write things down where agents can read them. New channels are public inside the company by default, and docs and meeting notes are written with agents as a main reader.
- Every agent gets a defined role. One might own data analysis while another enforces the design standard. One engineering team keeps a written roster of its humans and agents, and when its projects got more complex it added a release manager agent.
- Work is made checkable before a human looks at it. Code has tests, and docs get rubrics and style guides. Often one agent does the task and a second agent checks it.
Once a task is written down and has a check attached, Coase's cost is paid up front, and it matters much less who picks the task up. Humans and agents work in the same threads, so a half-finished task can pass from one to the other. Meetings shrink too. The article says teams protect human time on the calendar and save meetings for the most important work.
Anthropic's engineers have dispatched agents to handle 500 bug fixes on their own. It didn't start that way. One engineering leader took over a team with a big backlog and split the agents into two groups. The first group read every item, checked whether someone already owned it, and gave each unowned item a complexity score. The second group took the low and medium complexity items and wrote the code changes.
Swap the bug list for a list of lunch orders and you have Meituan: a queue, a sorter that sizes 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, coders turn into riders. Grab a ticket, race a timer, get rated, repeat.
In Anthropic's version, though, the riders are the agents. They take the tasks, and they get rated in their own way. Teams track which kinds of tasks each agent has proven it can do alone, and widen its scope one task type at a time after repeated successes. Delivery platforms run something similar for riders: more orders, a better on-time rate and better reviews earn points and a higher level. Take it one step further and a dispatcher just sends each task to whoever has done that kind of task well before, human or agent.
That moves the competition. In Chinese we call the endless grind 卷, "involution." If agents do the deliveries, the 卷 shifts from people to agents, and from there to the people who build the harnesses and train the models behind them. (I wrote about harnesses in my post on harness engineering. The loop is the cheap part. 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 published a long investigation called "Delivery Riders, Trapped in the System." A former Meituan station manager told the reporters that the limit for a 3 km delivery went from one hour in 2016 to 45 minutes in 2017, then to 38 minutes in 2018. To the people who built the system, each cut was progress, proof that the dispatch algorithm was learning. Riders kept up by speeding and running red lights.
Anthropic's article describes pressure in the other direction. The scarce resource is human attention, and the setup is built to protect it. Agents are coached to batch their questions, restate the context so a person can catch up fast, and limit how many things each person sees at once. Some teams have an agent whose only job is deciding which messages deserve a human's time. Others cap how much work the agents do per day, so the humans can keep up with it and keep their own skills.
On a delivery platform, the worker's speed is the bottleneck, so the platform pushes the worker. On a human-agent team, the reviewer's attention is the bottleneck, 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 both ends of the order.
At the front, someone decides what to deliver. In Anthropic's teams, humans 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 one pin took about eighteen separate operations. Ten workers splitting them made over 48,000 pins a day. Working alone, Smith wrote, each of them could not have made twenty. Where you make the cuts decides what the whole line can do, and people now make those cuts together with the agents. A project at Anthropic starts with humans and agents talking through who takes which role.
At the back, someone checks. The backlog story has a detail I liked. At first, humans reviewed every decision the agents made and flagged the ones that needed a person. Then they taught the agents to bring those decisions straight to a human, so a person always made the calls with hard trade-offs. Every week the agents wrote up their own mistakes so they wouldn't repeat them. Over time the leader handed them bigger changes and spent less time steering.
What I want to practice
- Write tasks so a stranger could pick them up. If an agent can't do a task from the ticket alone, fix the ticket first.
- Put the check in place before the work starts: a failing test, or a short rubric for anything that isn't code.
- Keep work out of private DMs. Agents can't see them, and neither can whoever takes over next.
- Track what each agent can do 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 batch their questions.
I still don't know how this goes for people. The same setup that protects a team's attention could be pointed the other way, with a timer on every engineer. Riders had little say in how their timer was set. Engineers might still get a say, 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.