New to Claude Code? Start here

Published 30/10/2026

A crash course for people who have never driven a coding agent. Half an hour of reading here saves days of trial and error later, and a good share of your plan's usage.

You don't need to know git, GitHub or how agents work to follow it. Each idea comes with the one thing you need to do about it.

The words you'll keep hearing#

Think of hiring a very fast contractor who forgets everything each morning.

The last column is the whole problem in miniature: the contractor is brilliant, but anything that lives only in their head is gone tomorrow. Everything below is about writing things down in the right place.

Get set up#

1. A terminal. macOS: Terminal. Windows: Windows Terminal (PowerShell). Linux: whatever came with it.
2. git. Check with git --version. If it's missing, install it from git-scm.com. Git is the undo button for everything an agent does, so don't skip it.
3. Claude Code. Install it from the official setup page, then run claude once and sign in with your plan.

4. A project folder. Make one, turn it into a repository and start a session in it:

   SHCOPY

    mkdir my-project && cd my-project
    git init
    claude

5. Ask for the door note. In the session, type /init. Claude Code reads the project and writes a starter CLAUDE.md. Keep it short: the commands that build and test the project, and the rules it must never break.

Your first session#

• Just ask. Describe what you want in plain words. Name the outcome, not the steps: "add a page that lists saved recipes, with a test" beats "open app.py and…".
• Point at files with @, as in @src/app.py, instead of pasting them.
• Plan before building. Press Shift+Tab to cycle permission modes. In plan mode Claude Code reads and proposes but changes nothing. Read the plan, correct it, then let it build. A wrong plan caught here costs a few hundred tokens; caught after the build it costs the build.
• Permission modes. The default asks before anything touches your machine. Accept-edits lets it change files without asking but still asks before commands. Start with the default until you trust what it does.
• Stop it. Esc interrupts. Esc, Esc opens the rewind menu, which can roll back the conversation, the code, or both.
• Save your progress. When something works, ask it to commit, or run git add -A && git commit -m "what changed" yourself. Small commits are cheap undo points.

The commands you'll actually use#

The full list, with keyboard shortcuts, is on Anthropic's Claude Code cheatsheet.

Why it goes wrong after the first hour#

The first session usually feels like magic. The trouble starts on day two, and it is nearly always one of these.

• The session got long. Every turn re-sends the whole conversation, so a long session costs more per message and the model pays less attention to its middle. Clear between jobs; see when to fork, compact or clear.
• Compaction forgot something. Anything you only said in chat can be summarised away. If it must survive, it goes in a file. See long-horizon context management.
• The new session started cold. It doesn't know what yesterday's session decided. You end up re-explaining, and re-explaining is usage spent on standing still. See handovers.
• CLAUDE.md grew into an essay. It is read every session, so every line costs every time. Keep it to what is true for the whole project; see CLAUDE.md and AGENTS.md.
• "Done" wasn't done. An agent will say a task is finished when it believes it is. Give every task a line that can be checked, and have it show you the check: the page loads, the figure comes out right, the log line appears, a test passes.
• The tests became the problem. "Write a test for everything" sounds safe, and it is how projects drown. A test that pins today's exact output breaks on every harmless change, and the agent spends your usage fixing tests instead of the project. Keep a test only for something that must stay true for good: dates are always dd/mm/yyyy, not "the date is 30/10/2026". Prove everything else once, when it's done, and move on.
• The same thing got built twice. An agent that doesn't know a helper exists writes a new one, slightly different. A month later there are three ways to format a price, and a fix to one misses the other two.

Habits that save usage#

1. One job per session, /clear between jobs.
2. Plan mode first for anything bigger than a small fix.
3. Write the finish line before you start: "done when …", and say how it will be shown.
4. Look before you build: ask the agent to search for an existing function before writing a new one, and, when it writes something new, whether it should be a shared helper.
5. Tests only for what must stay true; a test that pins today's output is a tripwire.
6. Commit after every working step.
7. Decisions go in files, not chat.
8. Check /usage before a big job, not after.

Or have it set up for you#

Everything on this page can be done by hand, and it is worth understanding either way. Atlas ADE is these habits, already wired together, so you can spend your usage on the project instead of on the setup:

One command sets it up in a new or existing project. Try the loop without installing anything on the demo, or start with the quickstart.