Node.js is the runtime that Claude Code and the other tools run on. Think of it as the motor many developer tools share; you install it once and forget it. Installing it also gives you npm (a package manager, used below). Go to nodejs.org and click the big LTS download button — the "long-term support" installer for your operating system. Run it; the wizard's default answers are all fine.

In your terminal:

node --version

If it says command not found (or not recognized): close the terminal window and open a fresh one, then try again. Newly installed commands often only appear in new terminal sessions — remember this reassurance, it applies to every install in this chapter.

Git is the version-control tool that saves snapshots ("commits") of your code and lets agents work on separate copies. It's also your safety net: because every change is recorded, anything an agent does can be inspected and undone. The whole workflow assumes a git project. On Windows, download the Git for Windows installer from git-scm.com — the defaults are fine, and it also installs Git Bash, which a later step relies on. On a Mac, run xcode-select --install in the terminal and accept Apple's dialog, or use the installer from the same page.

In your terminal:

git --version

Claude Code signs in to Anthropic's service, which needs a paid plan or API credits (you pay per token — roughly, per chunk of text the model reads and writes). Create an account at claude.com. Expect a real cost: as of mid-2026, Claude Pro at roughly $20/month is the typical hobbyist tier, Claude Max at roughly $200/month covers heavy multi-agent use, and pay-per-token API credits are the alternative. Prices change — check the current pricing page before you pick.

Everything an agent does happens inside a project folder — one folder per project, with git recording every change inside it. The rest of this guide keeps saying "go to your project folder", so make it exist now:

In your terminal:

mkdir my-first-project
cd my-first-project
git init

cd ("change directory") moves your terminal into that folder — every command you type afterwards applies there. You'll type it every time you come back to the project; a handy trick is to type cd  (with a trailing space) and drag the folder from Finder or Explorer into the terminal window — its location gets pasted for you.

Claude Code is the harness — the terminal app that runs the agent. Install it globally with npm (from the prerequisites), then log in. "Globally" means the tool is installed once for your whole computer, not into one project — which is what you want for the tools you'll use everywhere.

In your terminal:

npm install -g @anthropic-ai/claude-code
claude   # first run walks you through login

The first claude run opens your browser so you can sign in to your account; after that, the terminal and the agent are connected. From then on, starting an agent is: open terminal, go to your project folder (cd my-first-project), type claude.

You are now juggling two different prompts, and mixing them up is the classic beginner tangle. The terminal prompt — a line ending in something like $ or > — is where commands like npm and git go. The Claude Code prompt — the bordered chat box that appears after you type claude — is where you talk to the agent in plain English and use slash-commands like /grill-me. Paste a terminal command into the chat box and the agent may run it — or just chat about it; paste /grill-me into PowerShell and you get an error. Every code block in this chapter is labelled with where it belongs.

If the terminal says command not found: claude, close the terminal window and open a fresh one — newly installed commands often only appear in new sessions.

Use pnpm as your project's package manager — the tool that fetches and installs the code libraries (dependencies) your project builds on. It's fast and strict: it refuses to let your project silently use a library nobody declared, a whole class of "works on my machine" bugs that agents are especially prone to introduce. This guide's rules assume it.

In your terminal:

npm install -g pnpm
pnpm --version

Using npm to install these global tools is fine — the "never npm" rule you'll set below is only about commands inside a project. Two package managers in one project create conflicting bookkeeping; that's the actual rule.

Matt Pocock's skills are the reusable instructions that teach the agent each part of this workflow — grilling, planning, TDD, review. Think of each as a recipe card the agent pulls out when you ask for that move by name, so you don't re-explain the method every session. Install them once; they work in every project. Follow the current command in the repo's README (at time of writing):

In your terminal (not in the Claude Code chat box):

npx @mattpocock/skills install

npx is npm's "run once without installing" command — it fetches the installer, runs it, and leaves nothing behind but the skills themselves.

AGENTS.md is standing instructions for coding agents — a "README for agents": build/test commands, house rules, environment quirks. It's the open, cross-tool convention that most agents read. Claude Code itself natively reads a different file, CLAUDE.md — so the setup that makes every tool happy is a pair: put your rules in AGENTS.md, and add a CLAUDE.md whose entire content is the single line @AGENTS.md. That line is an import — Claude Code follows it and pulls the shared file in, every other tool reads AGENTS.md directly, and the two can never drift apart. Keep the file tiny: the model has a limited instruction budget, so record only what it can't discover on its own. And do not run claude /init; it dumps a bloated file that rots.

File contents — AGENTS.md (in your project's top folder):

- Use pnpm, never npm.
- Type-check with `pnpm tsc --noEmit` before claiming a task is done.

File contents — CLAUDE.md (one line, nothing else):

@AGENTS.md

You haven't needed a code editor so far, and you don't need one now: the easiest way to create both files is to ask Claude Code itself — inside the chat, say "create AGENTS.md and CLAUDE.md in the project root with exactly these contents" and paste the two blocks above.

Now the second half of the step, and the more important one. Rules the model "should" follow in prose, it will sometimes ignore — not out of defiance, but because a model follows instructions statistically, not mechanically. To make a rule certain, back it with a hook — a script that fires automatically and blocks the wrong action every time. A hook isn't smarter than the model; it's dumber, and that's the point: it cannot be argued with, and it never has an off day. This one rejects npm inside the project. Before each shell command, Claude Code hands the script a small JSON description of the call; the script fishes out the command (using Node — already installed, no new tools), and if it's an npm install-family command, it prints the reason and exits with code 2, the exit code that means "block this and tell the agent why".

File contents — .claude/hooks/pre-bash.sh:

#!/bin/bash
# Blocks npm inside this project — the rule is "pnpm, never npm".
cmd=$(node -e 'const d=require("fs").readFileSync(0,"utf8");try{process.stdout.write(JSON.parse(d).tool_input.command||"")}catch(e){}')
if echo "$cmd" | grep -qE '\bnpm +(install|i|ci|add|exec)\b'; then
  echo "Blocked by hook: this project uses pnpm, never npm. Re-run the command with pnpm." >&2
  exit 2   # exit 2 blocks the tool call; Claude reads the message above
fi
exit 0

Registering it tells Claude Code to actually fire the script before every shell command:

File contents — .claude/settings.json (if the file already exists, merge the "hooks" part into it):

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/pre-bash.sh"
          }
        ]
      }
    ]
  }
}

In your terminal (from the project folder):

chmod +x .claude/hooks/pre-bash.sh

chmod +x marks the script as runnable — on Mac and Linux, a file needs that permission before the system will execute it (Windows has no such permission; skip this one command there). Then restart Claude Code (type /exit, then claude again): hook configuration is read at startup. On Windows, the script runs in Git Bash — Claude Code uses it for hooks automatically when it's installed, and the Git for Windows installer from Step 2 already put it there (no Git Bash? use WSL, or install Git for Windows).

Once you've seen the hook fire, delete the "Use pnpm, never npm" line from AGENTS.md — it was scaffolding. Section 12's doctrine is that every line in that file must earn its place in the instruction budget, and a rule a hook already guarantees earns nothing. This tiny hook is a preview of the whole discipline: Section 1 said to build machinery that doesn't rely on trust — this is the first piece of that machinery, and Sections 7, 9 and 12 build the bigger ones the same way.