How to prevent outages in AI driven code factories

TL;DR

Maintainability, not more tokens, fixes outages. Upfront design, system architecture review, and explicit program design with types and call graphs reduce risk when using coding agents. Lights off approaches worsen the codebase over time, so plan ahead and retain human review to keep quality high.

Transcript

[music] What's up everybody? How we doing guys? Give it up for all the great speakers today so far. Um, [applause] all right. This is uh harness engineering is not enough and why software factories fail and we're going to click maybe. Oh, that's way too many slides. Hold on, guys. Okay. Um, so we're all racing to put AI coding into production and u... Read More

Key Insights

• Maintainability is the core bottleneck in AI driven code factories, not token counts or faster loops.
• Codebase quality degrades when models optimize for test pass rates rather than long term architecture, causing hidden costs months later.
• Agentic code review and regression testing can accelerate delivery but do not remove the need for human oversight in complex systems.
• Lights off software factory approaches worsen maintainability by reducing code reading and relying on automation alone.
• Without upfront design, architecture review, and clear call graphs, rapid development increases outages and user frustration.
• Current benchmarks for model maintainability are insufficient, making it hard to verify long term code quality improvements.
• Vertical slices and explicit design work like program design are crucial to align teams and reduce rework in AI driven development.
• Plan ahead with product reviews and system architecture discussions to save hours of review and produce readable, stable PRs.

Questions & Answers

Q: How can I prevent outages when using AI coding agents in a production system?

Outages are not fixed by adding more tokens or running more loops. The path to stability lies in maintaining codebase maintainability through upfront design, architecture reviews, and explicit program design down to types and call graphs. Plan with vertical slices, ensure reviews, and align teams to reduce surprising changes that cause outages later.

Q: What is the main reason AI driven code factories fail according to the talk?

The main reason is a model training problem related to maintainability. Even with faster code generation, the system cannot stay maintainable over time without human steering. Without maintainable code structures, changes in one area break others, leading to outages and degraded software quality.

Q: Why is there a pushback against lights off software factories?

Lights off approaches eliminate code reading and heavy code review, focusing on automation and faster production. This reduces human insight into code quality, increasing the risk of accumulating sloppy code and unreviewed changes, which in turn causes outages and long term maintenance problems.

Q: What role does upfront design play in reliable AI driven development?

Upfront design sets the expectations for how code will be structured, reviewed, and tested. It enables product review, system architecture planning, and detailed design, which saves hours of later review and leads to PRs that are readable and easy to maintain, ultimately reducing the chance of outages.

Q: How do benchmarks relate to maintainability in coding models?

Current benchmarks focus on passing tests rather than long term maintainability. Without benchmarks that measure how codebases stay maintainable as they evolve, models tend to optimize for short term success at the expense of architecture, making future changes riskier and more prone to outages.

Q: What is recommended to improve the next chapter of agentic engineering?

Recommended steps include turning the lights back on with upfront planning, product reviews, system architecture evaluation, and a dedicated phase of program design down to types and call graphs, followed by vertical slices. These practices enable better alignment, reduce rework, and improve PR quality.

Q: How does the speaker suggest handling incidents in a factory setting?

Incidents should be routed into the factory for structured handling, but not to replace human review. The aim is to balance automation with targeted human oversight to investigate root causes, reproduce issues, and implement design improvements that prevent recurrence, thereby improving overall maintainability.

Q: What historical perspective about software factories is shared in the talk?

The talk traces software factories back to 1968 and explains how the typical loop of building, reviewing, testing, and deploying has evolved with AI agents. It emphasizes that solely speeding up this loop without addressing maintainability will lead to more outages and degraded code quality over time.

Summary & Key Takeaways

• The speaker argues that harness engineering and loops maxing are not a cure for outages and broken code bases, because the fundamental issue is model training and maintainability.

• Upfront planning, architecture reviews, and vertical slices are proposed as essential steps to improve code quality and prevent late stage failures in AI driven factories.

• Relying solely on automated coding agents without human steering leads to degraded maintainability and more outages, highlighting the need for better benchmarks and design practices to move to the next chapter of agentic engineering.