Companies organize in teams, so should agents

The dream of AI-assisted software development is seductive: one developer commanding a fleet of agents, shipping features at unprecedented speed. But as Maggie Appleton astutely observes, this vision fundamentally misunderstands how software actually gets built.

Software was never made by one person working in isolation. It emerges from teams—from discussions, disagreements, and the slow work of building shared understanding.

The Implementation Window Has Collapsed

Agents can write code in minutes. What once took days of careful implementation now happens in the time it takes to write a prompt. This is genuinely remarkable.

But here's what we've overlooked: implementation was never the real bottleneck.

The hard question in software development has shifted. It's no longer how do we build this? It's should we build this at all?

The Hidden Alignment Infrastructure

The traditional development process had something we took for granted: built-in alignment checkpoints.

• Planning sessions where the team debated approaches
• Slack threads where someone asked "wait, why are we doing this?"
• Draft pull requests that invited early feedback
• Zoom calls where misunderstandings got caught before they became code

These weren't inefficiencies. They were the alignment infrastructure that kept teams building the right things.

Agents collapsed that window. Now the entire weight of alignment falls on the pull request a mechanism that was never designed to carry it.

What Goes Wrong

When alignment fails to keep pace with implementation, predictable problems emerge:

Features nobody asked for. Agents generate code so quickly that teams ship solutions to problems that don't exist. The ease of building becomes a trap.

Critical feedback after completion. Someone reviews a finished feature and realizes it misses the point entirely. Days of agent work get discarded.

Coordination debt. Multiple agents touch the same files. Developers duplicate effort. Giant stacks of pull requests pile up with no one having the context to review them meaningfully.

The fundamental issue is this: more individual output doesn't solve problems that require communication. Nine women can't make a baby in one month.

ACE: A Different Approach

GitHub's Next team is building something called ACE—Agent Collaboration Environment. It's a multiplayer workspace where teammates and agents share the same context.

The key innovations:

Shared sessions. Each session runs on a micro-VM with its own Git branch. Jump into a teammate's session, see their prompting history, switch tasks instantly. No more "let me share my screen."

Multiplayer editing. Everyone works on the same cloud computer. The "works on my machine" problem disappears.

Collaborative planning. Before the agent writes a single line of code, the team reviews the plan together. Cursors visible, suggestions inline. Alignment happens before implementation, not after.

Ambient awareness. A team pulse dashboard summarizes what coworkers have been doing. Agents bring social context to you, rather than requiring you to seek it out.

The Deeper Question

Before agents, nobody had enough time. We shipped software we weren't proud of because implementation consumed all our energy.

Agents give that time back. The question is what we do with it.

One path: go faster. Build more. Ship a giant pile of the same mediocre software, just quicker.

The other path: make better software. Use the reclaimed time for rigorous thinking, careful design, and genuine alignment on what matters.

Craft still costs time. To buy that time, you need to do fewer things better. That requires strong alignment.

The Bottom Line

The bottleneck isn't implementation. It's alignment.

The next phase of developer tooling needs to address this directly. We need tools that help teams align before agents start working—not tools that just make agents work faster.

Planning and building aren't separate phases. They're a continuous cycle. The tools need to reflect that reality.

Agents are fast. Alignment is slow. The future belongs to whoever figures out how to bring them together.

This essay draws on ideas from Maggie Appleton's talk on Collaborative AI Engineering and the work being done at GitHub Next.