The Software Team Is an Economic Artifact

Software organizations were not designed around taste. They were designed around a human coordination problem. A large system had to be decomposed because no one person could hold a high-resolution model of it: product into requirements, architect into design, manager into traffic control, engineers into implementation, QA into verification, DevOps into the last mile. Scrum synchronized the fragments. Jira stored the fragments. The standup asked, in effect, what do you know that I cannot cheaply read?

That stack is an economic artifact. It exists because communication among n people grows roughly as n(n−1)/2 — Fred Brooks’s old cruelty — and because typing was scarce. Phase one of the industry was constrained by how much code a person could emit. Phase two, once the teams got large, was constrained by how much they could tell each other. Phase three is arriving through a different door. Large language models attack both limits at once. Machines emit implementation. Machines can ingest the repository, the spec, the tests, the last fifty commits, and another agent’s diff without booking a room.

The new constraint is whether humans can define a coherent system faster than machines generate complexity.

Agents do not need a standup

In April 2026, Claude Code and Cursor shipped the same thesis in different chrome: the unit of work is no longer one assistant helping one typist. It is several agents, often in isolated git worktrees, orchestrated by a human who has become a manager of synthetic labor. Industry hiring notes now treat “never run two agents in parallel” as a tell that the candidate has not seen the year. That is the production-function change. Not autocomplete. Parallelism.

So the ticket-meeting-code relay starts to look antique. The architect writes constraints. Agents write into a shared repository. Continuous tests reconcile. State updates. The repo becomes closer to the organization’s memory than the backlog ever was. Culled already traced the verification loop that made coding agents economically useful first — act, execute, observe, retry — and the SaaS recoil when that loop moved software production back inside the firm. This is the labor chapter of the same story. Why keep a twelve-person information protocol when the workers share machine-readable state?

The tempting cartoon is one programmer with twenty bots. The more plausible firm is smaller and stranger: three to eight people with global judgment, and dozens of computational workers. Humans decide what to build, which abstractions may exist, which tradeoffs are allowed, and what must never ship. Agents absorb local execution — implementation, refactors, migrations, test generation, the dreary half of review. The scarce resource relocates from typing capacity to architectural judgment, the same migration from rented specialty to synthesis already visible outside engineering.

Coherence is the new payroll problem

Do not mistake this for a utopia in which code writes itself and the company goes to lunch. Thirty agents making simultaneous changes will invent incompatible abstractions, duplicate features, satisfy tests while violating intent, and hide dependencies the way a committee hides blame. The bottleneck moves from “how do we hire enough engineers” to “how do we keep a flood of machine work inside one conceptual architecture.” The architect is no longer the person who draws boxes. They become the governor of a computational organization. If they lose the plot, the tests will still go green.

That is why the labor market will not simply shed “programmers” and keep everything else. It will shed the jobs that existed to coordinate people who could not share state: a good deal of engineering management, a good deal of Scrum theater, a good deal of ticket hygiene. Middle-management cuts already arrived ahead of the technology in some firms — capital harvesting a story. The durable version is slower and meaner. Headcount per unit of software falls. Software output rises. Prices and startup capital requirements compress because you no longer rent forty salaries to find out whether the product exists. Outsourcing shops that sold coordination-plus-juniors lose their inventory.

The junior pipeline is the quiet fracture. Implementation was the apprenticeship. If agents eat the glue, the bugs, and the first tests, the traditional ladder — junior, mid, senior, architect — becomes economically unstable. Firms that stop hiring juniors save a year and bankrupt year five. Firms that hire them as reviewers of agent diffs, not as typists, are running a more expensive school. Both responses will coexist. Neither looks like 2019.

The software team, in this reading, is an intermediate historical technology. Not because humans stop collaborating. Because the reason we needed teams of programmers — expensive communication around scarce typing — is what the models attack. Four architects and eighty agents need not share a room or a daily standup. They synchronize the system. The testable claim is organizational, not lyrical. If, two years out, the median product company that ships still staffs forty engineers, six managers, a Scrum master, and a board of stickies, the production function did not change. If the winners look like a handful of high-context humans, a fleet of agents, a shared specification, and a test system that never sleeps, the team was the artifact. The future software organization may not synchronize people. It may synchronize state.