
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.
What you'll do
Install Claude Code and sign in, on Windows, Mac or Linux.
Read, propose, then write: three messages that turn 'meh' output into useful work.
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
- 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 --versionfails, grab it from git-scm.com ↗ first
Your progress0/7
- 01Install it and sign in6 min
- 02Make it read before it writes10 min
- 03Ship one small change, properly15 min
- 04The six commands and four keys you'll use every day10 min
- 05Let it run the boring stuff without asking9 min
- 06Know what it's bad at, so you stop asking6 min
- 07Next: teach it your project once, properly4 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:
irm https://claude.ai/install.ps1 | iexMac or Linux
Open your terminal and run this line:
curl -fsSL https://claude.ai/install.sh | bashWith npm instead
Already have Node 18+ and prefer npm?This works everywhere:
npm install -g @anthropic-ai/claude-codeStart it and sign in
Close the terminal, open a new one (so it picks up the new PATH), move into any project folder and start it:
Any terminalcd path/to/your/project claudeFirst 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.
TipKeep it updated. The native installer updates itself. With npm, runnpm install -g @anthropic-ai/claude-codeagain every couple of weeks. The tool moves fast and old versions lose features.
If it breaksclaude is not recognised after installing + 2 more
claude is not recognised after installing
The browser login loops or never completes
npm says EACCES or permission denied
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.
Paste this:
In Claude CodeRead 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.
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.
TipYou 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 hereis a great second message.WarningDon't paste secrets into the chat. It reads files itself. If a.envfile holds real keys, it may read it while exploring. Keep real production keys out of the project folder, or add.envto the ignore list in step 5.
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
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 CodeAdd 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
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
readPkghelper 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
After it writes, run the test it suggested yourself. Then:
Terminalgit 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.
TipHit 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.
If it breaksIt made a bigger change than I asked for + 2 more
It made a bigger change than I asked for
It says it can't find package.json or the project seems empty
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
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:
/initwrites aCLAUDE.mdfile 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./clearwipes 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./compactsqueezes 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./modelswitches 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./costshows what this session has used. Check it at the end of your first day so the numbers stop being scary./helplists everything else. You'll find/review,/mcpand/permissionsin 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 testruns 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.
/init and read the CLAUDE.md it wrote, and you've tried Shift+Tab to see plan mode.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.
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.
~/.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.--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.npm test (or your project's test command) runs without a permission prompt, and asking it to read .env gets refused.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.
/clearbetween 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.
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.
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:
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:
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
~/.claudefolder (home directory) and theclaudebinary 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.