It picks new colors. It tweaks the spacing. It swaps the font. It runs the build. Thirty minutes pass.

You open the page.

It’s not what you were thinking. It’s not pretty. It’s still ugly.

You blame Claude Code for “not understanding what you wanted.”

It understood the words. The problem was: you didn’t.

Claude Code is fast enough to ship code in minutes. The bottleneck is no longer typing. It’s the prompt you typed in.

If your prompt is fuzzy, your diff is fuzzy. The skill that fixes this is called clarify.

clarify is a Claude Code skill that enforces one rule: no plan, no scaffold, no code, until the ask is observable, named, and unambiguous.

It runs before any other skill. If your prompt fails its three-question test, clarify refuses to hand off to a planner. It writes a Dissolution Note and stops.

The point isn’t the skill. The point is the gate.

clarify converts fuzzy engineering asks into asks Claude Code can act on. Six examples from my actual queue:

• “Refactor the auth middleware” becomes “extract auth from routes.go so the existing 4 routes can each be unit-tested without a real session.”
• “Make the build faster” becomes “CI on main finishes in under 8 minutes for the next 10 consecutive runs.”
• “Clean up the database layer” becomes “the 23 raw SQL strings in repo/ move to typed query builders, no test regressions.”
• “Add caching” becomes “GET /products/:id returns from Redis when warm; p95 of the endpoint drops from 240ms to under 50ms in load tests.”
• “Modernize the frontend” becomes “the 14 class components in src/views/ become hooks-based functional components, no failing tests, bundle stays under 200kb.”
• “Improve error handling” becomes “every catch in api/ either rethrows with context or returns a typed error — no naked catch (e) {} blocks remain.”

Each rewrite turns a feeling into a diff Claude Code can produce and you can verify.

If your ask cannot be rewritten this way, do not run any planning skill. Do not type any prompt. Go back to your editor and rewrite the ask. Or back to whoever asked you, and rewrite together.

clarify works because it cuts the path between vague intent and shipped code.

The default Claude Code workflow looks like: prompt → plan → scaffold → diff → PR. Each step compounds the input. A fuzzy prompt becomes a fuzzy plan, which becomes a confidently-typed scaffold, which becomes a 400-line diff that looks like progress but isn’t tied to any verifiable outcome.

clarify breaks the chain at step zero.

When you invoke it, it scans your prompt for three things. Undefined words (“better”, “cleaner”, “modern”). Unverified assumptions (“it’s slow because of the DB”). Missing names (“the team wants this”). If it finds any, it stops the chain and asks you to fix the prompt before any other skill runs.

Claude Code never spends compute on a question you can’t answer. You stop accumulating diffs that you can’t verify. The PRs you ship correspond to specific things you actually wanted.

The mechanism is structural, not intelligent. clarify isn’t smart. It’s just a gate. The gate is the IP.

If you’ve ever shipped a refactor you couldn’t explain a week later, you didn’t have a Claude Code problem. You had a question problem. clarify makes the question expensive enough that you do the work upstream — when it costs you 5 minutes, not 3 days.

Hat tip to Elon Musk’s Algorithm, where step one is “question every requirement — and every requirement must come from a name, not a department.” And to Jesse Vincent’s brainstorming skill, which pioneered the hard-gate pattern (refusing to plan until alignment is reached). clarify combines the two specifically for the moment Claude Code is about to write code.

Once clarify is automatic, three extensions emerge.

• Run it on your own commits before review. Take any PR description from your last week. If it doesn’t pass clarify’s three-question test, the PR did something you couldn’t define. Worth noticing.
• Run it on tickets before estimation. Sprint planning gets wildly more accurate when you refuse to estimate any ticket whose acceptance criteria don’t survive the gate. The team protests for one sprint. Then they don’t.
• Run it in your head before the first prompt. The fastest version of clarify is a 90-second pause before the first prompt of a coding session, asking what specifically you’d see if the session went well.

The skill is here: github.com/richlin/clarify.

It doesn’t write your code. It refuses to write your code until the ask is shaped enough for code to be the right next move.

When you let Claude Code run on vibes, you ship vibes. When you make it run on observables, you ship something a third party can verify.

Reminder to self: if you can’t say what done looks like, Claude Code can’t either.

What’s a prompt sitting in your draft pane right now that wouldn’t survive clarify?