A developer once said:

"Feature's brainstorming is not my scope."

Please don't!

This sentence was always expensive. With spec-driven development and agentic coding, it becomes a risk for the developer's own job.

What happens when the developer leaves the brainstorming?

Nothing spectacular on day one. It is a slow chain reaction:

  1. Managers get bored. They invite, they explain, they follow up. Then they stop.
  2. The developer can't ask the right questions. He never heard the problem. He only has the solution, summed up in a ticket.
  3. Interest drops. How do you care about a business nobody tells you about?
  4. The domain stays a mystery. He knows the screens and the tables. Not the rules.
  5. Rules show up too late. He discovers them while developing the user story.

A user story is a placeholder for a conversation. Ron Jeffries said it in 2001: Card, Conversation, Confirmation. Remove the developer from the conversation, and only the card remains.

"Not my scope" doesn't remove the work of understanding. It moves it. From the moment it costs a question to the moment it costs code.

Why does it end in enormous delays?

A rule found in the code arrives after the design decisions. So we design it wrong. Then we have two bad options:

  • ❌ Twist product decisions to fit the code. The product stops following the business need and starts following the limits of our design.
  • ❌ Break the design at each change. Then the next request arrives, and we break it again.

Either way, delays get enormous. And nobody understands why a "small change" takes so long.

It's like building a house without ever talking to the people who will live in it. You meet the big family on the day the walls are up.

"It's developers' (mis)understanding, not domain experts' knowledge, that gets released in production." — Alberto Brandolini

If the developer wasn't in the room, what ships is a guess.

A rule found in a conversation costs a question. A rule found in the code costs a redesign. That is why my 10 steps to code a feature put the thinking before the code.

What does spec-driven development change?

Spec-driven development means writing a spec before writing code with AI. The spec becomes the source of truth, for the human and for the agent.

GitHub calls agents "literal-minded pair programmers". They need unambiguous instructions. A vague prompt, they say, forces the model to guess at thousands of unstated requirements.

Sounds familiar? That is our developer who skipped the brainstorming.

With one big difference. Without an agent, the developer hits the missing rule. Late and expensive, but he hits it. With an agent, the hole in the spec becomes clean, tested, readable code. And WRONG.

A late rule used to be a delay. Now it's a silent bug.

The DORA 2025 report calls AI an amplifier: it magnifies the strengths of high-performing organizations and the dysfunctions of struggling ones. An agent won't fix a team that discovers its rules while coding. That team will just be wrong faster!

Why is "not my scope" dangerous for your job?

Coding isn't just about typing code.

If your scope is "turn a complete ticket into code", that IS the agent's scope.

AI is not a substitute; it's a companion. But only for engineers who think about the problem. The value moves to what the agent can't do alone:

  • Understand the business problem.
  • Ask the question nobody asked.
  • Choose the trade-off with the product.
  • Review the result and say "this is wrong".

The last one is the most underestimated. How do you review an agent's code if you don't know the domain rules? You check the style. Not the meaning.

Saying "not my scope" keeps the part of the job that gets automated, and gives away the part that doesn't.

10 years of experience isn't one year repeated ten times. Ten years of translating tickets is exactly that...

How do you bring the developer back?

Start with your next feature:

  1. Join the brainstorming to ask questions, not just to listen.
  2. Ask for a concrete example of each rule.
  3. Hunt the edge cases before the code.
  4. Write the spec with the product: co-create, co-own.
  5. Slice small! A short spec gets read.
  6. Give it to the agent, then check the behaviors, not the style.
  7. A rule shows up in the code? Stop, and put it back in the spec.

Managers: don't get bored! Start with Trust: it breeds ownership. Try an event storming, and let the team co-create its first slices.

Should every developer join every meeting?

No. And spec-driven development is not a religion either.

Birgitta Böckeler tested the tools. One turned a small bug into four user stories and 16 acceptance criteria. About another, she says she would rather review code than all those markdown files.

The risk is replacing one ritual with another. A pile of generated specs that nobody reads is not a conversation. It's waste, in a nice format.

The spec is not the goal. It is the written trace of a conversation. For a one-line bug, a test is enough. For a feature that touches a business rule, the developer must be in the room.

💡 Remember: think twice, code once!

With agentic coding, code gets cheaper and cheaper. Understanding doesn't. That is where the job is now.

Does your team discover its rules while developing? Do you want spec-driven development without a new document factory? VisionPM can help, on the ground, with your teams. Read my background and write to contact@visionpm.fr.

Any thoughts?

Resources and bibliography

First published on LinkedIn: the original post