I stopped prompt-and-praying with Claude Code. Now it interviews me first.

Murilo Narciso — Sun, 05 Jul 2026 15:30:41 +0000

For months my workflow with Claude Code was what I now call prompt-and-pray: write a big prompt describing the feature, watch the AI code for a while, and discover at the end that it solved the wrong problem. Then pay again, in tokens and in patience, to redo it.

The turning point was admitting the problem wasn't the model. It was me, shipping vague specs to a very fast executor. A junior dev with a vague ticket writes the wrong thing slowly; Claude writes the wrong thing at 200 tokens per second.

So I stopped tuning prompts and built a protocol instead. This post is the full methodology, free to steal even if you never install anything.

The core inversion: the AI interviews you

The first fix was flipping the interview. Instead of me describing the feature, the AI questions me. One question at a time, no vague answers accepted, challenging my assumptions against what actually exists in the codebase, until scope and success criteria are airtight.

This sounds slow. It's the opposite. Twenty minutes of interrogation is cheaper than one wrong implementation, and the interview ends with something a prompt never gives you: a shared, written understanding of what we're building and what we're explicitly NOT building.

Six phases, four human gates

The full protocol runs as a single command (/adp) that drives a feature end to end:

Phase	What happens
0 · grill-me	The AI interviews you until scope is airtight. Gate: you approve the scope.
1 · to-prd	The conversation becomes a real PRD: user stories, acceptance criteria. Gate: you approve the PRD.
2 · to-issues	The PRD is sliced into vertical slices in dependency order. Gate: you approve the slicing.
3 · tech-lead	Each slice is implemented in TDD, one subagent per issue.
4 · qa	Green tests + the actual screen opened in a browser as evidence.
5 · guardrails-pr	A PreToolUse hook blocks secrets from reaching any commit, then opens the PR. Gate: you review the merge.

The design constraint that matters: the flow STOPS at those four gates and waits for explicit human approval. Nothing becomes code without a human having seen the plan. This is deliberately the opposite of the fully-autonomous-agent trend. I think the interesting engineering problem right now is deciding where the human belongs in the loop, not removing them from it.

The artifact I didn't expect to love: a living architecture map

Every team draws an architecture diagram once, pins it to a Miro board, and watches it rot. In this protocol, re-rendering the map is a phase, not a good intention. Every merged feature redraws an interactive HTML map that lives in the repo itself: files, screens, skills, subagents, MCP servers, hooks. Click a node, see the files responsible for it.

It became the most-used artifact of the whole system, including for onboarding humans.

The token economics surprised me

Here's the effect I didn't design for. Because the skills carry the reasoning (the interview script, the PRD format, the slicing convention, the QA checklist are all written down), the implementation model doesn't have to think about the process, only execute inside it. In practice that let me run Sonnet on medium effort where I previously used Opus on high effort, with comparable results on most features.

In my estimates that's up to ~70% fewer tokens per feature. To be clear about what that number is: my own estimate from my own usage comparing Sonnet-medium against Opus-high, not a formal benchmark. The bigger saving is less visible anyway: a feature specified before implementation doesn't get built twice.

If you take one thing from this post, take this: choose your model by how much of the reasoning is already written down, not by the task. Expensive models for genuine uncertainty (discovery, spec writing). Cheaper models for execution inside a written process.

Steal it

The methodology above is complete; you can implement it with plain skills in any setup. If you want the packaged version:

The free tier (the interview phase + PRD phase + conventions file) is open source: github.com/murilomn58/Claude-Spec-Driven-Fase-Zero. Install natively: /plugin marketplace add murilomn58/Claude-Spec-Driven-Fase-Zero then /plugin install adp-fase-zero@adp.
The full protocol (all six phases, the map, the secrets hook) is a paid plugin at claudespecdriven.com.br (R$47, about USD 9).

One honest caveat: I built this for Brazilian devs first, so the site and the plugin content are in Portuguese. The methodology isn't language-bound, and Claude follows PT-BR skills fine while responding in your language, but if that's a dealbreaker, the free repo plus this post gives you everything you need to build your own.