For decades, software development processes were built around a fundamental constraint: skilled people who could write code were scarce. Sprints, code reviews, staging environments, and release trains all evolved as mechanisms to organize human labor. That premise no longer holds. By September, more than 40% of pull requests on GitHub began with an agent's first draft, up from 17% in March. Yet the infrastructure surrounding these changes has not kept pace with the shift.
Agents have made code generation fast and inexpensive. The same cannot be said for the process of shipping that code. CircleCI's 2026 delivery data revealed that average daily workflow runs increased 59% year over year, with the top 5% of teams seeing a 97% jump and the bottom quartile showing no measurable growth. When one organization doubled its pull request output, the load on code reviewers doubled as well, and automated review systems quickly surpassed human review in coverage.
The pattern mirrors what happens across industries when work becomes automated. "When work gets automated in any industry, the people don't disappear. They stop doing the work and start designing the system the work runs through." Software engineers are transitioning into process engineers, building what amounts to a software factory—a coordinated system where machines perform the work and humans design the structure that governs it.
Three manufacturing lessons carry over to agents
Software development differs fundamentally from automobile manufacturing: a car plant produces the same product thousands of times, while software never ships the same change twice. Yet three principles from manufacturing apply directly to systems where machines execute the work.
The first principle is that people design the system, not the output. Ford's Model T production line cut assembly time from 12.5 hours per car to 93 minutes by 1914, not because workers became eight times faster, but because engineers fundamentally redesigned how the line operated.
The second is that quality must be built in at every step rather than inspected at the end. Sakichi Toyoda created a loom that automatically stopped whenever a thread broke, allowing one operator to manage multiple machines instead of monitoring a single one. Toyota structured its entire production system around this principle, and quality theorist W. Edwards Deming spent decades urging manufacturers to abandon end-of-line inspection in favor of in-process quality.
The third principle comes from Eliyahu Goldratt's work in "The Goal": the slowest step in a process determines the overall pace. Speeding up any step other than the bottleneck simply creates a backlog upstream. Agents accelerated code generation, and now the bottleneck has shifted to review and verification.
A software factory is a network of agents
A functioning software factory operates as a series of specialized agents, each focused on a single task and passing work downstream through the development lifecycle. A research agent transforms usage data and customer feedback into a brief. A spec agent writes requirements with acceptance criteria. A coding agent implements the change. A review agent examines it. A test agent runs it and reports failures. A release agent deploys it behind feature flags. An SRE agent monitors production, triages failures, and creates work for the next cycle.
Most handoffs in this loop occur between agents rather than people, fundamentally changing what a handoff means. Between humans, a handoff can be informal—a Slack message and some shared context suffice. Between agents, a handoff must be a formal contract specifying what gets passed, in what format, and with what proof of correctness. A specification lacking acceptance criteria gives the coding agent no clear target. A change without test evidence gives the release agent no basis for trust.
Agent-to-agent work introduces new failure modes. Errors compound as each agent builds on the previous one's output. Agents can converge too readily on incorrect solutions or enter infinite loops trading the same fix back and forth. A factory of agents requires what a factory of machines requires: checkpoints between stations and someone to decide where those checkpoints belong.

Software engineers become process engineers
That someone is the software engineer. The role transforms from writing code to designing the system that writes, tests, and ships code. This is more technical work, not less, because responsibility now extends across the entire code production pipeline. The job breaks down into four distinct responsibilities.
First is designing the flow: determining which agents exist, what each owns, what runs in parallel, and what information each handoff must contain. Second is defining what good looks like. An agent cannot hit a target that was never written down. Specifications, acceptance criteria, performance budgets, and API contracts once lived implicitly in engineers' heads; now they must be explicit enough for machines to verify. Third is continuously improving the line. When an agent ships a bug, the relevant question is not why the agent failed but why the process allowed the failure through. Every defect that reaches production is a process failure. Fourth is placing human gates strategically. Humans should review decisions where mistakes are costly and judgment is required, not every line of code an agent produces. Line-by-line human review of every agent pull request is a holdover from the craft era, equivalent to hand-inspecting every bolt in a factory.
Agents write code and fix tests. A database schema migration is expensive to get wrong but cheap for a machine to verify, so agents run it behind strict automated checks. UI copy is a matter of taste and cheap to change, so a human reviews it after deployment. Decisions about what to build and where security boundaries sit warrant human gates.
Quality gets built into every change, not inspected at the end

Most teams still operate under the traditional quality assurance model. Changes accumulate, then undergo a single inspection phase: a shared staging environment and a human reviewer. This creates a single test station for the entire factory, and when agents multiply the volume of changes, it becomes the bottleneck Goldratt identified.
Toyoda's loom freed operators by checking every thread as it ran and stopping immediately when one broke. Code written by agents needs the same mechanism. In a properly functioning software factory, the test agent checks every change as it is created, the coding agent fixes failures, and nothing advances until it passes.
Such checks only have value if they run in an environment where failures would actually appear. Mock environments do not suffice because they validate changes in a world that does not exist. Mocks were a practical compromise when change velocity was low and creating a production-like environment for each change was expensive and slow.
Each change should get its own environment that mirrors production, complete with the services, databases, and APIs it will encounter after release. A human only sees a change if it hits a gate, and by that point it already works, with evidence attached. This model requires a test environment for every change, cheap enough to use on every attempt. In practice, this means an environment that starts in seconds, deploys only the changed components, shares everything else, and allows end-to-end verification before merge.
Guardrails belong in the line, not in the prompt

Verification catches mistakes after they happen. Guardrails prevent mistakes that would be expensive to catch late. The design principle is simple: assume agents will do anything the system permits, and design the system so that everything it permits is safe.
Manufacturing calls this error-proofing. You do not post a sign instructing workers to insert a part correctly; you build a fixture that fits only one way. For agents, an instruction in a prompt is a sign on the wall, while a permission boundary is a fixture. Each agent should hold only the access its station requires. The coding agent never holds production credentials. Every run is isolated so one agent's test cannot corrupt another's. Required checks are enforced, every release can roll back independently, and if a check cannot run, the change stops.
A line that silently skips a broken inspection is worse than having no inspection, because everyone assumes it is working. Agent-to-agent work introduces another rule: trust does not cascade down the chain. A review agent approving a change should not expand what the release agent is permitted to do.
Judgment stays human, and it becomes most of the job
Factories did not eliminate engineers; they created industrial engineering as a discipline. You cannot design a line for work you do not understand, so the best factory builders will be engineers who know what good code, good tests, and a safe rollout look like from hands-on experience.
Some work remains off the line. The first version of something new, an unusual production incident, and a design nobody has attempted are bench work—they stay hands-on until they are understood well enough to standardize. Some decisions never move to machines: what is worth building, what a customer actually needs rather than what they said, when to trade speed for safety, and who is accountable for what ships. These were always the hard parts of the job. Now they are most of it.
The best process wins, not the best model
Agents made code cheap, and every team can access the same models. What distinguishes teams that pull ahead is the line they build around those agents: contracts between stations, human gates where judgment matters, and verification on every change. Designing that line is now the software engineer's job.