Get Started
Build with Claude Code

Mission 1 of 7

Get Claude Code doing real work in your first hour.

Most people type something vague, get something vague back and call it hype. This hour fixes that, from install to your first shipped change.

60 minBeginnerClaude Pro ($20/month) or an API keyFree mission

What you'll do

Get it running

Install Claude Code and sign in, on Windows, Mac or Linux.

Learn the pattern

Read, propose, then write: three messages that turn 'meh' output into useful work.

Ship a real change

Make your first change to a real project, and review the diff before it touches disk.

  • The six commands you'll use every day, plus the keyboard moves nobody tells you about
  • A clear picture of what it's bad at, so you stop asking it to do those things
Before you start
  • A terminal. Windows: PowerShell or Windows Terminal. Mac: Terminal. Linux: anything
  • A Claude account (Pro or Max) or an Anthropic API key. Pro is the simplest
  • A project to work on. Any folder with code in it. No project? Step 3 gives you one
  • Git installed. If git --version fails, grab it from git-scm.com ↗ first
Your progress0/7
01/07Install it and sign in0 done
STEP 01 of 07~6 min

Install it and sign in

One command, one browser login, and you're in.

Everything else in this hour needs Claude Code on your machine, so you start by installing it. There are three ways to install. Pick the one for your machine and ignore the rest.

The native installer is the one Anthropic recommends now: it updates itself and doesn't need Node.

Windows

Open PowerShell and run this line:

PowerShell
irm https://claude.ai/install.ps1 | iex

Mac or Linux

Open your terminal and run this line:

Terminal
curl -fsSL https://claude.ai/install.sh | bash

With npm instead

Already have Node 18+ and prefer npm?This works everywhere:

Any terminal
npm install -g @anthropic-ai/claude-code

Start it and sign in

  1. Close the terminal, open a new one (so it picks up the new PATH), move into any project folder and start it:

    Any terminal
    cd path/to/your/project
    claude

    First run opens a browser tab to sign in. Choose Claude account if you pay for Pro or Max. Choose API key if you'd rather pay per use.

    Either way, when the terminal says it's ready, you're done.

    Tip
    Keep it updated. The native installer updates itself. With npm, run npm install -g @anthropic-ai/claude-code again every couple of weeks. The tool moves fast and old versions lose features.
Checkpoint
You see the Claude Code prompt in your terminal, inside your project folder, waiting for input.
If it breaksclaude is not recognised after installing + 2 more
claude is not recognised after installing
Open a new terminal window. The installer added it to your PATH, but the old window doesn't know yet. On Windows, if a fresh window still can't find it, sign out and back in.
The browser login loops or never completes
Copy the URL it printed and open it in the browser you're actually signed in to. Then paste the code back if it asks. Corporate VPNs sometimes block the callback: try off VPN once.
npm says EACCES or permission denied
Don't sudo it. Use the native installer above instead, which installs into your home folder.
Still stuck? Ask the community
STEP 02 of 07~10 min

Make it read before it writes

The single habit that separates people who get value from people who get noise.

You're signed in, so the temptation is to ask for something straight away. Don't. This step is the habit that makes everything after it work.

What goes wrong

Here's the mistake everyone makes in the first five minutes. They type 'add dark mode' into a project it has never seen, and it guesses.

It picks a CSS approach the project doesn't use, puts files in the wrong place, and now you're cleaning up. The tool isn't bad. You asked it to drive blindfolded.

What to do instead

So the first message in any new project is never a request. It's a reading assignment.

  1. Paste this:

    In Claude Code
    Read this project and tell me, in five bullet points, what it does, how it's structured, how I run it, and the two things you'd fix first. Don't change anything yet.

    Watch what it does. It lists files, opens the ones that matter (package.json, the entry point, the README, a config or two), and comes back with a summary.

  2. Read that summary properly. If it has misunderstood something, correct it now in one line: 'No, the API lives in /server, the /app folder is just the marketing site.' It remembers for the rest of the session.

    Two things you learn from this exchange. First, whether it actually understood your project, which tells you how much to trust the next answer. Second, the 'two things I'd fix first' are usually right, and they're a good first task.

    Tip
    You can point it at specific files with @. Type @ and start typing a filename and it autocompletes. Explain @src/lib/auth.ts to me like I'm new here is a great second message.
    Warning
    Don't paste secrets into the chat. It reads files itself. If a .env file holds real keys, it may read it while exploring. Keep real production keys out of the project folder, or add .env to the ignore list in step 5.
Checkpoint
You have a five-bullet summary of your project that you agree with, and it hasn't changed a single file.
Stuck? Ask the community
STEP 03 of 07~15 min

Ship one small change, properly

See the full loop once: propose, diff, write, test, commit. Everything after this is the same loop at bigger scale.

