Claude Code slash commands and skills for UK indie hackers: the six custom commands that turn the agent into your team

Most UK indie hackers use Claude Code like a very fast junior developer. They type the same instructions every session: "run the typecheck, then the tests, then commit with a conventional message." "Check this route handles the UK VAT edge case." "Write a changelog entry from the last five commits." It works, but it is repetitive, and repetition is exactly the thing the agent is supposed to remove.

Custom slash commands and skills are the fix. A slash command is a markdown file you drop into .claude/commands/ that becomes a /command you can fire on demand. A skill is a slightly richer version that the agent can also load automatically when your request matches. Together they turn a pile of repeated instructions into a small, version-controlled toolkit that ships with your repo.

This is the UK builder's guide to both. The difference between the two. The six commands a UK micro-SaaS founder actually reaches for. And the one rule that decides which jobs become commands and which become skills.

Slash commands: a markdown file is the whole thing

A custom slash command is the lowest-ceremony feature in Claude Code. Create a markdown file in .claude/commands/ in your project root, write a prompt inside it, and the filename becomes the command. .claude/commands/ship.md gives you /ship. That is the entire setup.

Here is a real one. Drop this in .claude/commands/ship.md:

Run the full pre-ship check for this UK micro-SaaS, in order:

1. `pnpm exec tsc --noEmit` — fix any type errors before continuing.
2. `pnpm test --run` — fix any failing tests before continuing.
3. `pnpm exec eslint . --max-warnings 0` — fix any lint errors.
4. Stage all changes and write a conventional-commit message
   summarising what changed. Use British English in the message.
5. Show me the commit message and the diff stat. Do NOT push.

If any step fails, stop and report — do not move to the next step.

Now /ship runs your entire pre-ship ritual. You stopped typing five instructions; you type seven characters. The file is committed to the repo, so the command travels with the project and survives a fresh clone on a new machine.

Where commands live, and scope

Two locations, and the distinction matters:

• .claude/commands/ in the project root — project-scoped. Committed to the repo, shared with anyone who clones it, only available inside that project.
• ~/.claude/commands/ in your home directory — personal. Available across every project on your machine, never committed anywhere.

The rule of thumb for a UK indie hacker: project-specific workflows (/ship with this project's exact test command) go in .claude/commands/; personal habits you want everywhere (/explain-like-im-tired at 23:00 on a Sunday) go in ~/.claude/commands/.

Arguments make commands reusable

A static prompt is useful. A parameterised one is properly reusable. Slash commands accept arguments: $ARGUMENTS captures everything you type after the command, and $1, $2 capture positional ones.

.claude/commands/new-route.md:

Create a new Next.js API route at app/api/$1/route.ts.

Requirements:
- Use the existing route handlers in app/api/ as the structural template.
- Validate the request body with Zod.
- Return GBP amounts as integers in pence, never floats.
- Add a corresponding test file.

Route name: $1

Now /new-route webhooks/stripe scaffolds app/api/webhooks/stripe/route.ts with your house style baked in. One command, infinite routes.

Skills: commands that the agent can reach for on its own

A skill is the next step up. Structurally it is a directory — .claude/skills/<name>/ — with a SKILL.md file inside. That file has a short YAML frontmatter (a name and a description) and a markdown body of instructions.

The frontmatter is what makes a skill different from a plain command. The description line tells Claude Code when the skill is relevant. So a skill gives you two things for the price of one: an explicit /name trigger you can fire by hand, and an automatic trigger — when your request matches the description, the agent loads the skill itself without you asking.

.claude/skills/uk-vat-check/SKILL.md:

---
name: uk-vat-check
description: >
  Use when adding or reviewing any pricing, checkout, invoice, or
  Stripe code that handles money for UK customers. Checks UK VAT
  handling, the GBP-in-pence convention, and the 90,000 GBP
  registration threshold logic.
---

When reviewing money-handling code for this UK micro-SaaS:

- All GBP amounts must be integers in pence. Flag any float.
- VAT is 20% standard rate. Confirm it is applied, not assumed
  baked into the price.
- If the code touches turnover totals, check the 90,000 GBP
  rolling-12-month VAT registration threshold is referenced.
- Stripe amounts are already in pence — confirm no double conversion.
- Invoices must show the VAT line separately.

Now two things happen. You can run /uk-vat-check explicitly when you want a money-code audit. And when you ask the agent to "add a pricing tier" or "wire up Stripe Checkout", it sees the description, recognises the match, and loads the skill on its own — so your VAT rules get applied even when you forgot to ask for them.

That auto-loading behaviour is the whole point. A slash command waits to be called. A skill is closer to a team member who knows when their expertise is needed.

The skills-vs-commands rule

In 2026, custom slash commands and skills share a file format, and skills are the recommended direction — but plain .claude/commands/ files still work and are still the right tool for some jobs. Here is the rule that decides:

Use a slash command when you always want to trigger it by hand. Use a skill when you want the agent to also reach for it automatically.

A /ship command should never fire on its own — shipping is a deliberate act. Leave it a command. A uk-vat-check should fire whenever money code is touched — make it a skill. A /changelog is deliberate. A security-review knowledge file should load whenever auth code is edited — make it a skill.

Job	Command or skill	Why
Run the pre-ship check	Command (/ship)	Always deliberate
Audit UK VAT handling	Skill (uk-vat-check)	Should auto-fire on money code
Write a changelog entry	Command (/changelog)	Always deliberate
Apply the house API-route style	Skill (api-route-style)	Should auto-fire on new routes
Generate a Stripe test fixture	Command (/stripe-test)	Always deliberate
Enforce the GBP-in-pence rule	Skill (gbp-pence)	Should auto-fire on money code

The split is roughly even. Deliberate, occasional jobs stay commands. Always-on expertise becomes skills.

The six that earn their keep for a UK micro-SaaS

A starting toolkit. Three commands, three skills, and you have removed most of the repetition from a solo UK build.

1. /ship (command) — the full typecheck-test-lint-commit ritual shown above. The single highest-frequency command for any indie hacker.
2. /changelog (command) — "Read the last $1 commits and write a user-facing changelog entry in British English, grouped by Added / Changed / Fixed." Turns release notes from a chore into a keystroke.
3. /stripe-test (command) — "Generate a Stripe test fixture for $1 using test-mode card numbers and GBP amounts in pence." Stops you hand-rolling test data every time you touch billing.
4. uk-vat-check (skill) — the money-code auditor above. Fires automatically whenever pricing or checkout code is touched.
5. api-route-style (skill) — "Use when creating any new API route. Enforces the house structure: Zod validation, GBP in pence, a matching test file, British English in error messages." Keeps a growing codebase consistent without you policing it.
6. pr-review (skill) — "Use before opening or merging a pull request. Checks the diff for leaked secrets, missing tests, and any console.log left in." The local complement to a CI review — see the Claude Code hooks guide for the guardrail layer that sits underneath this.

Six files. Maybe forty minutes to write them the first time. They then ship with the repo forever.

The one anti-pattern

Building a command for something you do twice a year. The value of a slash command is amortised over its use count — a /ship you run forty times a week pays for its five-minute setup in the first morning. A /quarterly-companies-house-filing-reminder you fire once every three months never pays back the cognitive cost of remembering it exists.

The simple test: if you cannot remember the command exists without checking the / menu, it should not be a command. Build commands for the things your hands already do on autopilot. Everything else is just a prompt you type when you need it.

Want a data-backed UK business idea every week? Free reports drop every Thursday — keyword volumes, SERP analysis, builder prompts. Browse the latest free report on IdeaStack.

---