Thin Slices Stop /sdd-flow from Overflowing My Capacity

A Giant Pile of Shit

I thought I had mastered spec-driven development with Claude Code, and more fundamentally become an agentic coding superhero. That was until my ambitions overtook capacity. Agentic coding has gotten exceedingly powerful, but it still requires a developer to maintain close supervision, especially in more complicated scenarios.

Around six months ago I built this SDD development workflow plugin for applying a research-plan-implement cycle to software projects. Learning from my experience using it, I continued to tweak it and added additional review phases and steps that auto-corrected imperfections. It worked so well that I figured I could more fully automate the process, which led me to create the /sdd-flow skill. This allowed me to simply one-shot features (I am using "one-shot" loosely here because there are clarification and review steps involved). That worked well until my projects got complicated and one-shotting meant handling too many requirements and expectations at once. In short, I had drunk the Kool-Aid and believed AI could deliver.

The fact that I was developing several projects in parallel just compounded the mess that I found myself in. I got a little overwhelmed, and that led me to disregard sensible practices and become impatient and careless. I honestly just wanted to get to an end-state. I got irrationally hooked on delivering. And I definitely delivered. After three weeks of development and one week of trying to debug and steer the project back on course, I delivered an important lesson. I rediscovered the limits to agentic coding and AI model capabilities along with my own human limitations.

Thinner Slices

So I took a couple of steps back and evaluated my development process, both the parts I was guiding personally and the parts the agent was running.

First thing to fix was how coding agents typically build a multi-layered app. They conjure up an entire layer before moving on to the next. Take an app with a frontend and a backend. The agent delivers the whole frontend, normally a wide swath of functionality, then moves on to the backend. You can go several cycles before any of it is testable end-to-end.

Next problem, ironically, I was getting worse results although I had the app thoroughly unit and end-to-end tested. Leaning too much on this as an assurance for quality and completeness, I was skipping the personal review. Under pressure, I took the easy road and just entered the next prompt, rolled the dice, and kept gambling. That was dumb.

In search of a solution to better influence how a coding agent delivers and to correct what my behavior ended up being, I thought about how I would normally develop a project like this if I was doing the work "the old way," pre-GenAI. If you had a feature-rich application or even a complicated feature, you would focus on succeeding with one very specific slice. You would develop it all the way through, connecting all the various layers from the backend to the frontend, so that there was something that could be tested as soon as possible by a human user.

This vertical slice development approach, when applied to coding agents, would:

1. Force the agent to focus more tightly.
2. Make it easier for me to test and review what is being delivered.
3. Help me to better track what is being delivered and more quickly correct deviations.

That last point matters because it ties back to another behavior I needed to address. I was so focused on speed and so encouraged by previous successes that I was developing too much, too quickly. I needed to slow down.

Developing in slices makes it easier for me to digest the work and stick to more thorough reviews. Instead of one research → spec → implement cycle per feature, the feature is decomposed into vertical slices upfront. You keep the speed benefit within a cycle (no manual hand-offs between phases) but recover the oversight benefit. You're reviewing something small enough to actually understand and make time for. This is a much better fit for developing multiple projects in parallel with coding agents.

Software development is personal. This is what aligns with my style, my constraints and my experience.

In Control Again

So two out of the three projects that I was developing in parallel actually shipped. The third, most complicated project, the one that caused this whole rethink, I flushed down the toilet. It was such a mess and I had so little confidence in it that starting fresh was more sensible. Plus, this allowed me to start testing out everything that I have discussed here.

I have been very pleased with the results, both in how the agent now behaves and in how I'm forced to behave. The application now has a more focused set of initial features. I have a better grasp of what I am doing and how to keep growing it.

This sense of control has allowed me to get back to working on two other projects in parallel. Three seems to be my magic number. But I am running them at a saner, healthier rhythm now.

Zooming Out - Larger Implication

Coding agents are not finished products that you simply consume. They can work off the shelf for a lot of scenarios, but at the same time, for a lot of scenarios that are more complicated, they need to be adjusted and customized to how you develop. You have to get to a point where you understand how things flow for yourself and for an agent during a development cycle.

There are some very vocal people sharing what works for them, myself included. It's important to consider a variety of viewpoints and experiences. It helps to feed your own personal trials, but it comes down to you synthesizing all this information and figuring out what works for you, fits your style, and aligns with your processes. This requires investment and experimentation.

This process of trying to find the right alignment includes a bit of informal "vibe" evaluations. To get the most out of these tools and to exercise the most leverage, you need something more scientific. Luckily, there have been some recent releases that make it easy to do proper evals and capture comprehensive tracing in order to identify where your coding agent is failing and where it can be improved. More on this in an upcoming post.

In the meantime, remember that an agentic coding tool starts off as a sledgehammer. Customize the handle to fit your hands. Turn it into a screwdriver when the job calls for precision. Keep shaping this wonderful and scary technology to your own goals.

Use Slice Mode

The skill requires a flag to invoke the development in vertical slices: /sdd-flow delivery_mode: per-slice

This skill belongs to the agent-engineering plugin.