Now that you've had it read the project, you'll run the whole loop once on something small.

If you have no project

No project of your own? Make a throwaway one: run npx create-next-app@latest demo (pick the defaults), cd demo, git init && git add -A && git commit -m 'start', then claude. Any small Node or Python project works.

Give it a small task

  1. Give it a task that is small, specific and has a way to check it. This is the shape of every good request:

    In Claude Code
    Add a --version flag to the CLI. It should print the version from package.json and exit. Keep the change small, show me the diff before you write it, and tell me how to test it.

    Three things in that message do the work. Small: one flag, not a feature. Show me the diff before you write it: you review before it touches disk. Tell me how to test it: it has to think about verification, which makes the code better.

Review the diff

  1. When it proposes the edit, Claude Code shows you a diff and asks for permission. Read it.

    Press y to accept, n to reject, or type a correction ('use the existing readPkg helper instead of reading the file again').

    This permission step is the safety net. Later you'll loosen it for boring things like running tests, but for writing files, keep it on until you trust the project setup.

Test it and commit

  1. After it writes, run the test it suggested yourself. Then:

    Terminal
    git diff
    git add -A
    git commit -m "Add --version flag"

    Or just tell Claude Code 'commit this with a sensible message'. It writes good commit messages, and it won't commit without asking.

    Tip
    Hit Escape at any time to stop it mid-task. It stops cleanly, keeps what it's done so far, and waits. You're never stuck watching it go the wrong way.
Checkpoint
The change is committed, you ran the test, and you read every line of the diff before it was written.
If it breaksIt made a bigger change than I asked for + 2 more
It made a bigger change than I asked for
Say so: 'That's more than I asked for. Revert everything except the flag itself.' Then next time add 'change nothing else' to the request. It takes that literally.
It says it can't find package.json or the project seems empty
You started claude in the wrong folder. Type /exit, cd into the project root (where .git lives), and start again.
It asks permission for every tiny thing and it's slow
That's correct for now. Step 5 shows you how to allow safe commands (tests, linters, git status) permanently, so it only asks for the ones that matter.
Still stuck? Ask the community
STEP 04 of 07~10 min

The six commands and four keys you'll use every day

Stop fighting the interface so you can think about the work.

You've done the loop once. Now learn the small set of commands and keys that make it comfortable.

The six commands

Type / and a menu appears. There are dozens of commands. These six are the ones that matter in week one:

  • /init writes a CLAUDE.md file describing your project. It's the memory that survives between sessions. The next mission is entirely about getting this file right, so run it now and read what it produced.
  • /clear wipes the conversation. Do this between unrelated tasks. A long chat about the login page makes it worse at the billing page, because it's carrying all that context around.
  • /compact squeezes a long conversation into a summary when you want to keep going on the same task but the chat has got heavy. It'll do this itself when it has to; doing it on purpose at a natural pause is better.
  • /model switches between models. Sonnet for most work, Opus when the task is hard or the codebase is tangled. Opus costs more and thinks harder. Use it when you'd want a senior engineer.
  • /cost shows what this session has used. Check it at the end of your first day so the numbers stop being scary.
  • /help lists everything else. You'll find /review, /mcp and /permissions in there when you need them.

The four keys

And the keys:

  • Escape stops the current action. Escape twice opens a list of earlier points in the conversation you can jump back to, which rewinds the chat (not your files).
  • Shift+Tab cycles modes: normal, auto-accept edits, and plan mode, where it can read and think but not write. Plan mode is how you handle anything bigger than a bug fix. Mission 3 is about it.
  • ! at the start of a line runs a shell command directly: !npm test runs your tests and puts the output in the chat so it can see it.
  • # at the start of a line saves a note to memory: # Always use pnpm, never npm in this repo. It writes that into CLAUDE.md for you.
Tip
Paste an image with Ctrl+V (Cmd+V on Mac). Screenshot a broken layout or an error dialog and paste it in. It reads images. 'Make it look like this' with a screenshot of a design beats three paragraphs of description.
Checkpoint
You've run /init and read the CLAUDE.md it wrote, and you've tried Shift+Tab to see plan mode.
Stuck? Ask the community
STEP 05 of 07~9 min

Let it run the boring stuff without asking

Keep the safety net for edits and deletes, drop it for tests and reads, and the whole thing gets twice as fast.

In step 3 the permission prompt was your safety net. Here you keep it where it matters and switch it off where it only slows you down.

Every time it wants to run a command or write a file it asks. For rm -rf that's exactly right. For npm test it's a tax.

The fix is a small settings file in your project that says which commands are always fine.

Write the settings file

