Pull strategy and BDD: the end of "give me the specs"
Two things developers say:
"We should not care about tomorrow's concepts and possible changes."
"Give me specs to start working…"
…on your waste. Functional and technical.
Both sound reasonable. Both are expensive.
There is another way to organize the work: a pull strategy, with BDD and continuous delivery.
Why does ignoring tomorrow's changes cost so much?
The first one sometimes hides behind YAGNI: "You Aren't Gonna Need It".
Except YAGNI doesn't say that.
The Yagni article on martinfowler.com is very clear. YAGNI is about features we SUPPOSE we will need later. It does not cover the effort that keeps the software easy to modify. What's more: YAGNI only works if the code stays easy to change.
Don't build for tomorrow. But don't block tomorrow!
The developer who refuses to think about the next change is not keeping it simple. He is being simplistic. Don't confuse simple and simplistic! They are two orthogonal concepts.
A suitable trade-off is not perfection. It is the simplest design that fits the requirements today and does not block the next change.
Why does "give me the specs" produce waste?
Picture a restaurant.
Every morning, someone writes the list of dishes. The cook follows it to the letter. Fifty dishes are ready at noon. Nobody talked to the customers.
In the evening, half of it goes to the bin.
Did the cook do a bad job? No. He followed the list. But nobody in the kitchen asked who was coming to eat.
This is exactly "give me the specs". Someone pushes a pile of specs. The developer codes them as written. Waste included.
And guessing is expensive. At Microsoft, online experiments measured it: only about a third of the tested ideas improved their target metric.
On the product side, SVPG describes the same trap. A feature team receives a list of features to deliver. A real product team receives problems to solve.
It is the logical sequel to "not my scope". A user story is a placeholder for a conversation. Remove the developer from the conversation, and only the card remains. So he waits for someone to fill it.
What is a pull strategy?
The idea comes from manufacturing, at Toyota.
The principle is simple: you only start a piece of work when someone needs it and a slot is free.
In push, you produce big batches from a forecast. Then you push them to the next step, ready or not.
In pull, it is the opposite. The next step asks. The step before produces. Nothing is produced without that signal. The goal: no overproduction.
Our restaurant in pull? The customer orders, the kitchen cooks, the dish goes out hot.
In a software team, that means three rules:
- Limit the work in progress.
- Finish what is started.
- A slot is free? Pull the next item, the most valuable one.
On martinfowler.com, it is called continuous flow: when a story is finished, the team pulls the next one.
Careful: a board with columns is not pull yet. Without a limit on work in progress, it is just a board.
What the team gains:
- Less waste. No stock of specs written six months too early.
- Finished work. There is no half-finished feature hiding in a branch.
- Visible problems. A full column shows the bottleneck.
- Faster feedback. DORA's research links working in small batches to better delivery performance.
- Better-informed decisions. You commit later, with more facts.
A team that ships once a quarter learns once a quarter.
What does BDD have to do with it?
IMHO, BDD is pull applied to specs. Its founding text offers one question to choose the next behavior:
"What's the next most important thing the system doesn't do?" — Introducing BDD (2006)
This is a pull question! We don't ask: "Is the spec complete?" We ask: "What is the next behavior that matters?"
The conversation happens before the story is pulled, as close to the need as possible. Not six months before. Product, design and the developer look for concrete examples together. These examples become the spec, then the tests.
Continuous delivery closes the loop. The software stays releasable at any time, and each small slice goes to production. User feedback gives the next signal.
The spec is no longer pushed to the developer. It is pulled by the need.
What does a week look like with a pull strategy?
Two things keep the flow going: close collaboration with product, and code that is easy to change. You can give both fixed slots.
In my previous experience, our week looked like this:
| When | What |
|---|---|
| Monday afternoon | Product or customer success shadowing |
| Every day, 30 minutes | Ticket grooming: example mapping or a light event-storming session |
| Wednesday | Chores and "discotech" |
A ticket started in "Ideas", moved to "Ready", then was pulled.
Monday afternoon: the field.
Fixed slots for product discovery (shadowing customer success, support, product…) can improve the scope of the next candidates. It is close to what Product Talk calls continuous discovery: weekly contact with customers, by the team that builds the product.
Every day, 30 minutes: the conversation.
Not a big ceremony. Thirty minutes to move tickets towards "Ready", with concrete examples (that is example mapping) or a light event-storming session.
"Ready" does not mean "complete spec". "Ready" means the conversation has happened.
Wednesday: chores and "discotech".
"Discotech" is the name we gave to technical discovery and light specs, written as a team. The opposite of "give me the specs"!
To go fast, a team takes reasonable and pragmatic shortcuts. A shortcut you admit costs almost nothing. But it has to be reworked, otherwise the next change slows down. Then the one after.
So you can reserve a fixed slot for chores and refactoring, and let the team choose the next technical ticket to pull. They know where it hurts.
This is not scheduling technical debt for next month. The cleanup does not wait for a separate project: it happens inside the story that exposes the mess. The slot is for the rest: chores, and shortcuts taken on purpose. A habit that depends on free time disappears in the first busy month.
No more "technical debt management". The goal: code that is ready for the next change, without slowing the pace. That is the real answer to "we should not care about tomorrow".
In a restaurant, they call it cleaning the kitchen.
To start on Monday:
- Make all the work visible. All of it, even the "small things".
- Set a low limit on work in progress. Limit reached? Help finish.
- Reserve fixed slots: the field, the conversation, the chores.
- Choose the next item by value: what is the next behavior that matters?
- Before you pull a story, talk. Product, design and dev, with examples.
- Slice small, ship, measure, learn. Then pull the next item.
❌ "Is the spec complete?"
✅ "What is the next problem to solve?"
What does the AI and agentic era change?
It amplifies. In both directions.
On one side, the problem gets worse. An agent codes a pile of specs much faster than a developer. Waste included. Push pushes harder: more code, more work in progress, more review. And the cost goes up with it.
The DORA 2025 report calls AI an amplifier: it magnifies the strengths of high-performing organizations and the dysfunctions of struggling ones.
On the other side, with a good methodology, it is an accelerator. Pull limits what the agent starts. BDD examples give it a clear spec. Small slices keep the review possible. The chores slot keeps the code easy to change, for the human and for the agent.
AI is not a substitute; it's a companion. With a good method, it empowers engineering performance. Without one, it produces waste faster!
Does a pull strategy fit every team?
No. And it is not a religion.
The Continuous Flow article says it plainly: continuous flow is effective for skilled teams. A less experienced team does better with iterations, which give a rhythm and regular feedback.
You also need slack. A team that is always busy is usually a red flag. It stops pulling and takes whatever is pushed at it.
And a fixed slot can turn into a ritual. A meeting without a decision costs the team time.
Pulling does not mean no planning. It means planning small, often, as close to the need as possible.
💡 Remember: finish each change properly before you start the next one!
Is your team waiting for its specs? Is your backlog full of "almost done" work? VisionPM can help, on the ground, with your teams. Read about my background and write to contact@visionpm.fr.
Any thoughts?
Resources and bibliography
- Martin Fowler, Continuous Flow (martinfowler.com, 2023). https://martinfowler.com/bliki/ContinuousFlow.html
- Martin Fowler, Yagni (martinfowler.com, 2015). https://www.martinfowler.com/bliki/Yagni.html
- Dan North, Introducing BDD (dannorth.net, 2006). https://dannorth.net/blog/introducing-bdd/
- Matt Wynne, Introducing Example Mapping (cucumber.io, 2015). https://cucumber.io/blog/example-mapping-introduction
- Lean Enterprise Institute, Pull Production (Lean Lexicon). https://www.lean.org/lexicon-terms/pull-production/
- Lean Enterprise Institute, Push Production (Lean Lexicon). https://www.lean.org/lexicon-terms/push-production/
- Lean Enterprise Institute, Just-in-Time Production (Lean Lexicon). https://www.lean.org/lexicon-terms/just-in-time-production/
- DORA, Work in process limits (dora.dev). https://dora.dev/capabilities/wip-limits/
- DORA, Working in small batches (dora.dev). https://dora.dev/capabilities/working-in-small-batches/
- Corey Ladas, What is Scrumban? (Agile Alliance, 2008 essay). https://agilealliance.org/scrumban/
- Mary Poppendieck, Lean Software Development (essay, leanessays.com, 2003). https://www.leanessays.com/2003/04/lean-software-development.html
- Jez Humble, David Farley, Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation (Addison-Wesley, 2010). https://continuousdelivery.com/
- DORA, 2025 State of AI-assisted Software Development Report (Google, 2025). https://research.google/pubs/dora-2025-state-of-ai-assisted-software-development-report/
- Marty Cagan, Product vs Feature Teams (SVPG, 2019). https://svpg.com/product-vs-feature-teams
- Teresa Torres, Continuous Discovery (Product Talk glossary, 2025). https://www.producttalk.org/glossary-discovery-continuous-discovery/
- Ronny Kohavi et al., Online Experimentation at Microsoft (Microsoft ThinkWeek, 2009). https://exp-platform.com/Documents/ExPThinkWeek2009Public.pdf
First published on LinkedIn: the original post
