Rebuilding Engineering Workflows for AI--First Development

The transition from human-centric to agent-centric software engineering is not just a change in tools; it is a fundamental shift in how teams collaborate. As AI tools take on the role of a pair programmer, traditional industry standards like manual code review and synchronous pair programming are becoming outdated. For engineering teams, competitive advantage no longer comes from following best practices that prioritize human oversight. Instead, it comes from rebuilding workflows to match the speed and scale of AI agents. Teams that stick to legacy processes will be slowed down by safeguards meant to ensure quality, while those who adopt AI-first workflows will gain a significant, compounding speed advantage.

The Erosion of Traditional Quality Gates

The industry has long treated manual code review and pair programming as essential for software quality. However, the hosts of Overcommitted point out a shift: these practices provide less value when the primary author is an AI agent.

When code is generated quickly, human review becomes a bottleneck rather than a safeguard. Brittany Ellich notes that the traditional goal of code review, which is to build a shared mental model, is moving further upstream. Instead of catching errors in a pull request, the focus is shifting to prompt engineering and agent instructions.

"I think that right now people are still doing human code review just purely because we have always done it. And I think at some point, we are not gonna need it anymore."

-- Brittany Ellich

The system shows the fragility of these quality gates. If the authoring process is automated, the review process must also be automated. Otherwise, it becomes an expensive, slow activity that creates friction without reducing risk.

The Myth of the 10x Engineer as a Multiplier

The conversation challenges the industry obsession with the 10x engineer. The hosts argue that the term is overrated, but they introduce a nuance: the only version of a 10x engineer that holds value is the multiplier.

The true advantage lies in an engineer who increases the output of the entire team. This is where loop engineering, the practice of using AI agents to break down and execute tasks, changes the dynamic. By producing smaller, more frequent pull requests, an engineer can achieve a 10x output in volume. However, this creates a consequence: if the team review process is not automated, the multiplier creates an unsustainable workload for their peers.

"I think the only take on 10x engineering that I have ever really liked is the one where you are such a multiplier for the rest of your team is that like your team as a whole has more output than they would otherwise."

-- Erika Eggemeyer

The Hidden Cost of Vibe Coding

The term vibe coding has emerged as a shorthand for agentic engineering, but the hosts warn that it is overhyped. The danger is confusing writing code with engineering.

When non-engineers or junior developers use AI to vibe code an application, they often bypass the mental modeling and architectural planning required for production software. The immediate benefit of a working prototype feels productive, but it hides a downstream cost: a system that is impossible to debug or scale because the author lacks a foundational understanding of the patterns the AI used. The competitive advantage goes to those who use AI to accelerate their thinking, not to replace the rigor of the engineering process.

Key Action Items

• Audit your PR process: Evaluate if your current code review process catches genuine logic errors or just enforces style preferences that could be handled by linting or AI instructions. (Immediate)
• Shift mental modeling upstream: Move the shared understanding phase of development to the design and prompting phase. If your team is not aligned before the code is generated, the review process will remain a bottleneck. (Over the next quarter)
• Implement Loop Engineering cautiously: Adopt agentic PR stacking to increase velocity, but ensure your CI/CD pipeline can handle the increased volume of automated tests. (12-18 months)
• Standardize dotfiles: Treat your environment configuration as code. By putting dotfiles in a repository, you eliminate the friction that slows down onboarding and environment parity. (Immediate)
• Redefine the 10x contribution: Shift performance metrics from individual PR counts to team-wide velocity. If an engineer output creates a bottleneck for others, they are not a multiplier; they are a system liability. (Next 6 months)
• Prioritize ergonomics over health trends: Focus on changing positions throughout the day rather than strictly standing or sitting. The advantage is in the movement, not the desk height. (Ongoing)