What is the point of a team? In any kind of work, the point of a team is to do more work than one person can do alone, somehow. With some kinds of work, that scaling is straightforward: if the task can be done in parallel, it’s easy to just add workers and get more done. There are coordination problems eventually, but to a first approximation, you can just add people and get more done.
That works for many kinds of physical work, but it’s more complex for mental work. The software world has known for a long time about Fred Brooks’ “mythical man month” - the idea that software teams don’t scale like that, because each programmer needs to talk to many, or most of the programmers on the team. So as the team scales, the amount of work capacity goes up linearly but the communication overhead goes up as the square - much faster.
AI seems to solve some of this problem: one person can just have AI agents do a lot of work for them, right? Agents are fast, and if you want, they can even talk to each other. So we should scale much faster, and to a limited degree, we do.
What you really need in this world isn’t more people to do the work - the agents can do the work. What you actually need is more people to pay attention to the work.
This is a hard problem. If you work directly with AI coding agents, you probably have experienced this. It’s very easy to get into a place where you are spending most of your time trying to pay attention to what all of your agents are doing, constantly context switching and having to reload to keep track. It’s not hard to start a new task - usually just a minute or two in a new session will do it - but you just can’t pay attention to more. You need a teammate who can help pay attention to things.
In the database world, this is called sharding. When one database server can’t handle the load from users, the database itself is broken into “shards” that are served separately from different machines, spreading the load. This works with databases because all of the work is uniform - each row in the database has the same schema, or format, so it’s possible to serve pieces of the database from many machines (there can be other challenges, like trying to keep related data on the same machine to reduce overhead, so I am simplifying a bit).
But in the cognitive world, we have a harder problem. People aren’t regular like database rows. They ‘embed’ information differently. Much of the overhead in a team is reconciling these different representations. How many times have we gone through the process of writing a spec, exchanging emails, settling on a design, only to need a final “acceptance” meeting to make sure we are “aligned” (or how many meetings along the way “could have been an email”)? Those 45 minutes are an overhead cost of aligning our embeddings. And sometimes it doesn’t work! Or two engineers read the same spec and build two parts of a system that don’t connect properly because one understood “user” one way than the other. Neither one misread it - there was no error to catch - they had legitmately different, but incompatible, “embeddings” of the world. We all know this feeling, of being aligned “in theory” but needing to “just chat face to face” to work it out. This is people aligning their expectations and embeddings to each other.
Agents don’t quite have this problem. Agents based on the same model start from identical embeddings (the models are identical). Prompt construction can further align them by giving them each a clear, specific, repeatable understanding of the problem. And AI tends to be less individualistic and unpredictable, as well as faster. Alignment for agents is still an issue but much less of one, and with ego removed, can happen much faster.
This “sharding of attention” is becoming one of the harder problems in AI based systems, and it will likely become even harder. If you consider a workflow that has agents and humans in it, the humans are essentially very slow, but critical nodes - research has found1 we output about 10 bits per second, vs billions of input bits from our senses. Quite the ratio! Humans are like high-latency, low-bandwidth, high-value control nodes. You’d never route a lot of traffic through a node like this - if you were designing this system, you’d be very careful to only route what you need through it.
But we have to involve these slow nodes - humans are the only thing in the system that can hold accountability, so we have to be involved. But the embedding issue and our attention overload make it challenging and hard to do well.
We need this to be efficient, and we need to be able to shard, or spread, high-level attention across many team members. We need to make it so that no human nor agent can overly disrupt our critical, but slow, human control nodes. We need to be able to get a lot of throughput in the system without hitting the mythical man month limit as we scale up these teams.
We need a robust ergonomics of attention.
Actual physical ergonomics came out of the industrial revolution. We realized that the intersection of humans and machines in the factory was very dangerous for humans. Bodies got injured or worse. But even if they weren’t violently harmed, repetitive and harsh motions did damage over time. The human in the physical factory is very much like the slow node in the cognitive one: the machines are faster and tougher, but the human is critical. We have to make sure the machines don’t hurt the humans, and if the ergonomics are right, the whole factory moves faster.
This isn’t just about communication. It’s about the fact that we are now scaled cognition and are damaging attention with agents in much the same way we scaled motion and damaged bodies with machines. I guess I’ve written about this before (more than once), but it’s becoming more clear the more we watch teams adopt AI.
This is at the root of why you aren’t getting the benefit from AI that you think you should. The most common failure is a “hot shard”, where all decisions (and distractions) get routed to the one person on the team who can answer them in that moment. It’s locally rational - that’s the right person! - but globally highly inefficient - it both overloads that person and stalls the network. Hot shards in a database are an indication that further sharding is needed. Here, it’s an indication of the same - the problem space needs to be divided so that it’s easier to spread load without as much context reset.
This results in a few common patterns. Either that person holds up adoption across the whole team (or the team decides it’s not worth it anyway), or the team does adopt AI broadly but doesn’t get any benefit because there are too many bottlenecks - individuals might create lots of work (or slop) but it has trouble getting through the overall system. For what it’s worth, factories had to solve this problem too - you can’t have a single, critical slow craftsman in the middle of the production line, or making a critical part. The factory is only as fast as the slowest part - it has to scale that part somehow.
Interestingly, for folks like me with ADHD, the current moment is even more perilous: we can get much more done, because it’s so easy to turn our (abundant) ideas into action, but we also wind up being much more distracted - our attention is even harder to manage now. Attention has always been both a challenge and a superpower for me. I don’t think of it as attention “deficit” - I have plenty of attention, even more than “normal” people and it’s often an asset because I can think of so many things and have so many ideas at once. But if I’m not careful, with AI, it just becomes overwhelming - more and more I am building systems that are skeptical, help me remember and before doing something new. Attention management is everything now, no matter how much of it you have.
Some rough ideas to start thinking about this:
- We tend to give work to whoever is available. Probably it should go to who has the lowest attentional cost to handle it. Deciding who that is should be as easy as possible.
- Handoffs and context switches are what matter - translating between embeddings is expensive. They need to be minimized, design teams and problems around this where possible.
- Calling the human is critical, expensive, and slow. It should be done rarely and strategically - at the start and end of long projects (direction and acceptance) but more rarely in the middle.
Individuals feel empowered by AI, teams and organizations less so. Attention is the core problem now - AI can help but it can also hurt. Safer and slower is faster - we learned this from factories. We need to begin creating a robust ergonomics of this if we want to truly realize the value of these tools in large organizations.
1 Zheng and Meister, "The unbearable slowness of being," Neuron, 2024.