Strategist · Designer · Operator

Launch
with Ben

Claude Code

Working notes from daily Claude Code use: why it ignores CLAUDE.md, pre-commit hooks that block AI drift, skills vs scripts, and session habits.

Claude Code is my daily driver for building MVPs. Out of the box, it’s good. With custom skills, it’s what I actually need.

Skills are markdown files that teach Claude how to do specific jobs. Instead of re-explaining my workflow every conversation, I write it once and invoke it with a slash command. But skills alone aren’t enough. That’s why this pillar also covers AI Change Control, the pre-commit enforcement layer that catches the bugs skills and CLAUDE.md can’t.

This section covers the skills I use, how they chain together, how to build your own, and the enforcement layer that makes them load-bearing.

The skills I use

Code skills

/think: The pause button. Stops Claude from rushing into the first workable answer and forces evaluation of the real task, hidden assumptions, and alternative approaches. Now acts as the universal decision-point skill that other skills invoke automatically when things are ambiguous.

/audit: Structural quality scanner for app pages. Goes page by page checking purpose, classification, structural quality, consistency, and data logic. Rates each page as keep/cleanup/refactor/rebuild. Auto-routes into /think → /remediation or /todo based on findings.

/remediation: The structural fixer. Takes audit findings and executes proper rewrites: fix data sources first, extract shared primitives second, rebuild pages third. Validates its plan through /think, then hands execution to /todo instead of running steps manually.

/todo: The execution manager. Creates task files, tracks items one at a time, enforces the audit-before-coding rule, and verifies each item with /fix before moving on. The backbone that /remediation feeds into.

/fix: Verification, not just “does it work.” Proves the real affected path executes correctly, uses the right source of truth, and leaves behind code safe to keep as the standard. Routes back to /remediation if it uncovers structural problems.

/brainstorm: The second opinion, and the one rule that makes it worth anything: it has to come from a model that is not me. Sends a filled brief to Codex and Fable in parallel, blind to each other, and reports where they disagree rather than averaging them. AI Second Opinion: Why Your Own Agent Can’t Give One is the case where both of them rejected a decision I had already settled.

Content skills

/content-plan: Maps the content ecosystem before writing. Finds gaps, overlaps, parent/child relationships, and recommends what to write next. Always the starting point when you’re not sure what content needs attention.

/content-write: Writes one production-ready content file that fits its cluster. Reads nearby files first to avoid overlap. Hands off to /content-audit when done.

/content-audit: Quality judge. Evaluates role clarity, distinctiveness, usefulness, and cluster fit. Verdict: keep/refresh/rewrite/merge/delete. Routes to /content-refresh or /content-write based on severity.

/content-refresh: Surgical improvement. Preserves what works, fixes what doesn’t, without a blind rewrite. Used when the angle is right but execution is weak. Hands off to /content-audit for validation.

How they chain

The skills don’t work in isolation. They hand off to each other automatically.

Code flow:

/audit → /think → /remediation → /think → /todo → /fix → /audit (final)
  find     evaluate     plan          validate   track    verify    validate

Content flow:

/content-plan → /content-write → /content-audit → /content-refresh → /content-audit
    map            write            judge            improve           validate

/think is the bridge: available to any skill at any decision point. When things are ambiguous, skills route through /think before taking action.

Skills aren’t the only kind of shortcut, and picking the wrong kind creates mess. Skills vs scripts is the decision rule: automate judgment with a skill, automate a fixed sequence with a script, then gate the result with enforcement. And when a rule has to hold no matter what the model decides, it goes in a Claude Code hook, which is code the agent can’t talk its way past.

How to set up custom skills

Skills are markdown files in specific directories:

~/.claude/commands/          # Available in every project
<project>/.claude/commands/  # Available only in that project

Each .md file becomes a slash command. audit.md becomes /audit.

Anatomy of a skill

---
description: One-line summary of what this skill does
---

# /skill-name

What this skill does in one sentence.

## When to use

- Situation A
- Situation B

## Steps

1. Do this first
2. Then this
3. Then this

## Rules

- Always do X
- Never do Y

## Output format

[What the response should look like]

The description in frontmatter is what Claude uses to match your intent to the skill. Make it specific.

A real example: the /fix skill

---
description: Verify a code change by proving the real affected path works
---

# /fix

After making a change, prove it actually works.

## Steps

1. Name the change and the affected code path
2. Run the real route, test, or command — not a nearby one
3. Check logs for errors
4. Confirm the implementation uses the correct source of truth

## Rules

- Build passing is not proof. The real path must execute.
- If verification reveals a structural issue, stop and use /remediation instead.

## Output

VERIFIED: [what works, what was tested, proof]
or
NOT VERIFIED: [what failed, what to do next]

Short, direct, opinionated. That’s what works.

Making skills chain together

Skills get powerful when they hand off to each other automatically. Add explicit routing instructions:

## After this skill completes

| Result | Next action |
|--------|-------------|
| Found structural issues | Invoke `/remediation` |
| Found isolated bugs | Invoke `/todo` to track fixes |
| Everything clean | Stop |

Do not wait for the user to type the next command. Invoke it.

The key phrase is “invoke it,” not “recommend” or “suggest.” Claude follows direct instructions better than polite suggestions.

Making Claude actually use them

Claude sometimes sees /think in your message and just… responds with its own analysis instead of invoking the skill. Fix this by adding a rule to your CLAUDE.md:

# Skill Invocation Rule

These are skills that MUST be invoked via the Skill tool:
`/think`, `/audit`, `/fix`, `/todo`

When the user includes any of these anywhere in their message, invoke
it using the Skill tool before responding. Do not treat them as
conversational text. Do not skip the invocation.

This goes in your project or user-level CLAUDE.md. Without it, Claude will occasionally shortcut past your skills.

Tips from actual use

Keep skills opinionated. “Check if things look okay” is weak. “Rate each page as keep/cleanup/refactor/rebuild” is strong. The more specific the instruction, the more consistent the output.

Include anti-patterns. A “Never” section prevents Claude’s worst habits: over-explaining, scope creep, skipping verification.

Define the output format. If you don’t specify what the response looks like, you’ll get a different shape every time.

One skill, one job. A skill that audits AND fixes AND deploys will do all three poorly. Split them and let them chain.

Use a meta-skill. A /think skill that says “pause, evaluate, then route to the right skill” prevents Claude from rushing into the wrong workflow.

Why this matters

The difference between “AI that helps” and “AI that actually ships” is structure.

Without skills, every conversation starts from zero. You re-explain your workflow. You re-establish your standards. You re-catch Claude’s bad habits.

With skills, you encode what you’ve learned once. Then you benefit from it every time.

The chain that works:

/audit  →  /think  →  /remediation  →  /todo  →  /fix  →  /audit (final)
  find       evaluate     plan           track     verify     validate

You type /audit once and the whole pipeline runs.

Articles

Running it day to day

AI Change Control (a 4-part cluster + a GitHub repo):

More

Related: