Two teams looked at the same technology and drew opposite conclusions about what it does to their org chart.
Eddie Kim, Gusto's CTO, threw out the org chart. With three other engineers and one designer, Eddie built Gusto Cofounder, a net-new product line, from zero code to a tier-one launch in 10 weeks. No Figma. No Jira. No docs. Standups, retros, and Slack threads all got replaced by a single "perma-Zoom." A designer with no engineering background reportedly hit the 94th percentile for shipping code.
Andrew Ambrosino, who leads the Codex desktop app at OpenAI—where nearly 100% of employees now use Codex weekly—reportedly looked at the same collapse of roles and issued a warning: eliminating the concept of roles entirely is a big mistake.
Both are right. That's the tension this piece is about.
This week the pattern jumped the fence: OpenAI, Cursor, and Gusto are, per reporting, all restructuring how humans and agents coordinate, and the interesting part is not that process died. It's where the process went.
Start with the seductive read. The headline everyone is copying is "no Figma, no Jira, no docs." The dream Anthropic is selling sits right next to it: as Jess Yan, a product lead there, reportedly put it, "we give [agents] tasks overnight and then we wake up and the backlog is resolved and bugs are squashed." You tag an agent like a coworker, it works while you sleep, the artifacts of coordination evaporate.
But read Kim's own account of the 10 weeks and you notice he didn't remove coordination. He concentrated it.
The perma-Zoom is the tell. You don't delete standups and retros and async Slack and replace them with nothing—you replace them with a continuous, always-on channel where five people share context in real time. That's not less coordination. That's coordination compressed into a single high-bandwidth surface, made possible only because the team was small enough to fit inside one call.
Look at the other elite teams and the same move repeats under different names.
Ambrosino describes OpenAI's PMs operating on a "zone defense" model—a coordination scheme, not the absence of one, for the specific problem that arises when everyone can build anything. When the constraint on building disappears, the scarce thing becomes deciding what gets built and who owns which zone. So they built a play for it.
At Cognition, Nader Dabit reportedly describes watching non-engineers tag Devin in Slack to fix docs and report bugs, PRs showing up from people who don't know what a branch is. The unlock he names isn't the coding. It's the Playbook: when someone figures out how to make the agent handle a class of task, they encode it once, and the whole org triggers it repeatedly. Expertise gets externalized into reusable infrastructure.
Perma-Zoom, zone defense, Playbooks. Three teams, three names for the same thing: coordination didn't die. It recompiled into a new layer that sits on top of parallel agent output.
Perma-Zoom, zone defense, Playbooks. Three teams, three names for the same thing: coordination didn't die. It recompiled into a new layer atop parallel agent output.
Which brings us to the sentence that actually explains the restructuring, buried in Dabit's cloud agent thesis: "The constraint shifts from engineer hours to review capacity."
Sit with what that means. The old bottleneck was writing code, so process existed to allocate that scarce resource—tickets to queue the work, docs to specify it, standups to unblock it. Jira and Figma were externalized memory for a world where engineering hours were the thing you couldn't make more of.
Cloud agents blow that constraint open. Dabit's own example: "you describe ten tasks, kick off ten sessions, and come back to ten PRs." The work isn't scarce anymore. So the coordination artifacts that existed to ration it become dead weight—which is exactly why Gusto could throw them out.
But the constraint didn't vanish. It moved. "Ten parallel agent sessions means ten PRs to review." The scarce role is no longer the person who writes the ticket. It's the person who can review ten PRs by lunch, hold the whole codebase in their head, and decide which of the ten was right.
This is why Kim's trash-can method matters more than the perma-Zoom does. His team writes, reviews, and deletes a full PR as a product decision instead of writing a planning doc. Read that as a labor reallocation: the cheap step (producing the artifact) got pushed to the agent, and the expensive step (judging it) got pulled to the human. The PR became the spec. Review became the work.
And review is where the new bottleneck bites hardest, because it's the one task you can't fully hand back to an agent. Dabit's corollary is that the cloud agent pattern "demands a review agent" to organize diffs, catch bugs, and answer questions with full codebase context—and he's blunt that without it you're "either rubber-stamping PRs or drowning in review debt." That's real, and the operational fallout of that PR flood—security, cost, what actually breaks when the queue backs up—is its own story, which the security-queue piece picks up. Stay on the workflow side and the point holds: even with a review agent, someone still owns the judgment call, and that someone is now the constraint.
Notice what this does to the roles everyone thought were disappearing.
The PM job that spent years drifting toward "coordinating and aligning people" is genuinely fading. But the coordination work isn't gone—it's being reforged. Someone has to define the zones, write the Playbooks, decide which of the overnight PRs ships and which goes in the trash. That's not ticket-writing. That's review governance, and it's harder, not easier.
Which is exactly why Ambrosino's warning is the load-bearing counterpoint to the Gusto headline. On his team roles are collapsed—and he still insists that eliminating the concept of roles entirely is a big mistake. Someone has to own the zone. Someone has to carry the taste that decides what "good" means when ten plausible PRs are sitting in the queue.
That word—taste—is the quiet reason "throw out the process" doesn't obviously scale past teams like these.
Process is externalized taste and context. A spec, a design doc, a ticket—these exist so that judgment can be written down once and handed to people who don't yet carry it internally. When Kim's five-person team deletes the docs, it works because all five already hold the taste and context the docs would have externalized. The perma-Zoom transmits it live. The trash-can method assumes everyone in the call can look at a PR and know whether it's right.
A designer hitting the 94th percentile for shipping code is not evidence that the designer learned to code. It's evidence that agents let existing judgment express itself in a medium the person couldn't previously reach—and the judgment was already there.
Take that same setup to a 200-person org where the context isn't shared, the taste isn't uniform, and nobody can fit inside one Zoom, and "throw out the process" becomes "throw out the only mechanism that transmitted judgment to people who don't have it yet." The artifacts weren't friction. They were the teaching layer.
So here's where it lands. The elite teams didn't win by deleting coordination. They won by having enough shared taste that they could afford to move coordination from artifacts into a live review layer—perma-Zoom, zone defense, Playbooks—that sits on top of parallel agent output.
For everyone else, that layer doesn't exist yet. The review governance, the encoded taste, the coordination-as-infrastructure that lets an org draw from agent capacity without drowning—that's not a process you throw out. It's a product still waiting to be built.
The overnight backlog is the easy half. The bottleneck nobody has named yet is who reviews it, and how you teach an organization to.