Agentic Workflows Amplify Developer Discipline for Software Quality

In this conversation with Don Syme, host Scott Hanselman explores the seismic shift occurring in software development with the advent of agentic workflows. The core thesis is that while AI tools offer unprecedented power, their true value lies not in replacing human craft but in augmenting it, demanding a new level of developer discipline and strategic guidance. The non-obvious implication is that this technological leap doesn't democratize mediocrity; instead, it amplifies the need for deep understanding of software quality, rigorous testing, and intentional design to harness AI's potential effectively. This discussion is crucial for developers, team leads, and engineering managers who need to navigate the evolving landscape of AI-assisted development, understand the hidden costs of unchecked automation, and discover how to leverage these tools to build more robust, maintainable software, thereby gaining a significant competitive advantage.

The Double-Edged Sword: Wizard Powers and the Ghost of Technical Debt

The current moment in software development feels like a revolution, a sentiment echoed by Scott Hanselman and Don Syme. Syme likens new developers to having "wizard powers," capable of conjuring software with modern coding agents. This isn't just about faster development; it's about a fundamental change in how software is conceived and built. However, this power comes with a critical caveat: the potential to amplify existing mediocrity or create new forms of technical debt if not wielded with discipline. Syme emphasizes that the craft of building reliable software--free from nulls, with strong construction guarantees--remains paramount. The challenge, then, is to marry this deep-seated need for quality with the speed and power of AI.

The danger lies in what Syme calls "vibe coding" or simply training AI on the vast, often imperfect, corpus of existing code. If AI agents learn from a history of mediocre practices, they will perpetuate them. The question becomes: how do we ensure these powerful tools elevate the software development lifecycle (SDLC) rather than just accelerating its existing flaws? Syme's focus on empowering repository maintainers and core engineers to set the tone and direction is key. This involves establishing feedback loops, such as integrating production profiling and telemetry, to guide AI towards performance and quality goals.

"We are going to want, as much as people are happy vibe coding and the like, there is still a notion of better software. And a lot of the work we're kind of doing is about how can we get the best of both worlds, right? How do you empower the developer to be running full throttle, not necessarily in the vibe coding, but certainly in that kind of creating, creative."

-- Don Syme

This leads to the concept of "ambiguity loops." While traditional programming relies on deterministic "for loops," agentic workflows introduce "ambiguity loops" that allow for more flexible decision-making. These loops, Syme argues, require robust checks and balances--tests, complexity checks, and human oversight--to prevent AI from going "off the rails." The failure to implement these guardrails is where unchecked ambiguity can lead to the generation of "slop," a term Hanselman uses to describe AI-generated code that lacks quality or purpose. The success of agentic workflows, therefore, hinges on good software engineering practices that keep these powerful tools "on rails."

Continuous AI: The Third Leg of the DevOps Stool

The conversation pivots to how agentic workflows fit into the existing DevOps paradigm. Syme introduces "continuous AI" as a necessary third leg to the stool of continuous integration (CI) and continuous deployment (CD). This additive approach means that DevOps, rather than being diminished, becomes even more critical. Continuous AI encompasses tasks like continuous documentation, continuous triage, and, crucially, continuous code simplification and test improvement.

The core idea is that AI can continuously work on refining the codebase, identifying areas for simplification, and enhancing test coverage. This isn't about replacing human judgment but about automating the toil and repetitive tasks, freeing up developers for higher-level strategic work. Syme stresses that this requires a cultural shift within DevOps, moving from a strict adherence to determinism to embracing a controlled level of indeterminism offered by AI, always under human control.

"The one we're adding is what we call continuous AI. And that is all about these ambiguity loops, these softer judgments that need to be made about software."

-- Don Syme

This concept of "continuous AI" directly addresses the fear that AI will simply churn out mediocre code. By integrating AI into the SDLC as a continuous process, it can proactively address technical debt, improve code quality, and ensure documentation stays current. The key is that humans remain in control, guiding the AI's goals and reviewing its outputs. This proactive approach to quality, Syme suggests, is where the real competitive advantage lies--building software that is not just built quickly, but built better.

