Essential cookies keep the site working and are always on. If you allow analytics, we also record sessions of visitors and of members aged 18 or over across the site, including messaging and profile pages: clicks, scrolls and page layout. Everything you write or upload, names, profile photos and images are masked in your browser before anything is sent, so the text you type never leaves it unmasked. Recordings are not used for advertising. Ad measurement is a separate choice. You can withdraw any time in settings.
The age of the process engineer: How software teams are… — Marsel
AI
The age of the process engineer: How software teams are redesigning for AI-powered development
As AI agents take over code generation, software engineers are shifting from writing code to designing the systems and safeguards that govern how machines build, test, and ship software.
As AI agents increasingly generate code, the bottleneck in software development is no longer creating features—it's shipping them. The fundamental nature of engineering work is shifting as a result. Rather than writing code directly, engineers are becoming architects of the entire development pipeline, designing the workflows, checks, and human gates that govern how autonomous agents collaborate to build and deploy software.
When automation reshapes any industry, workers don't vanish—they evolve. They shift from executing tasks to designing the systems through which work flows. Three principles from manufacturing offer practical guidance for building what amounts to a software factory:
Humans design the system, not the output. Henry Ford didn't make workers faster at assembling cars; he redesigned the assembly line itself, cutting production time from 12.5 hours per car to 93 minutes.
Quality gets embedded at every step. Sakichi Toyoda's automatic looms halted production the moment a thread broke, preventing one operator from needing to monitor a single machine constantly. This "jidoka" principle—quality built into the process—became foundational to lean manufacturing.
The slowest step governs overall pace. Eliyahu Goldratt's insights on constraints remain true: accelerating work upstream of a bottleneck just creates a pile waiting for the bottleneck to clear.
Agents compressed the coding phase; now review and verification are the chokepoint.
Rather than humans handing work to other humans, the new model involves specialized agents working in sequence, each optimized for a specific task. A research agent distills customer feedback into a specification. A spec agent writes detailed requirements with acceptance criteria. A coding agent implements the change. A review agent evaluates it. A test agent verifies it works. A release agent manages rollout behind feature flags. An SRE agent triages production issues and opens the next work item.
This chain depends on structure that human handoffs don't require. Between people, a Slack thread and implicit context suffice. Between machines, each transition demands a formal contract: what data passes, in what format, and with what proof. A spec lacking acceptance criteria leaves a coding agent with no target. A code change without test evidence gives a release agent nothing to trust.
When agents fail, they fail in new ways. Errors cascade because each stage depends on the previous one. Agents may accept outputs too readily or spiral in endless fixes. The factory needs checkpoints between stages and someone to design where they go. That someone is the engineer.
The engineer's role transforms into four distinct responsibilities:
Designing the flow: Mapping which agents exist, what each owns, what can run in parallel, and what each handoff must prove.
Defining success criteria: Making explicit what was once implicit knowledge in people's heads. Specifications, acceptance criteria, performance targets, and API contracts must be concrete enough for a machine to verify.
Fixing the process, not the agent: When an agent ships a bug, the real question isn't why the agent failed—it's why the process allowed the failure. Every escaped defect signals a gap in the line's design.
Placing human gates strategically: Humans should decide only where mistakes are expensive and judgment matters. Line-by-line human review of every agent's pull request is a legacy habit from the craft era. Schema migrations are high-risk but easy to check programmatically, so they run behind hard controls. UI copy is low-risk and cheap to update, so it ships and gets reviewed after. Decisions about what to build and where security boundaries sit belong with people.
The old model concentrated quality checks at the end: changes accumulate in a staging environment, then a human reviewer inspects them. This creates a single inspection point for the entire organization—Goldratt's constraint. Once agents multiply the volume of changes, this becomes untenable.
Toyoda's loom exemplified a better way: it tested every thread continuously and stopped the moment one broke. The parallel in software: the test agent validates every change as it's made, the coding agent fixes failures immediately, and nothing progresses until it passes.
This verification only works if it runs in an environment that mirrors production. Mock tests don't suffice; they prove code works in a world that doesn't exist. Each change needs its own production-like environment with the same services, databases, and APIs it will encounter after release. Humans only see changes that hit a gate, and by then the evidence of functionality is already attached.
This demands test infrastructure that spins up in seconds, deploys only the changed components, and shares the rest—allowing end-to-end verification before merge without requiring full infrastructure duplication per change.
Verification catches errors after they happen. Guardrails prevent expensive mistakes from ever reaching that point. The principle: design the system so everything it permits is safe.
Manufacturing calls this error-proofing. Rather than posting a sign telling workers to insert parts correctly, you build a fixture that fits only one way. For agents, a prompt instruction is a sign; a permission boundary is a fixture.
Each agent gets only the access its stage requires—the coding agent never holds production credentials. All runs are isolated so one agent's test can't contaminate another's. Mandatory checks are enforced, every release can roll back independently, and if a check can't run, the change halts. A broken inspection that silently passes is worse than none, because it creates false confidence. In agent-to-agent chains, trust doesn't cascade down; a review agent's approval shouldn't grant the release agent expanded permissions.
Factories didn't eliminate engineers—they created industrial engineering. The best factory designers understand the work intimately, having done it themselves. They know what good code, solid testing, and safe deployment look like hands-on.
Some work resists standardization. First attempts at new patterns, mysterious production failures, and untested designs remain bench work—exploratory and custom until well understood enough to codify.
But the truly irreducible human decisions endure: what's worth building, what a customer actually needs versus what they stated, when to trade speed for safety, and who is accountable for what ships. Those were always the hardest parts. Now they're the main job.
AI coding tools are accessible to every team. The models are equivalent. What separates advancing teams from stalled ones is the pipeline they architect around those models—the contracts between stages, the human gates placed for judgment, and verification woven into every step. Building that line is the engineer's new calling, the actual work that determines success in the age of AI-driven development.
AI
Signal Disables Screenshots to Defend Against AI-Powered Data Scraping