Why Software Quality Is the Key to Scaling AI Development | Sonar Summit 2026

The Illusion of Speed and the Reality of Reliability

The advent of large language models has democratized AI-powered development, offering unprecedented speed in code generation, pipeline automation, and agent orchestration. What once took weeks now takes hours. However, Lena, senior director of developer relations at Akamai, argues that this speed advantage is ephemeral. When everyone can move fast, speed stops being a competitive differentiator. The real question organizations must answer has shifted fundamentally: not "can we build it," but "does what we shipped actually do what we intended?" The companies that will dominate the next decade won't be those with the best AI models—they'll be those with the best systems for ensuring that models produce reliable, correct outcomes.

The Two Generals Problem: A Fundamental Communication Challenge

Understanding why AI systems fail requires examining a deeper philosophical and mathematical truth: the two generals problem. This classical thought experiment illustrates that perfect alignment between human intent and AI understanding is structurally impossible, not a limitation that better models will solve. Every translation between internal human thought and external words, and then from words to AI interpretation and code generation, introduces lossy steps. If clarity starts at 100% in a person's mind, each translation step might preserve only 70% of the previous clarity. This compounds across the system. The implication is stark: because businesses are owned by people, there will always be astronomical demand for professionals who ensure the correctness of AI results. It's not about whether AI can do the work—it's about whether anyone can trust that the work was done correctly.

Non-Determinism and Architectural Guard Rails

AI-generated code introduces a unique vulnerability: non-determinism. Every LLM call is inherently non-deterministic, and without structural control, systems will fail. This fragility compounds across agent orchestration, tool selection, RAG retrieval, and text-to-SQL translation—each step introduces failure modes. Unlike deterministic code, non-deterministic systems cannot be tested into reliability using traditional methods. Consider a real case where a team replaced an ETL pipeline with AI-generated code. The transformation logic appeared elegant and even handled edge cases like time zone conversions correctly. However, it failed to account for a legacy quirk in source system APIs that returned microseconds as milliseconds for records created before a specific date—knowledge that existed only in commit messages and in the mind of a departed senior engineer. For three weeks, all historical data imported with corrupted timestamps, yet monitoring showed green because data flowed and row counts matched. The architectural lesson is clear: organizations cannot build a perfect black box. Instead, they must build a glass box around AI systems through structural guard rails and quality assurance processes.

The Evolution of AI-Assisted Development Workflows

The evolution of AI-assisted development reveals a progression toward better quality control. Initial approaches using standard prompting tools work for small tasks but break down as complexity increases. Developers discovered that even million-token context windows have only a fraction of usable capacity—perhaps 20-40% before quality degrades. This led to spec-driven development, where detailed requirement specifications and markdown-based documentation provide persistent context across sessions. However, this approach created new problems: specifications become monolithic and difficult to manage at scale, particularly when bugs in generated code require fixes. The critical insight emerged that fixing AI-generated code directly mirrors the problem of patching compiled binaries—it's the wrong level of intervention. Instead, developers should fix the specification and regenerate the code. This approach scales better, but introduces another bottleneck: reviewing massive AI-generated pull requests becomes physically impossible when productivity is high. The solution lies in elevating the alignment process itself.

Plans Over Code: The Future of Quality Assurance

The breakthrough comes from recognizing that plans are more reviewable than code. Rather than catching errors at the code review stage, teams should move the alignment process to the specification and planning phases. When errors are caught at the planning level, organizations prevent ten times more errors than they would catch at the implementation stage. This fundamental shift in workflow—from code-centric review to plan-centric review—aligns with the speed advantages AI provides while maintaining quality gates. The architectural patterns that emerge prioritize continuous validation, structured specifications, and persistent institutional knowledge. By treating specifications as executable contracts rather than living documentation, teams can leverage AI's speed while embedding guardrails at the point where they matter most: before code generation begins.

Key Takeaways

• Perfect alignment is structurally impossible: The two generals problem demonstrates that achieving 100% correspondence between human intent and AI output is a fundamental property of communication, not a limitation that better models will solve.

• **Non-deterministic systems require architectural guardrails