Vertical slicing: "done, only the tests are missing"
"Done, only the tests are missing."
You have probably heard it at a stand-up. In superTeam, it goes like this.
An experienced developer says it every morning, for two weeks: the ticket is done, only the tests are missing.
The day after: the tests are complicated to write, but the work is done. You can test it manually.
The day after: actually, everything works fine. The tests are just taking time.
Then he lets everyone know that testing is not his core skill. And that it is optional.
Managers react and ask to skip the tests. The other mates remind them that they need quality proofs, and that capturing regressions is important.
The product suffers. The team too.
Why is "done, only the tests are missing" not done?
Is it proven? Is it integrated? Did a user see it?
No.
A manual test proves one path, once. It captures nothing for tomorrow. A ticket that takes days hides its risk until day three. This one hid it for two weeks.
Tests should be part of the coding activity. When they come after, they are complicated to write, because nothing in the design was driven by them.
But careful: testing is not a synonym of quality! Tests added afterwards, on the wrong scenarios, check technical details. They add waste to bad quality.
And how much of those two weeks solved a supposed problem? Nobody knows. Nothing reached a user.
Do this ticket after ticket: the budget explodes, and the project gets abandoned. Non-quality is expensive!
IMHO, the problem is not the tests. It is the slicing. This ticket was never a vertical slice.
We work in sprints. Isn't that iterative?
Iterative is not incremental!
Jeff Patton explained it in 2008: iterating and incrementing are separate ideas. An artist works iteratively: the whole face is sketched first, then refined. A paint-by-number artist works incrementally: one corner finished to the last detail, then the next one. Nothing looks like a face until the end.
Incrementing a solution that was fixed upfront, with the feedback at the end, is waterfall in pieces. Not a best practice.
❌ Sprint 1: the database. Sprint 2: the API. Sprint 3: the screens.
✅ Week 1: one user does the simplest version of the job, end to end.
Coding agents and spec-driven development fall into the same trap, only faster. Leave the agent without clear boundaries, skip the validation iteration by iteration, ask too much for each iteration. Pivoting becomes really hard, and rubbish lines of code stay in your workspace without you knowing.
"Only the tests are missing" is the same waterfall, at the scale of one ticket.
If slices are thin, where does the architecture go?
In the first slice.
Alistair Cockburn calls it a walking skeleton: the smallest version of the system that runs end to end and connects the main parts. Growing Object-Oriented Software, Guided by Tests starts a project with one. On the product side, it carries the first thin path of your story map.
The bones of the skeleton are the boundaries and the words. A domain model is not a class diagram: it is the vocabulary of the business, in the code.
Ian Cartwright and Martin Fowler call business value The Elephant in the Architecture. From what I see, architecture and modelling have a huge hidden business value:
- They make the code go fast and well, at any time. The only way to go fast is to go well.
- They make every feature easy to test. "Complicated tests" often mean wrong boundaries, not missing skills.
- They free the conversations, with the business and with AI, from the translation tax.
- They are the spine of your agentic harness: where the agent can work, and how its work is checked.
This is not big design upfront. The skeleton sets only the boundaries that the first path needs. Defer, prove and challenge each technical decision. A good architecture makes the next change cheap, not every possible change.
How do you slice vertically?
Slicing is vertical. Never horizontal!
❌ A database ticket, an API ticket, a UI ticket. Then an "integration" ticket.
✅ "An employee submits an expense and sees it in their list."
A slice either works for a user or it does not. The team co-creates it with product, around concrete examples.
Take superTeam's ticket, expense approval:
| Slice | The one rule | The example that proves it |
|---|---|---|
| 1. Submit an expense | A submitted expense appears in the employee's list | A €20 expense is submitted: it is in the list |
| 2. Route by amount | Under €50: approved. From €50: waits for the manager | A €120 expense with a receipt waits for the manager. A €20 one is approved |
| 3. Receipt required | Above €25 without a receipt: rejected | A €40 expense without a receipt is rejected |
Slice 1 has no business rule. It builds the walking skeleton. Then each slice adds ONE rule, without ambiguity, and the previous examples stay green. Vertically sliced minimalist tickets!
Which slice comes first? The one that proves, or kills, the riskiest assumption. Not always the happy path.
A thin slice is simple. A slice that silently skips a rule is simplistic. Don't confuse simple and simplistic!
How small is small enough?
Smaller than small.
A good heuristic: a slice reaches production in one or two days. If it takes longer, slice again.
The mechanism: we always solve supposed problems. Sometimes problems that do not exist. The bigger the slice, the more supposed problems it carries, and the later we find out. Fail fast, learn faster!
With coding agents, this is no longer a preference. DORA's research finds that AI adoption often comes with more delivery instability, and that working in small batches counters that risk.
Your team thinks its slices are already small? Try Alistair Cockburn's Elephant Carpaccio workshop once. You will be surprised.
Why do small slices still bring surprises at the end?
Because they wait on a branch.
A slice is an iteration only when it is integrated and releasable. superTeam's ticket lived two weeks on its branch. Slice it in three and merge the three branches on the last day: it is the same waterfall.
Trunk-based development and continuous delivery are the guideline for a real iterative way of working:
- Everyone integrates into the trunk at least once a day.
- Unfinished work hides behind a feature flag, not on a branch. Deployed does not mean released.
- The software stays releasable at any time.
With coding agents, the long-lived branch gets worse. An agent produces code faster than anyone can review it. On a branch, the unreviewed code piles up until the merge. On the trunk, the feedback comes before the pile.
So when is a slice done?
Back to superTeam. Three slices, each one with its example, each one tested while it is coded, each one on the trunk within a day or two.
The acceptance example comes first, then Test FIRST. First does not mean start by testing only. FIRST is an acronym: Fast, Isolated, Repeatable, Self-validating, Timely. Timely means written with the code. Not two weeks later!
Captures behaviors, NOT technical details! Ian Cooper explained it in TDD, where did it all go wrong. Otherwise the test blocks the refactoring it should protect, and the team starts to skip it.
The tests are complicated to write? It is a signal: too many rules in the slice, or a missing boundary. Slice again, or add the boundary, until the test becomes boring.
Testing is not your core skill? Extreme Programming answered long ago: pair programming and collective ownership.
Done means: on the trunk, proven by its examples, releasable, and observable in production.
What does AI change?
Nothing. Except the size of the damage. And the speed to get there, with little to no awareness, depending on the amount of care you put into your harness.
Without iterations, a coding agent gets lost, hallucinates or over-engineers. It creates mountains of rubbish code and functional issues.
That is why the harness matters. It must oblige every model to work in EXACTLY the same frame: one vertical slice at a time, the example first, Test FIRST, the same boundaries, the same definition of done.
Birgitta Böckeler calls it harness engineering: guides before the agent acts, sensors after.
And testing goes wild. Tests generated after the code look like the code. They pass by construction. Researchers already have a name for the leftovers, CodeSlop: "the residual and functionally unnecessary edits commonly seen in AI-generated code".
Today, superTeam's developer would not say "only the tests are missing". He would show 300 green tests that prove nothing.
So ask one question: would this test fail if the code were wrong?
AI is not a substitute; it's a companion. Without thin slices, it produces waste faster!
When is slicing not enough?
Slicing comes after the ground is solid. No tests at all? No conversation with product? Start there.
To start on Monday:
- Take the next feature in your backlog.
- Find, with product, the first behavior worth proving.
- Write its example.
- Cut everything else.
- Ship it on the trunk, behind a flag. Then pull the next slice.
💡 Remember: slice vertically, smaller than small, and ship it on the trunk. The risky part fails in hours, not weeks!
Are your tickets "done, only the tests are missing"? VisionPM can help your team slice for real, with humans or coding agents. Read about my background and write to contact@visionpm.fr.
Any thoughts?
Resources and bibliography
- Jeff Patton, Don't Know What I Want, But I Know How to Get It (jpattonassociates.com, 2008). https://jpattonassociates.com/dont_know_what_i_want/
- Jeff Patton, User Story Mapping (O'Reilly, 2014). https://www.oreilly.com/library/view/user-story-mapping/9781491904893/
- Alistair Cockburn, walking skeleton (alistaircockburn.com). https://alistaircockburn.com/Bio
- Alistair Cockburn, Elephant Carpaccio (workshop). https://alistaircockburn.com/Elephant-Carpaccio
- Steve Freeman, Nat Pryce, Growing Object-Oriented Software, Guided by Tests (Addison-Wesley, 2009). https://www.informit.com/store/growing-object-oriented-software-guided-by-tests-9780321503626
- Eric Evans, Domain-Driven Design: Tackling Complexity in the Heart of Software (Addison-Wesley, 2003). https://www.pearson.com/en-gb/subject-catalog/p/domain-driven-design-tackling-complexity-in-the-heart-of-software/P200000009375
- Ian Cartwright, Martin Fowler, The Elephant in the Architecture (martinfowler.com, 2020). https://martinfowler.com/articles/value-architectural-attribute.html
- Martin Fowler, Yagni (martinfowler.com, 2015). https://martinfowler.com/bliki/Yagni.html
- DORA, Working in small batches (dora.dev). https://dora.dev/capabilities/working-in-small-batches/
- DORA, Trunk-based development (dora.dev). https://dora.dev/capabilities/trunk-based-development/
- Paul Hammant, Trunk Based Development. https://trunkbaseddevelopment.com/
- Jez Humble, David Farley, Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation (Addison-Wesley, 2010). https://continuousdelivery.com/
- Tim Ottinger, Jeff Langr, F.I.R.S.T (Agile in a Flash, 2009; source: Brett Schuchert, Tim Ottinger). https://agileinaflash.blogspot.com/2009/02/first.html
- Kent Beck, Cynthia Andres, Extreme Programming Explained, 2nd edition (Addison-Wesley, 2004). https://www.informit.com/store/extreme-programming-explained-embrace-change-9780321278654
- Ian Cooper, TDD, where did it all go wrong (NDC Oslo, 2013). https://av.tib.eu/media/51426
- Birgitta Böckeler, Harness engineering for coding agent users (martinfowler.com, 2026). https://martinfowler.com/articles/harness-engineering.html
- Alex Mathai et al., TRIM: Reducing AI-Generated CodeSlop via Agent Trajectory Minimization (arXiv, 2026). https://huggingface.co/papers/2607.18161
