I made Claude Code interview me before it writes any code

A few guardrails for agentic coding — starting with the one that catches the most expensive mistake.

Agentic coding has one failure mode that costs more than all the others combined: the agent confidently builds the wrong thing. Not buggy code — wrong code. It misread what you wanted, picked a default you'd never have chosen, made an architectural call you didn't notice, and by the time you catch it the thing is three files deep. Now you're either rewriting it or, worse, keeping it because tearing it out feels expensive.

I kept hitting this. The fix wasn't a better model or a longer prompt. It was a guardrail: don't let the work start until we actually agree on what it is.

So I built /grill-me.

What it does

/grill-me is a slash command for Claude Code. When I'm about to start something non-trivial, I run it — and instead of diving in, Claude interviews me, one question at a time:

• Each question comes with Claude's recommended answer and the trade-off behind it, so I'm reacting to a concrete proposal, not staring at a blank prompt.
• One question per turn. No wall of ten questions I'll half-answer.
• No plan gets written until I say "alignment complete."

That last rule is the whole point. The command is structurally forbidden from producing an implementation plan until I explicitly release it. It can't sprint ahead. It has to surface the decisions — the ambiguous requirement, the unspoken default, the fork in the architecture — and get a real answer out of me first.

The effect: all the expensive disagreements happen in cheap turns of conversation, before a single line of code exists. The drift, the rework, the "wait, that's not what I meant" — caught at the point where catching them costs a sentence instead of a rebuild.

Why one question at a time, each with a recommendation? A batch of questions gets shallow answers; a single sharp question with a proposed default gets a real decision. And the recommendation does double duty — it forces Claude to commit to a position, which drags its assumptions into the open where I can veto them, instead of burying them inside a plan.

It's a guardrail, not autopilot

/grill-me doesn't make the agent correct. It makes the misalignment visible early. It keeps you on the road; it doesn't drive the car.

And it's one guardrail, not a complete safety system. There are plenty of ways agentic coding goes sideways that this does nothing about — I'm not claiming completeness. I'm claiming this particular guardrail catches the single failure I paid for most often, and that a few well-placed guardrails beat a vague promise of safety.

They compose

Bonus: the guardrails stack.

/grill-me is an alignment gate — so I started putting it in front of other things. One setup I run: two sessions running /dialogue (a harness where two Claude sessions talk a problem through - e.g. my CFO agent and my Amazon-Operator) where one drives a structured /grill-me. The dialogue explores the solution space; the grilling forces the alignment. They reach a solution quality I never got from either alone.

I also use the grill-me discipline as the front end of a triage routine — before anything gets filed as a ticket, it has to survive the same "are we sure we understood this correctly?" interrogation. Fewer misread tickets, fewer wrong things built.

That's the pattern worth stealing even if you never touch my command: make alignment a gate, not a vibe.

The kit's status line — a cost/context cockpit, and one of the guards covered below.

The other guards

/grill-me lives in a small kit of these things, all the same philosophy — catch a specific failure at its cheapest point:

• /handover guards continuity. A session piles up context the next one can't see; /handover dumps that state to a file the next session picks up automatically. You stop losing the thread between sessions.
• The status line guards cost and context — it forecasts what your next turn will cost and warns you before an auto-compaction quietly drops half your context.
• The rca skill guards debugging: a falsifiable hypothesis and a disconfirming check before any fix, so you don't confidently repair the wrong cause. It right-sizes itself, too — a quick inline diagnosis for a cheap, reversible bug; a full documented root-cause analysis when the fix gates something expensive or irreversible (a migration, a data backfill, an auth change). The guard scales to the stakes instead of taxing every bug equally.

None of these is a complete answer to anything. Together they're a few guardrails for the failures I hit most.

It's a kit you can install

It's Florian's Claude Code Kit — pure Node, zero dependencies, on macOS, Linux, and Windows. The installer merges into your ~/.claude without clobbering anything you already have, and aborts before writing if it would collide:

git clone https://github.com/FlorinI/Florians-Claude-Code-Kit.git
cd Florians-Claude-Code-Kit
node install.mjs        # --dry-run to preview, uninstall to remove exactly what it added

Then run /grill-me before your next non-trivial task and let it interview you.

It's MIT, maintained best-effort in spare time. If a guardrail you wish existed is missing — and many are — the repo's open.

— Florian & Claude Code