# Prompts

Twenty prompts to copy into Claude Code, grouped by job, each with a line on when to use it.

Swap anything in [square brackets] for your own details. Read what Claude Code says back before you say yes to it. Never paste a key or password into a prompt. Where a step needs one, the prompt tells Claude Code to let you put it somewhere safe yourself.

## Getting set up

**1. First run in a new folder.** Use this the first time you open Claude Code in a project.

```text
I'm a complete beginner. This folder is for [one line about the project].
Look at what's here, then draft a CLAUDE.md that says
what the project is, how I like to work, and what you must never do without
asking me (delete files, spend money, put secrets in code).
Show me the draft and explain each line in plain English before you save it.
```

**2. Explain it to me.** Use this when Claude Code uses a word you don't know.

```text
Explain [term] in plain English, with one example from this project.
Assume I've never done this before. Keep it under 150 words.
```

**3. Tell me what you're about to do.** Use this for the first week, until you trust what it does.

```text
For the rest of this session, before you run any command or change any file,
tell me in one sentence what it does and why. Then wait for me to say yes.
```

## Interview me before you build

**4. The interview.** Use this when you have an idea but it's vague.

```text
I want to build [rough idea]. Don't write any code yet.
Interview me, one question at a time, until you know:
who it's for, what problem it solves, what the smallest useful version is,
and what I do not want in it. Wait for my answer before the next question.
When you've got enough, write it up as a one-page brief in BRIEF.md.
```

**5. Challenge my idea.** Use this when you're excited and need someone to push back.

```text
Here's my idea: [idea]. Argue against it. What's the weakest part?
Who already does this? What would make a person not use it?
Then tell me the smallest version that would still be worth building.
```

## Plan it

**6. Plan first.** Use this in plan mode before any build.

```text
Read BRIEF.md and plan the build. Use this shape: goal in one sentence,
who it's for, what done looks like, what's out of scope, numbered steps small
enough to finish in an hour each, how I'll check each step, and what could go
wrong. Don't build anything. Ask me if anything in the brief is unclear.
When I approve the plan, save it as PLAN.md.
```

**7. Second opinion on the plan.** Use this in a fresh session, or in a different AI, before you build.

```text
You haven't seen this project before. Read PLAN.md and try to find what's wrong
with it. Look for missing steps, steps in the wrong order, things that will cost
money, security gaps and anything too big for a first version. List the problems
from worst to least bad. Don't rewrite the plan.
```

## Build it in small steps

**8. Build one step.** Use this for every step of the plan.

```text
Do step [number] of PLAN.md and nothing else. When you're done, tell me what you
changed, how to see it working, and what you checked. Don't start the next step.
```

**9. Stop the creep.** Use this when Claude suggests extra features.

```text
That's outside the plan. Add it to a file called LATER.md as one line, and carry
on with the current step. We only look at LATER.md once the first version works.
```

**10. Save my progress.** Use this at the end of each work session.

```text
Add today's entry to BUILD-LOG.md: what we did, what broke, what we fixed, how
long it took, and the next step. Keep it short. Then tell me how to save the
project with git, and do it once I say yes.
```

## Check it

**11. Run the checks.** Use this when a step says it's finished.

```text
Check what you just built. Run any tests that exist, and write a few simple ones
for the new code if there aren't any. Then tell me exactly what you ran, what
passed, what failed, and what you did not check.
```

**12. Phone view.** Use this on any page or site before you share it.

```text
Check the page at phone width (about 375 pixels). If you can't open a browser,
read the code and tell me what to look at on my own phone. Look for text that
runs off the edge, buttons too small to tap, images that are too big, and
anything you have to scroll sideways to see. Fix what you find and show me
what changed.
```

**13. No secrets in the code.** Use this before you save to GitHub or put anything live.

```text
Search this whole project, including old files, for anything that looks like a
key, password or private address. Don't open .env files to do it. Tell me what
you found and where.
Move any real secret out of the code into a .env file that's listed in
.gitignore, and update the code to read it from there. Do not print the values.
If one was already saved to git, tell me, because it needs replacing.
```

## Fix a bug

**14. Fix it properly.** Use this when something breaks.

```text
Something's wrong: [what you expected] but [what happened]. Here's the exact
error, if there is one: [paste it, with any keys removed].
Don't change anything yet. Find the cause first: read the relevant files and
tell me what you think is wrong and how you know. Then fix that one thing and
show me how to check it's fixed.
```

## Put it live on Cloudflare

**15. Deploy a page.** Use this when your site works on your computer.

```text
Help me put this folder live on Cloudflare for free. It's a static site.
Explain each step before you run it. If you need me to log in to Cloudflare,
tell me what to do and let me do it. Don't ask me to paste any keys here,
and ask me before anything that would cost money.
When it's live, give me the address and tell me what to check on my phone.
```

## Research a market or niche

**16. Research before you build.** Use this to find out if the idea is worth building.

```text
I'm thinking of building [thing] for [who]. Research it. Who already sells
something like it, what do they charge, what do their customers complain about,
and what's missing? Keep a list of the pages you used, with links, and say
which points you're unsure about. Write it up in RESEARCH.md. Don't guess.
```

## Brief a subagent

**17. Hand off a job.** Use this to give one job to a helper with a fresh view.

```text
Start a subagent for one job: [the job]. Give it only what it needs: the goal,
the files to read ([list them]), what done looks like, and what it must not
touch. Ask it to report back in under 200 words, including anything it wasn't
sure about. Show me the brief you give it first.
```

## Make a skill

**18. Turn it into a skill.** Use this after you've done the same job twice.

```text
We've done [the job] the same way twice. Turn what we did into a skill: a folder
with a SKILL.md that has a short description of when to use it, then the steps,
then how to check it worked. Keep it under one page. Show it to me before
you save it.
```

## Review my work

**19. Try to break it.** Use this in a fresh session when a build is finished.

```text
You didn't build this. Your job is to break it. Read the project and look for
bugs, missing checks, anything that would fail on a phone, anything that
could leak a secret, and anything the plan said it would do that it doesn't.
For each problem, show me how to reproduce it, or write a test that fails
because of it. List them from worst to least bad. Don't fix anything yet.
```

**20. Fix the list.** Use this right after prompt 19.

```text
Here's the list of problems: [paste it]. Fix them one at a time, worst first.
After each fix, run the check that proved it and tell me whether it now passes.
Stop and ask me if a fix would change what the project does.
```

**Next:** [30 days](../plans/30-days.md)