Repo Assist: Taming Technical Debt with Agentic Workflows

To illustrate the practical application of agentic workflows, Syme details his "Repo Assist" tool. This workflow is designed specifically to tackle the pervasive problem of technical debt in open-source repositories. Syme describes the "guilt of a maintainer" when faced with a backlog of issues and the feeling of not properly maintaining a beloved project. Repo Assist, installed via a simple command, acts as an assistant, running periodically to label issues, propose bug fixes, suggest engineering improvements, update its own pull requests, and prepare releases.

The impact Syme describes is profound: in one repository, F# Control Asynchronous Sequences, Repo Assist helped close out about half of the 50 existing issues by providing solid technical analysis, automating the initial understanding of issues that maintainers would typically do with AI assistance anyway. This automation frees up maintainers to focus on higher-value tasks like reviewing AI-generated fixes and deciding on the project's future direction.

"It is, I found it absolutely amazing. I've used, I think, in seven repositories now. We'll take one. So F# Control Asynchronous Sequences. It's a piece of software that's very dear to my heart because it's one of the first ever implementations of asynchronous sequences... and it just closed, it just either made very good comments on, on the whole, very good comments on the, on the issues."

-- Don Syme

This example highlights the "delayed payoff" of agentic workflows. The initial setup and integration might seem like an investment, but the long-term benefit is a significantly reduced maintenance burden and a more robust codebase. Syme's personal experience--feeling "alive again as a maintainer"--underscores the emotional and professional reward of taming technical debt. He emphasizes that this process shifts collaboration from the minutiae of pull requests to higher-level discussions about the repository's overall direction and goals, a clear competitive advantage derived from tackling a problem most teams find overwhelming.

The Harness: Guardrails for AI-Powered Development

The conversation circles back to the critical need for guardrails. Hanselman's analogy of an "ambiguity loop" without bounds leading to "slop" is directly addressed by Syme's framework of goals, constraints, and guardrails. He uses the metaphor of a "junior engineer" to describe the AI agent. Just as a junior engineer needs guidance and supervision, so too do AI agents. The effectiveness of advanced tasks like performance engineering or test improvement depends heavily on the "harness" provided--the quality of micro-benchmarks, proper setup, and manual verification.

This is where the "discomfort now, advantage later" principle comes into play. Investing time in setting up robust benchmarking, defining clear goals, and establishing strict constraints for AI agents is difficult work. However, this upfront investment is precisely what prevents the generation of low-quality code and ensures that AI's "unlimited energy" is channeled productively. Without this harness, AI-generated code can be unreliable, leading to frustration and a loss of trust.

Syme advocates for educational institutions to incorporate courses on AI-assisted software development, teaching students the fundamentals of good engineering practices that will allow them to effectively guide these new tools. The ability to make sound judgments, understand what constitutes quality software, and skillfully direct AI is becoming the new core competency. This requires moving beyond simply "vibe coding" and embracing the discipline of engineering AI-powered development, ensuring that the future of software is not just faster, but demonstrably better.

Key Action Items:

• Immediate Actions (Within the next quarter):

  • Review existing CI/CD pipelines: Identify opportunities to integrate AI tools for tasks like automated documentation updates or initial issue triage.
  • Experiment with basic agentic workflows: Utilize tools like GitHub Repo Assist on a non-critical project to understand their capabilities and limitations.
  • Establish clear AI usage guidelines: Define acceptable use cases for AI code generation and review processes within your team.
  • Invest in developer education: Provide training on prompt engineering and best practices for working with AI coding assistants.

• Longer-Term Investments (6-18 months):

  • Develop internal AI best practices: Document successful patterns and guardrails for agentic workflows based on team experience.
  • Integrate AI into core development processes: Explore using AI for continuous code simplification, test generation, and performance analysis.
  • Implement robust feedback loops: Ensure AI outputs are consistently reviewed and used to refine AI models and prompts for improved accuracy and quality.
  • Foster a culture of critical AI review: Encourage developers to rigorously evaluate AI-generated code, focusing on maintainability, security, and performance, not just immediate functionality.