DEV Community: Patricio Renner

🧬 Spec-Driven Development: An Evolutionary Approach

Patricio Renner — Thu, 16 Apr 2026 18:42:45 +0000

Ten years ago, I attended a workshop on building DevOps teams for CTOs at Chef's annual conference in Austin, Texas.

One of the speakers was Chef's VP of Engineering, who shared a story about Spotify. He opened with a provocative line: "nothing of what's published about how Spotify works is true." He then mentioned that some of the articles we could find online were actually his own. He had consulted with the team to help them develop their working methodology. What he had learned from them was their unique capacity for reflection and continuous evolution: how they work today is very different from how they worked 6 months ago, which in turn was very different from how they worked 6 months before that.

That continuous learning mindset became an inspiration for how I work, and it has shaped my approach to agentic software development and, especially, to adopting Spec-Driven Development in that context.

Why I Don't Recommend Any SDD Framework

Several people have asked me which GitHub SDD-framework repositories I recommend. My answer is none. Does that mean they're not good? Not at all. Some contain very valuable insights and can offer inspiration for designing your own model. If you find an interesting project, explore it, understand it, and learn to extract the valuable lessons and incorporate them into your own model.

My recommendation is to follow your own path: build your own SDD implementation and evolve it continuously. For every mistake you encounter along the way, every lesson learned, take the time to analyze it and add it to your knowledge base. You can use skills to implement continuous improvement cycles. This gives you the flexibility to create a system tailored to your needs, with the ability to incorporate the learnings you gain from experience.

A Concrete Example: /pipeline-optimizer

In all my projects, I implement a /pipeline-optimizer skill. When an error occurs, its role is to investigate the root cause and propose systematic improvements to prevent errors of the same kind from happening again. The skill owns the definitions for agents, skills, rules, hooks, and the specifications of the development pipeline and quality guidelines.

Why Self-Evolution Matters

This capacity for self-evolution becomes critical because of the speed at which tools and LLM models are changing. As an example, Claude Code ships a new release every 1 or 2 days, and it's not just bug fixes: each release brings new functionality. If you own your model, you can understand those changes, evaluate them, and adopt them at your own pace. If you depend on an external framework, you wait for someone else to do it for you.

** What path are you following? Are you building your own SDD implementation, or still relying on external frameworks? **

The LLM Behaviors That Shape Agentic Development

Patricio Renner — Thu, 26 Mar 2026 20:53:20 +0000

Key Learnings for Implementing Spec-Driven Development

In previous posts, I shared my conviction that it's possible to produce quality software with AI coding agents and that the key lies in spec-driven development. But to design an agentic programming framework, you need to understand how models operate. Here are five fundamental learnings.

1. Code Quality

A year ago, the biggest issues were lack of prompt adherence and degradation over iterations, leading to regression and spaghetti code. Today, models have fewer hallucinations, deliver higher quality code, and follow prompts more reliably, making it possible to consistently produce high-quality code with proper specifications.

2. Context Management

Context is the information available to a model at a given moment. Although context windows have grown significantly, more isn't always better. As that context is consumed during a session, prompt adherence decreases and misinterpretations of what was requested increase. It's essential to provide focused, well-defined tasks that the model can process efficiently. Avoid compaction at all costs: the model decides what to keep, and you lose control of the context.

3. The Amnesiac Developer Syndrome

Models are like a developer with amnesia: each new session forgets everything it did before. They act like a senior dev who just joined a project. Without proper onboarding, they make mistakes not from lack of expertise, but from unfamiliarity with the project and its code. That's why the quality of context injected into the agent is essential for reliable results.

4. How Models Respond

Models are designed to deliver complete responses, using inference to fill in what is missing from the prompt. If the prompt is broad, ambiguous, or incomplete, the model fills in the gaps with its own assumptions. In that process, the user loses control of the result and may get code that doesn't align with their expectations without being aware of it. That's why it's critical to provide complete, clear, and unambiguous specifications.

5. Models Make Mistakes

Agents are not yet capable of consistently delivering error-free code, and these errors don't always stem from gaps in your specifications; they can also arise from inherent model limitations. Agentic workflows must be designed on the assumption that models will introduce bugs, much like you'd design processes for a team of human developers.

Boris Cherny (head of Claude Code at Anthropic) reinforces this point: using separate context windows is what makes subagents work. One agent can cause bugs and another, using the same exact model, can find them. Until agents write perfect bug-free code, multiple uncorrelated context windows is a good approach.

