Collaborative AI Engineering: One Dev, Two Dozen Agents, Zero Alignment

생각 덩어리

"One man, two dozen Clauds" theory of the future

I think this is what many people think peak developer productivity looks like right now, right? This is like a wall of terminal-based coding agents all running in parallel on one person's machine. I like to call this the one man, two dozen Clods theory of the future.

The promise that we're given here is that one person with a fleet of agents will do the work of an entire team of developers. The main problem with this stream is it assumes that software is made by one person.

Single-player interfaces — 개인 생산성의 한계

All of these tools are single-player interfaces and they focus on scaling up the work of the individual. But there is limited value in scaling up one individual.

Software is not made by one person in a vacuum. It is a team sport and everyone building it needs to agree on what they're building and why.

Nine women make a baby in one month logic

Believing individual productivity leads to great software is nine maybe nine women make a baby in one month logic. Uh more individual output doesn't solve problems that require communication and coordination. It makes them worse.

"Should we build it?"가 새 병목

An implementation is rapidly becoming a solved problem, right? Probably everyone here believes that. Uh writing code is now fast, it's getting cheaper, and quality is going up and to the right.

The hard question is no longer how to build it, it's should we build it? Agreeing on what to build is the new bottleneck.

When production is cheap, opportunity cost becomes the real cost. You can't build everything and whatever you pick comes at the cost of everything else.

Coordination tools are still from another era

Alignment has always been a bottleneck, but agents have made the cost of not being aligned as a team much, much higher. What makes it worse is that all our coordination tools are still from another era.

So GitHub, Slack, Jira, Linear, and the like are as they currently stand are not designed for the agentic development world. We are funneling masses of agentic outputs into platforms that were built for an outdated way of building software.

PR과 issue가 미래라고 믿는 GitHub 직원은 거의 없다

Here I know like I work at GitHub, so that might sound heretical for me to say. Um but I promise it's not controversial. There are very few people internally who believe that the PR and the issue are the future of software development and there are lots of us inside the machine trying to explore what comes next.

Implementation window가 무너졌다

This is how the development process used to look, right? We had a planning phase, a building phase, and a review phase. And we had all of these touchpoints of alignment along the way.

But that implementation window has now collapsed. And because implementation is no longer as expensive and time-consuming, we think we don't need to plan as much. So most of those early touchpoints actually disappear.

Alignment이 PR 뒤로 밀려났다 — 너무 늦은 정렬

The time between logging an issue and an agent opening a PR is now a couple of minutes. The code is so cheap that we don't properly stop to think before we prompt it.

This leaves the weight of all that alignment to sit on the pull request. All those checkpoints now come after the implementation at the end of the process when it's too late. And it's never what PRs were really designed to do in the first place, so they perform poorly at it.

Local plan mode — 팀과 공유되지 않는 계획

Unhelpfully, most coding agents also have this local plan mode that is completely unshared with other people. So you're not even your team on whether the plan it made is good before you ship it, if you even read it. And so we lose even more alignment points.

Wasted work + coordination debt

Going fast without good alignment leads to wasted work. So this is like features no one asked for and that don't actually solve real problems. And receiving critical feedback after you finish something that ends up meaning you have to toss the whole thing out.

And also coordination debts. This is when you get really hairy merge conflicts because agents will touch in the same files or developers even doing duplicated work because they both picked up a thing and tried to finish it in one day.

Context lives in people's heads, not the codebase

This is especially true because most of the context that you need for alignment and to build the right thing is not in the code base. It's in people's heads.

The business context and the financial resources determine what the correct thing to build is, the political dynamics of who's in charge and who gets to make decisions, the product vision from leaders, the user research insight from designers, and the organization's history and what you've built before.

The agents can never discover this context on their own. You need a way to get humans to share it early and naturally without adding process and overhead.

ACE — Agent Collaboration Environment 시연

It's called ACE, stands for Agent Collaboration Environment. Uh it's not a primetime product yet. So like if it looks pretty rough around the edges, it's because it is.

It looks a bit like Slack, GitHub, Copilot, and a bunch of cloud computers had a baby.

Each session = chat + micro VM + Git branch

Each session is more than a chat channel though. It is also backed by a micro VM. So a sandboxed computer in the cloud on its own Git branch. The changes we make in each session are isolated, so we can work on parallel tasks and instantly switch between them.

If I want to tap one of my teammates on the shoulder and get their thoughts on a feature I'm building, nobody has to stash their Git changes and like pull down a new branch or like wrestle with local work trees. I just jump into their session and I see what they're doing in a click.

Truly multiplayer — 같은 코딩 세션을 공유

So, I actually kicked off this session, but Nate is now prompting the agent. So, this is truly multiplayer. Both of us are sharing this coding session. Uh the agent can also read our whole conversation. That is all input to the prompt. So, we can talk about things up ahead and just say at Ace, do it.

Slack은 software dev 도구가 될 수 없다

Because if you're thinking, you know, like why wouldn't we just use Slack for this? I think it's because Slack is never going to become a fully featured software development tool unless they sincerely pivot from their current business. Um so, it's never going to have the right primitives and I really doubt it's going to add them.

Close the laptop — agent는 클라우드에서 계속 돈다

I can close my laptop on this and work can continue. Um my session doesn't die. My teammates can keep prompting Ace um and making progress.

Computer doesn't need to be alive and I don't need to go buy a Mac Mini to keep things available. I just talk to my always-on agent in the cloud.

공유 plan — collaborative cursors

And here we all are in our plan. I can see my teammates' cursors. We can collaboratively edit it together. We can decide if we like this plan, if it's any good at all, if it achieves our intent.

Once we're all happy with the details, we go back to the chat and we can just say at Ace, do this. And it knows what the context is.

Five features a day — 동료가 뭘 만드는지 따라잡기

One of the biggest challenges of agentic development is that the speed and volume of work makes it really hard to keep up with what your co-workers are doing. They are now shipping five features a day instead of half of one.

If all your conversations around the code are available to agents, it gives them access to a social information fabric where they can help get you oriented every morning and stay aligned with your team.

Reclaiming time — 더 빨리가 아니라 더 좋게

All of this is actually about reclaiming time, right? Before coding agents came along, none of us had enough time and energy to make our products the way we wanted to. I guarantee everyone in this room has shipped software they're not proud of.

We have an opportunity to not just go faster and build a giant pile of the same crappy software, but instead to make much better software through much more rigorous critical thinking and better alignment in the planning stage.

Quality is the new differentiator — craft 대 vibe-coded slop

I think many people are now realizing that in a world of fast, cheap software, quality becomes the new differentiator. The bar is being set much higher and craftsmanship is what set you will will will set you apart from vibe-coded slop.

But craft still costs time and energy. It's not free. And in order to buy the time and energy you need for it, you need to do fewer things better, which requires lots of strong alignment.

Few exceptional things, not a thousand crappy ones

The dream for me is that we end up with tools, whether it's Ace or others, that create environments where teams can think rigorously together about hard problems.

Uh agentic tools should help us do higher quality work, get aligned faster, and build a few exceptional things rather than a thousand crappy ones.