Collaborative AI Engineering: One Dev, Two Dozen Agents, Zero Alignment — Maggie Appleton, GitHub
Summary
Maggie Appleton, staff research engineer at GitHub Next, argues that the dominant model of agentic software development — one developer orchestrating a fleet of coding agents in a solo terminal environment — is fundamentally flawed and exacerbates existing team alignment problems. She frames this as the "one man, two dozen Clods theory of the future," where the promise of multiplying individual output ignores the team-sport nature of software engineering. Her core thesis: implementation is now a largely solved problem, meaning the real bottleneck has shifted to deciding what to build and achieving team-wide agreement on direction. When production costs collapse, opportunity cost becomes the dominant cost, and misalignment becomes far more expensive than it previously was.
Appleton traces how traditional development workflows contained natural alignment checkpoints throughout planning, building, and review phases — Slack conversations, draft PR comments, issue discussions — that collectively kept teams oriented. Agentic development has collapsed the implementation window so dramatically (from issue-logged to PR-opened in minutes rather than days) that these touchpoints have vanished from the front end of the process and instead pile up as post-implementation review burdens on pull requests. PRs were never designed to carry the full weight of alignment and perform poorly when forced to do so. The result: duplicate work from parallel agents touching the same files, merge conflicts, surprise features nobody agreed to build, and enormous stacks of PRs reviewers lack context for.
Existing coordination tools — GitHub, Slack, Jira, Linear — were designed for a pre-agentic development model. Appleton notes that even internally at GitHub, very few people believe the PR and issue are the future of software development. Critical context needed for correct build decisions — business priorities, financial constraints, political dynamics, product vision, user research, organizational history — lives in people's heads, not codebases, and agents cannot discover it autonomously.
To address this, the GitHub Next team built ACE (Agent Collaboration Environment), a research prototype entering technical preview with a rollout to several thousand users. ACE combines multiplayer chat (Slack-like interface), coding agents, sandboxed micro VMs per session running on isolated Git branches, and real-time collaborative editing. Key capabilities demonstrated include: shared dev server previews so teammates see the same live app without branch-switching overhead; multiplayer agent prompting where any team member (developer, designer, PM, customer support) can direct the agent mid-session; collaborative plan editing with live cursors before implementation begins; automatic commits with diffs surfaced in-session; and PR creation linked back to the originating ACE session for traceability. The micro VM architecture means sessions persist independently of individual machines — a developer can close their laptop and teammates continue prompting agents on the shared cloud computer.
The dashboard layer gives individuals a Monday-morning briefing on what they left unfinished and summarizes teammates' recent shipping activity (e.g., "Nate shipped a lobby channel, David fixed access token issues"), addressing the challenge that agents now enable five features per day per person rather than half a feature, making team-wide awareness nearly impossible without tooling support.
Appleton closes with a philosophical argument: agents have returned significant time previously consumed by implementation. The opportunity is not merely to go faster and produce more software, but to do more rigorous critical thinking, user research, and architectural deliberation — to build fewer, better things. In a world of cheap, fast software generation, she argues craftsmanship becomes the primary differentiator against "vibe-coded slop." ACE's goal is to create environments where teams think rigorously together, get aligned faster, and focus energy on the right problems before agents start working.
Key Takeaways
- •Implementation is becoming a solved problem; the real bottleneck is now deciding what to build and achieving team alignment before agents start working.
- •Agentic tools amplify the cost of misalignment — duplicate work, conflicting changes, and wasted tokens scale with agent speed.
- •PRs were not designed to carry the full weight of team alignment and perform poorly when forced to do so; alignment checkpoints must move earlier in the process.
- •Critical build context (business priorities, political dynamics, user research, org history) lives in people's heads, not codebases — tooling must help teams surface it before agents start.
- •Multiplayer agent environments where all team roles (devs, designers, PMs) share one workspace and one live agent context reduce coordination debt significantly.
- •Micro VM per session with isolated Git branches enables parallel workstreams without branch-switching friction, allowing teammates to inspect each other's work in one click.
- •Agents should read the full team conversation as context, not just the last prompt — a Slack-like interface makes this natural and inclusive for non-developers.
- •Proactive dashboard summaries of teammates' recent activity are necessary when individuals ship five features per day and passive awareness becomes impossible.
- •Closing your laptop should not kill a session — always-on cloud-based agent sessions enable async, mobile, and multi-person continuation without local environment dependency.
- •The opportunity of cheap implementation is not to build more, but to reclaim time for deeper thinking, user research, and architectural rigor — building fewer, better things.
- Craftsmanship is the differentiator in a world of fast, cheap code generation; strong team alignment is the prerequisite for craft.
Transcript
[music] >> Okay, we all good? Right. Uh so yes, this talk uh is called uh one developer, two dozen agents, zero alignment. Uh this is the case for why we need collaborative AI engineering. So first, a very quick intro. I'm Maggie, I work uh at GitHub as a staff research engineer. Uh at least that's my title. I'm actually a designer back when that was like a separate thing to engineer. Um and next is the Labs team within GitHub. So we work on kind of more experimental, risky bets than the rest of...
Speakers
Topics
Related Sessions