Understanding how models operate is the first step to designing an agentic development process that produces consistent, quality results.

I'm working on a longer article that expands on these points with real-world examples and practical lessons. I'll share the link here once it's published. After that, I'll cover how I put spec-driven development into practice with concrete implementation patterns.

Have you run into any of these behaviors when working with agents? I'd love to hear how you've dealt with them.

Is It Possible To Build High-Quality Software With Agents?

Patricio Renner — Thu, 26 Mar 2026 19:55:16 +0000

Tools, Methodology, and the Engineer's Evolving Role

The quality of applications built with AI agents is a controversial topic. Several senior software engineers raise concerns such as:

Code quality degradation over iterations.
Functionality breaking when new features are added (regression).
Systems that don't meet production standards, among others.

I'm convinced that with the current state of the art, it is possible to produce quality software that meets the most demanding standards for reliability, privacy, and information security, while maintaining these attributes consistently over time.

There have been significant improvements compared to what was possible just a few months ago. However, it's not the models alone that make the difference, but a combination of:

The tools that enable complex development processes by orchestrating multiple agents (like Claude Code, my favorite).
The learning that developer communities have built from a better understanding of how models operate and how to get the most out of them (methodology).

Today, development agents are not mature enough to generate top-tier software autonomously. They require detailed and precise guidance from the engineer in charge, which in turn requires a proper methodological approach.

How do you prevent regression? By incorporating rigorous testing under a TDD model.
How do you avoid code vulnerabilities? Periodic cybersecurity audits. In my case, I run them once a week (Have you tried /security-review in Claude Code?).
How do you ensure well-structured, organized code is maintained over time? Thorough periodic code quality reviews, which I do every 1-2 days.
How do you make the application handle errors gracefully and provide adequate feedback? Error handling guidelines for the agents.

All of this, executed through specialized agents orchestrated within my development workflow, along with detailed documentation containing architecture guides and standards.

Beyond the specific techniques, there's a deeper reflection:

The process isn't simple, but the reward is significant: in my experience, productivity gains can reach 5x-10x, and the possibilities that open up are endless.

To achieve this, the software engineer's role needs to evolve: less time writing code, more time designing the specifications, standards, and guardrails that make quality possible.

In the next post, I'll explore how LLMs actually behave and why understanding their mechanics is essential to getting consistent results.

Are you making that transition, or are you still evaluating whether the leap is worth it?

Agentic Software Development

Patricio Renner — Thu, 26 Mar 2026 19:37:26 +0000

Reflections After 3 Years of Use

I've been intensively using generative AI since ChatGPT was released in November 2022. Software development quickly became one of the areas where I use it most. Repeated cycles of enthusiasm and disappointment have led me to a more mature understanding of its strengths and limitations. Here are some reflections.

The New Baseline for Development

I'm convinced that in the current state of the art, specialized code generation agents are a fundamental tool for software developers. Those who don't adopt them are creating a massive handicap compared to those of us who use them systematically.

Beware of Trivialization

I'm concerned about the trivialization happening when people without software engineering knowledge see how "with a simple prompt" they can build functional applications "without coding." While this is possible, there are several caveats to keep in mind.

Many platforms that let you generate applications with a prompt lock you into their environment (vendor lock-in) and produce applications with security, scalability, and maintainability issues unsuitable for production. On top of that, people without software experience lack the ability to write complete specifications, so the AI fills in the gaps with assumptions that aren't made explicit and often don't align with expectations. These applications can be useful as prototypes or for private use, but risky for broader deployment.

The Senior Developer's Superpower

On the flip side, software development agents can be a superpower in the hands of a senior developer. AI cannot produce production-grade software without proper guidance, but it can dramatically accelerate productivity.

This isn't about "vibe" coding, but about spec-driven development. That means producing detailed technical documentation that guides development agents to generate the required code.

What does it include? Functional specifications with measurable acceptance criteria, architectural patterns, code quality standards, testing, security, observability, among others.

The developer's role doesn't disappear; it evolves from writing code to designing the structural elements that enable quality software. As Faisal Haque puts it, this is the evolution from coder to builder.

I've been dedicating myself to exploring and experimenting with how to produce high-quality software using agents, and I'm preparing a series of posts to share the learnings I've gathered along the way.

In the next posts, I'll dig into the specifics: how models actually behave, what spec-driven development looks like in practice, and the techniques that make the difference. What's been your experience so far?