# The reflex handbook — installable agent skills > Each skill below is a real artifact: a CLAUDE.md rule, slash command, SKILL.md, or prompt. To use: copy the artifact and paste it straight into your CLAUDE.md (or tell your agent to add it). Install once — the right thing runs itself. > > craftagent.cloud · 14 skills --- ## 1. Verify Before You Call It Done *A forcing function so the agent proves a fix instead of claiming it.* **Rule:** Don't ask the agent to be careful — install the gate so it *can't* skip the proof. ``` ## Verification — before reporting "done" Never report a change as done on inspection alone. First: 1. Run the real path — render the page / hit the endpoint / execute the command. 2. Paste the actual output here. Do not describe it; show it. 3. State the one observable signal that proves it works (a value, an exit code, a rendered element). A confident tone is not evidence. If the user says "still broken," re-diagnose from the observed output — do not re-apply the same fix on a new guess. ``` Source: https://craftagent.cloud/en/verify-by-running-it/ --- ## 2. Plan First, Then Code *A forcing function that makes the agent show its approach — and stop — before touching code.* **Rule:** The cheapest place to fix the wrong approach is *before* the first line of code. ``` ## Plan before non-trivial changes For any task beyond a one-line edit, before writing code: 1. State the approach: which files you will touch, the direction you will take, and why not the obvious alternatives. 2. Flag what you are unsure about or assuming. 3. STOP and wait for my go-ahead. Do not write code until I confirm. Skip this only for trivial, single-line changes. ``` Source: https://craftagent.cloud/en/plan-first-gate/ --- ## 3. Map the Blast Radius Before You Edit *A forcing function that makes the agent trace who depends on a symbol before it changes it.* **Rule:** A small edit to a shared symbol is not a small change — it is every caller's change. ``` ## Before editing shared code Before changing a function, type, signature, or config value that other code depends on: 1. List every caller or dependent of the symbol you are about to change. 2. State the blast radius: what breaks if the change is wrong, and how far it reaches. 3. If it touches a widely-used symbol or a public interface, say so and wait for my go-ahead before editing. Never change a shared signature with blind find-and-replace — trace the callers first, then edit. ``` Source: https://craftagent.cloud/en/check-impact-before-editing/ --- ## 4. If It's Deterministic, Don't Make It Guess *A forcing function that sends exact-answer work to a script instead of the model's reasoning.* **Rule:** The model should reason about what has no right answer — and run code for everything that does. ``` ## Deterministic work goes to code, not prose When a task has exactly one correct answer a script can compute — counting, parsing a fixed format, transforming data, math, lookups — write and run a script instead of producing the answer by hand. 1. If the input has a consistent structure, reach for a parser, regex, or query — not free-form reasoning. 2. Show the script and its real output, not just the final number. Reserve your reasoning for judgement, generation, and ambiguity — the work that has no single right answer. ``` Source: https://craftagent.cloud/en/script-the-deterministic-parts/ --- ## 5. Diagnose From the Symptom, Not the Guess *A prompt that forces a real diagnosis before a single line of fix.* **Rule:** A fix aimed at a guess is just the next bug — read the symptom before you touch the code. ``` Before proposing any fix, diagnose first: 1. Reproduce the symptom and paste the actual error or wrong output — the real text, not a paraphrase. 2. Trace it to a root cause. State the cause and the specific evidence that points to it. 3. Only then propose the smallest change that addresses that cause. If I say it's still broken, do not try a different patch — re-read the new output and re-diagnose. A second failed fix means the first diagnosis was wrong. ``` Source: https://craftagent.cloud/en/diagnose-from-the-symptom/ --- ## 6. Make It Argue Against Its Own Plan *A prompt that pressure-tests an approach before you commit a single line to it.* **Rule:** The approach that survives its own strongest counter-argument is the one worth building. ``` Before we build this, pressure-test the approach: 1. Restate the plan in two lines. 2. Argue against it: where is it most likely to break, what assumption is it leaning on, and what would make you abandon it? 3. Name one simpler alternative, and say why you would or wouldn't take it. Then give your honest recommendation. Don't defend the first idea — pick the approach most likely to survive the real problem. ``` Source: https://craftagent.cloud/en/argue-against-the-plan/ --- ## 7. Hand Off to Your Next Session *A slash command that turns a session into a note the next one can pick up cold.* **Rule:** A session that can't be picked up cold is a session you'll redo from memory. ``` --- description: Summarize this session into a handover note for the next one --- Write a concise handover note for whoever picks this up next — a fresh session, or someone else: - **Done**: what changed this session, in a line or two. - **State**: what works now, and what is half-finished. - **Next**: the single next action, concretely. - **Gotchas**: anything that will trip up the next session. Keep it short enough to read in thirty seconds. State, not narration — skip the thought process. ``` Source: https://craftagent.cloud/en/hand-off-your-session/ --- ## 8. A Review That Doesn't Rubber-Stamp *A reusable Skill that reviews a change for real problems instead of approving it by reflex.* **Rule:** A real review names what it checked — "looks good" names nothing. ``` --- name: review-changes description: Review a diff for real problems before it ships — no rubber-stamping --- Review the change across these dimensions, in order: 1. **Correctness** — does it do what it claims? Trace one real input through the new path. 2. **Edge cases** — empty, null, huge, the second call, concurrent access. Where does it fall at the edges? 3. **Blast radius** — what else calls this? What silently changes for them? 4. **Readability** — could the next person change it without you in the room? For each finding, report: `file:line` · severity (blocker / should-fix / nit) · why it matters · the smallest fix. If you find nothing, say what you checked and why you're confident. Never approve by default. ``` Source: https://craftagent.cloud/en/a-review-that-doesnt-rubber-stamp/ --- ## 9. Run to the gate, then stop — not step-by-step *A prompt that lets the agent run on its own but stop at the few places worth stopping — so you can let go without losing control.* **Rule:** Don't choose between watching every step and letting it run free — let the agent run to defined gates, then stop for approval. ``` Work through this task autonomously — don't ask me about routine steps. But treat these as hard stops: pause and wait for my go-ahead before each. - Before anything that writes, deletes, deploys, sends, or is otherwise hard to undo. - Before you move from one phase of the work to the next. - Whenever you hit a decision you're less than about 80% sure of. At each stop, give me three short lines — what you just did, what's next, and why — then wait. Everything between the gates, just do. ``` Source: https://craftagent.cloud/en/run-until-the-gate/ --- ## 10. A CLAUDE.md skeleton — turn a description into operating law *A minimal frame to paste into CLAUDE.md that tells the agent what to default to, when to stop and ask, and where the danger is.* **Rule:** CLAUDE.md isn't a README — write it as law the agent must follow, not an intro it can skim past. ``` # — CLAUDE.md ## What this is ## Conventions (follow these by default, without being told) - - ## Stop and ask — do not guess - When a requirement is ambiguous, ask before choosing. - Before any destructive or irreversible action. ## Danger zones (handle with extra care) - ## Before you say it's done - ``` Source: https://craftagent.cloud/en/a-claude-md-skeleton/ --- ## 11. The weekly review prompt — five minutes that turn experience into skill *Three questions a week to know whether you're getting better or just getting used to mediocre.* **Rule:** Without a feedback loop, experience doesn't become skill — five minutes a week, three questions, change one thing. ``` Weekly review (5 minutes). Answer three, one line each: 1. One thing that did NOT work with the agent this week — what, and why? 2. One thing that DID work — what made it work, so I can repeat it on purpose? 3. The single template, prompt, or rule I'll change because of (1) and (2). Keep it to three lines. This isn't a report — it's turning this week's experience into next week's skill. If nothing changes in line 3, the review didn't do its job. ``` Source: https://craftagent.cloud/en/the-weekly-review-prompt/ --- ## 12. Split the work into focused slices, each with clean context *A prompt that makes the agent break a big task into a few independent, checkable pieces — instead of cramming it all into one blind run.* **Rule:** Don't hand over one tangled block — make it split the work into a few clean slices, each with its own context, checkable on its own. ``` Before doing this, split it into focused slices I can check independently: 1. Break the task into 2-4 sub-tasks, each with a clear, separate goal. 2. For each slice, list ONLY the context it actually needs — don't carry the whole task into every piece. 3. Do them one at a time (or hand each to a fresh sub-agent), keeping each slice's context clean. 4. At the end, reconcile: show how the pieces fit together and flag any conflicts between them. Tell me the split first — the slices and what context each gets — and wait for my OK before you start. ``` Source: https://craftagent.cloud/en/split-into-focused-slices/ --- ## 13. Is this even worth an agent — ask before you open the chat *A pre-flight prompt that makes the agent sanity-check whether the task is worth handing over, instead of plowing into work a one-liner could do.* **Rule:** The first question isn't "how do I prompt this well" — it's "is this even worth an agent"; make it sanity-check before it works. ``` Before we start, sanity-check whether this is even worth handing to you: - Is it deterministic — one right answer every time? If so, a script or a fixed tool beats me. Say so. - Is it a quick one-off I could do by hand faster than writing this prompt? If so, say so. - Does it need judgment AND repeat often? That's where handing it to you actually pays off. If this task isn't a good fit for an agent, tell me plainly — don't just do it anyway. I'd rather hear "use a script for this" than spend the overhead and find out later. ``` Source: https://craftagent.cloud/en/is-this-worth-an-agent/ --- ## 14. Probe with a small task before you trust it in a new domain *A prompt that makes the agent do one small slice and show how it thinks — before you hand over the whole task in a field it hasn't proven itself in.* **Rule:** The same agent behaves differently by domain — probe a small slice and watch how it thinks before handing over the real task in new territory. ``` This is a new kind of task for you, so let's calibrate before I hand over the real thing: 1. I'll give you a small, representative slice first — do just that, not the whole task. 2. Show your work: not only the result, but how you reached it and where you were unsure. 3. Then stop and wait. I'll check whether your approach matches what this domain actually needs. Don't scale up to the full task until I've seen the small one and said go. A good result on a tiny slice — reached the right way — tells me how much to trust you on the big one. ``` Source: https://craftagent.cloud/en/probe-before-you-trust/ --- _craftagent.cloud_