Run /permissions inside Claude Code and you get a menu to allow or deny tools.

  1. Create the file directly, which is clearer and lives in git so your whole team gets it:

    .claude/settings.json
    {
      "permissions": {
        "allow": [
          "Bash(npm test:*)",
          "Bash(npm run lint:*)",
          "Bash(npm run build:*)",
          "Bash(git status:*)",
          "Bash(git diff:*)",
          "Bash(git log:*)",
          "Read(**)"
        ],
        "deny": [
          "Read(./.env)",
          "Read(./.env.*)",
          "Bash(rm -rf:*)",
          "Bash(git push --force:*)"
        ]
      }
    }

What it says

Read it as a list of 'always yes' and 'always no'. Tests, lint, build and read-only git commands never prompt again.

Your .env files are invisible to it, so there's no way for a key to end up in a chat. Force pushes and recursive deletes are blocked outright, even if you ask for them by accident.

Everything not on either list still asks, which is what you want: writes, installs, anything that touches the network.

Tip
There's a personal version at ~/.claude/settings.json that applies to every project on your machine. Put your universal 'never' list there (force push, rm -rf, reading .env) so a new project is safe from minute one.
Warning
You'll see people recommend --dangerously-skip-permissions. It does what it says. Don't use it on your own machine with your own files. If you want hands-off runs, mission 5 shows you how to do it safely in a container or a throwaway branch.
Checkpoint
npm test (or your project's test command) runs without a permission prompt, and asking it to read .env gets refused.
Stuck? Ask the community
STEP 06 of 07~6 min

Know what it's bad at, so you stop asking

The fastest way to get good results is to stop requesting the things that reliably go wrong.

You've got the basics. This step is about what to avoid asking for.

After a week with it, everyone hits the same walls. Here they are in advance, with the workaround for each.

  • Vague goals. 'Make it better' produces a random walk. Give it a target: a failing test, a screenshot, a sentence a user would say. If you can't describe done, it can't get there.
  • Huge single requests. 'Build the whole dashboard' produces a plausible-looking mess. Split it: data layer, then one component, then the next. Plan mode (mission 3) does this splitting for you.
  • Things it can't see. It can't click around your running app unless you give it a browser (mission 4). It can't see your production database. It works on what's in front of it. Put the error log in front of it, not a description of the error.
  • Fresh-off-the-press libraries. If a package shipped last month, its knowledge may be a version behind. Paste the docs page or a link, or say 'check the installed version in node_modules before you use it'.
  • Pretending it ran tests. Sometimes it says 'tests pass' without having run them. Allow the test command (step 5) and say 'run the tests and paste the output'. Output is proof. A sentence isn't.
  • Long chats. Quality drops as the conversation grows. /clear between tasks. Treat each task as a fresh hire who has read CLAUDE.md.

None of these are reasons to not use it. They're the rules of the tool, the way a car needs fuel. Once you work inside them, it's a different experience to the one people complain about online.

Checkpoint
You can name three of the six and say what you'll do instead.
Stuck? Ask the community
STEP 07 of 07~4 min

Next: teach it your project once, properly

Everything in this hour gets better when CLAUDE.md is good. That's the next mission.

Right now, every new session starts from the /init file you generated, which is a decent sketch.

The difference between a sketch and a real CLAUDE.md is the difference between a contractor on day one and one who has worked with you for a month. The next mission is a 50 minute rebuild of that file: what goes in, what stays out, and the three lines that stop it making the same mistake twice.

Before you go, do one more real task today on your own project, start to finish, using the read, propose, diff, test loop. The loop is the skill. The commands are just buttons.

Checkpoint
You've shipped a second small change on your own, and you've opened the CLAUDE.md mission.
Stuck? Ask the community

Your first wins

It works. Now do something with it.

Get a map of a project you've never seen

Clone any open source repo you're curious about, start Claude Code inside it and paste:

Prompt
I've never seen this codebase. Give me a tour: the entry point, how a request flows through it, where the business logic lives, where I'd add a new feature, and one thing that looks fragile. Use file paths. Don't change anything.

Turn a bug report into a fix

Paste a real error message or stack trace (from your terminal, logs or a user) and ask:

Prompt
Here is an error from production: [paste it]. Find the cause in this codebase, explain it in two sentences, propose the smallest fix, show me the diff, and write a test that would have caught it.

Undo it cleanly

How to remove everything this mission installed.

Claude Code itself comes out in one of two ways, depending on how you installed it.

  • Native install: delete the ~/.claude folder (home directory) and the claude binary from ~/.local/bin (Mac/Linux) or %USERPROFILE%\.local\bin (Windows).
  • npm install: npm uninstall -g @anthropic-ai/claude-code.

Project files it created: CLAUDE.md and .claude/settings.json are plain text in your repo. Delete them or git checkout them away. Nothing else was changed unless you accepted a diff.

Next mission · Build with Claude CodeWrite a CLAUDE.md that makes every session start like day thirty
→