Collaborative AI Engineering — Maggie Appleton, GitHub Next
TL;DR
Agentic coding makes alignment, not implementation, the real bottleneck — Maggie Appleton argues that when a PR can appear minutes after an issue is filed, the hardest question is no longer “how do we build it?” but “should we build it?” and whether the team agrees on why.
The current ‘one developer, two dozen agents’ dream breaks because software is a team sport — she calls today’s wall-of-terminal workflows the “one man two dozen claudes theory of the future,” and compares pure individual-output thinking to “nine women make a baby in one month” logic.
Pull requests are absorbing work they were never designed to do — as implementation windows collapse and local agent plans stay private, planning touchpoints disappear and all the coordination burden lands at review time, when wasted work, merge conflicts, and duplicated efforts are most expensive.
GitHub Next’s ACE prototype is a multiplayer agent workspace, not just another coding assistant — each session combines Slack-like chat, shared agents, a microVM in the cloud, live previews, terminal access, diffs, and a git branch so teammates can jointly build and discuss work in real time.
ACE’s key bet is that the missing context lives in people, not the codebase — product vision, org politics, user research, business constraints, and historical knowledge can’t be discovered by agents alone, so the tool is designed to pull designers, PMs, support, and engineers into the same development conversation.
Appleton’s bigger point is quality over velocity in a world of cheap software — agents have “gifted” teams time back, and she wants that time spent on deeper planning, research, and craftsmanship so teams build “a few exceptional things rather than a thousand crappy ones.”
The Breakdown
Why the solo-agent fantasy falls apart
Maggie Appleton opens with a great title — “one developer, two dozen agents, zero alignment” — and immediately takes aim at the current fantasy of a single person orchestrating a wall of terminal agents. She jokes that GitHub Next is basically the “department of [__] around and find out,” but her core point is serious: software is not made by one person in a vacuum, so scaling individual output doesn’t solve the coordination problem.
Implementation is cheap now, so opportunity cost gets expensive
Her sharpest framing is that implementation is rapidly becoming a solved problem, which means the real bottleneck is deciding what’s worth building. When code is cheap, the real cost is opportunity cost — every feature you ship crowds out something else — so team alignment matters even more than it used to.
Why PRs are now doing the wrong job
She walks through how development used to have natural alignment checkpoints during planning, building, and review, with enough slowness for Slack threads, issue comments, and draft PR discussions to shape the work. Now the time from issue to agent-opened PR can be just minutes, early planning disappears, review gets heavier, and PRs end up carrying all the coordination load after the implementation is already done.
The failure modes everyone already recognizes
Appleton makes this concrete with painfully familiar examples: features nobody asked for, critical feedback arriving after the work is finished, duplicated effort, and “really hairy” merge conflicts because multiple agents touched the same files. Her point is that agents didn’t create the alignment problem — they raised the cost of getting it wrong.
ACE: Slack, GitHub, Copilot, and cloud computers had a baby
That leads into ACE, GitHub Next’s research prototype for “agent collaboration environment,” which she says is heading into technical preview with a few thousand users. The product pitch is memorable: it looks like “Slack, GitHub, Copilot, and a bunch of cloud computers had a baby,” with each shared session backed by a microVM, its own git branch, terminal access, previews, diffs, and a multiplayer chat where humans and agents work together.
A truly shared workspace, down to prompts and previews
The demo shows why she thinks this matters: teammates can jump into the same cloud machine, inspect each other’s prompting history, run commands, view the same dev server, and avoid the classic “works on my machine” nonsense. In one moment, Nate jumps into Maggie’s session and asks ACE to add a teal theme, showing that the session isn’t owned by one person — anyone in the room can steer the agent, and the whole conversation becomes prompt context.
Planning becomes collaborative and continuous
For larger features, ACE can generate a plan that the team edits together in real time, with visible cursors and requirement changes before anyone tells the agent to execute. That’s the thesis in product form: planning and building are no longer separate phases, but a cycle, and alignment has to happen alongside implementation rather than being crammed into the pull request.
The bigger ambition: reclaim time for craft
She closes on a more human note, saying many teams have shipped software they aren’t proud of simply because implementation used to eat all their time. Agents have given some of that time back, and her hope is that tools like ACE help teams spend it on user research, design thinking, and stronger decisions — building fewer things, but better ones, with craftsmanship that stands apart from “vibecoded slop.”