Claude Code for beginners: your first session, without detours

By Marco Kohns, Co-founder of ENLIX, lecturer in AI and growth

· 12 min read

A first session is four moves: change into the project directory, start claude, ask a question that changes nothing, and then commission exactly one small change. What goes wrong is almost always the same thing, and it has nothing to do with not knowing how to code: the request is drawn too wide, and there is no command Claude can use to check its own result.

Getting-started guides are good at describing the installation. They are strikingly bad at naming the points where the first hour tips over. So below are the five stumbling points we keep seeing in our own operation, each with the sentence that prevents it.

How does a first session with Claude Code go?

In five steps, the first two of which change nothing. Anthropic's quickstart sets the order: change into the project directory, start claude, sign in, ask a question about the project, and only then commission a first small change.

cd /path/to/your/project
claude

On first start Claude walks you through signing in through the browser. After that the prompt appears, with the version, the model and the working directory shown above it. If that is not the directory you expected, end the session and start it again in the right folder: the working directory decides which files are in reach at all.

The first question should change nothing. The quickstart suggests phrasings like what does this project do? or where is the main entry point?. Two things get settled at once: whether Claude reads your project correctly, and what an answer looks like before you have to judge a change. You do not have to attach files for that; the documentation states explicitly that Claude reads the project files as needed.

Only then comes the first change, and it is deliberately small. The quickstart uses a single function as its example. What makes a good first task is further down.

What goes wrong most often in a first session?

Five things, and four of them are closed by one sentence each in the request. The order below is the order they show up in the conversation.

Stumbling pointHow you noticeThe sentence that closes it
Request drawn too wideClaude edits more files than you meant"Change only src/x.ts, nothing else."
No definition of doneYou have to rebuild the result yourself to judge it"It is done when npm test passes."
No check commandClaude reports done, and it is not done"Then run npm test and show me the output."
Stepped in too lateThe answer is long and misses the targetEsc in the first minute, not after the answer
A third correction instead of a restartEach round gets worse rather than better/clear and one new, better request

The fifth one is the most expensive, because it does not feel like a mistake. Correcting twice feels like progress. Anthropic describes the opposite in its best practices: a third correction attaches itself to a conversation that already contains two failed attempts, and Claude re-reads them on every further turn.

The same first task, once without and once with a check command

Step that sits with you

No check command in the request

  1. describe the task
  2. Claude edits files
  3. Claude reports done
  4. you read the diff
  5. you run the check yourself
  6. you describe what is wrong
  7. Claude patches it
  8. you check again

4 of 8 steps sit with you

Check command in the request

  1. describe the task and name the check
  2. Claude edits files
  3. Claude runs the check
  4. Claude patches until it passes
  5. you read the diff

1 of 5 steps sit with you

The same task, two requests. The difference is one sentence: the command Claude measures its own result against.

Why does Claude say "done" when it is not done?

Because it had nothing to check that against. Anthropic names this case in its best practices as one of three reasons a session goes differently than expected: Claude said it was done and it wasn't quite, usually because it had no way to check its own work. The remedy is in the same document and it is unspectacular: give Claude a command that has to pass.

That sounds like a job for large projects, but it is cheap precisely at the start. In this repository, the one the page you are reading comes from, the check is two commands. How long they took today is below.

What one check costs in this repository

Test run (npx vitest run)1.1 sProduction build (npm run build)37 s

Measured on 28 October 2026 in the same run that published this article. The test run covers 240 tests across 9 files; the build additionally checks every route on the site. With no build cache in place, the first build of the same day took 55 seconds.

What one check costs in this repository
Test run (npx vitest run)1.1 s
Production build (npm run build)37 s

Just over a second for 240 tests is the reason the test command sits in our project file rather than in a wiki: it is cheap enough that Claude can run it after every change without anyone minding. The build costs a little over half a minute, so it runs at the end.

If your project has no such command yet, that is the most worthwhile task of the first week. Until then a smaller stand-in does the job: your language's type checker, a single test run, or simply the command that starts your program. What matters is that it is a command with an unambiguous output, and not a sentence like "check that again".

How do you word the first task so it runs end to end?

With three pieces of information: where, what, and how you will know it is done. The quickstart demonstrates the difference with an example. Instead of fix the bug it reads: fix the login bug where users see a blank screen after entering wrong credentials.

Applied to a first task of your own, that looks like this:

In src/components/Header.tsx: the "Contact" menu item is missing on
screens under 640 pixels wide. Add it to the mobile navigation in
the same position as in the desktop navigation.
Do not change any other files.
It is done when npm test passes.

Four lines, four jobs. The first names the file and saves Claude the search. The second describes the symptom rather than the cause you suspect. The third draws the boundary, and the fourth gives the check command. The documentation additionally recommends breaking larger pieces of work into numbered steps rather than commissioning them in one sentence.

A warning about the second line: describe what you see, not what you believe the cause to be. A suspected cause in the request cuts the search short before it starts, and that is the most common reason a correctly executed task still produces the wrong result. How a request is built that holds up on larger work is in prompt engineering, and you can click the four-block structure from it together in the prompt generator.

When do you press Esc, and when /clear?

Esc in the first minute, /clear after the second failed correction. Anthropic puts the first half as an instruction in its best practices: Watch the first minute, press Esc the moment Claude drifts.

For a beginner this is the least intuitive rule of the whole entry, because it runs against the reflex to wait politely. An answer that goes the wrong way in its third line does not get better by its thirtieth, and every further line of it then sits in the conversation history.

The second half is the abort. Two corrections are one attempt. After the second, the right move is /clear plus a new request that folds in what you have since learned. The history does not vanish: /clear only starts a new context, and the old session is still reachable through claude -r.

Three keys you need on day one, none of which appears in the prompt:

KeyWhat it does
Escinterrupts Claude immediately, the history stays
↑brings back the previous request, to sharpen it
Shift+Tabswitches the session's permission mode

What may Claude do without asking in a first session?

That depends on the permission mode, and the default is more generous than most getting-started guides describe. According to the permission modes documentation, the built-in default for interactive terminal and VS Code sessions from version 2.1.283 onwards is auto. In that mode everything runs without individual approval, while a separate classifier model reads along in the background and blocks risky actions.

ModeStatus barWhat runs without asking
Manual⏸ manual mode onreads only
Edit automatically⏵⏵ accept edits onreads, file edits, common filesystem commands
Plan⏸ plan mode onreads, plus classifier-approved commands
Auto⏵⏵ auto mode oneverything, with background safety checks

What the auto-mode classifier blocks by default is listed in the documentation: downloading and executing code, production deploys and migrations, force push, git reset --hard, merging a pull request no human has approved. Allowed by default are file operations in the working directory, installing declared dependencies and read-only HTTP requests.

For a first session in a project you care about, two things are still worth doing. First: a directory under version control with everything committed before you start. Then every change is a diff rather than a surprise. Second: Shift+Tab until the status bar reads ⏸ plan mode on, when you want to see what is supposed to happen first. Claude then reads files and writes a plan, but changes nothing until you approve it.

Which beginner tips can you skip?

Several that are still everywhere. Anthropic keeps a table in its best practices under the heading What you can stop doing, and three rows of it cover exactly the advice beginners hear first.

Common adviceWhy it is retired
The context window is your main constraint, manage it aggressivelyCurrent models have a one-million-token window and compaction happens on its own. /clear between topics is still worth it, because a focused context gives better answers and costs less
Add IMPORTANT or ALL CAPS to instructions Claude keeps missingCurrent models follow a plainly worded line. More emphasis mostly makes the rule get over-applied
Write "think hard" or "be thorough" in the promptEffort is the control for that. Those phrases are ordinary prompt text

The pattern behind them matters more for a beginner than the three cases themselves: much of what sits in guides as technique was a workaround for something the model could not do at the time. Anyone starting in 2026 does not need to learn those workarounds. What you need instead is a precise request and a check command, and both are above.

Which features you can safely postpone until you need them, and in what order they come after that, is in how to learn Claude Code.

How do you know the first session went well?

By three things, and none of them is the length of the answer. First: the change sits in the files you expected, and you read the diff. Second: the check command passed, both for Claude and then once more for you. Third: you could say in one sentence what changed.

The commit belongs to the end of it, and you can commission it in the conversation; the quickstart lists Git operations explicitly as conversational commands. Read the commit message before you let it stand.

/exit            ends the session
claude -c        continues the most recent session in this directory
claude -r        opens the list of sessions to pick from

What comes after that is the file that holds your rules, so you do not repeat them in every session. What one looks like after months in operation, and why ours is longer than recommended, is in the CLAUDE.md file. If the installation itself is still open, or your terminal cannot find claude, that is answered in installing Claude Code.

Do you need coding skills or a course for this?

For the first session, neither. You need a terminal, a project directory and a Claude subscription or a Console account, and the documentation is readable in English and German. If you want to find out whether the tool suits you, an afternoon answers that, not a payment.

To be honest about what a course does not do at this point: the four moves above are faster to learn on your own. What saves time is the part after them, meaning the rules file, the check commands and the recurring procedures, because otherwise you derive those from your own mistakes. That is exactly the content of The Claude Code System: four weeks, weekly live sessions, an ENLIX certificate of completion at the end. The cohort runs in German, so the English page carries a waiting list rather than a price. What other providers in the German-speaking market charge is in the Claude Code course comparison. And what using the tool itself costs is worked out in a minute by the cost calculator.

Frequently asked

What should I ask Claude Code first?

Something that changes nothing. Anthropic's quickstart suggests questions such as "what does this project do?" or "where is the main entry point?". You learn whether the tool reads your project correctly before it touches a file, and you see what an answer looks like before you have to judge a change.

Do I need to know how to code for the first session?

Not for the first session. You need a terminal, a project directory and a Claude subscription (Pro, Max, Team or Enterprise) or a Console account. What you do need is the ability to judge whether the result is right, and that is exactly what a check command is for.

Why does Claude Code do something other than what I asked?

Usually because the request did not carry the information that was missing. The documentation names the antidote: a request that names the file, describes the symptom and says what done looks like. When it drifts, press Esc instead of waiting for the answer.

What do I do when the second correction misses too?

Run `/clear` and rewrite the request. Anthropic now says so itself: a third correction attaches itself to a conversation that already contains two failed attempts, and Claude re-reads them on every further turn.

How do I end a session and continue later?

`/exit` ends it. `claude -c` continues the most recent conversation in the same directory, `claude -r` opens the list of sessions to pick from. The conversation is saved locally, so you do not have to explain where you left off.

Written by

Marco Kohns

Co-founder of ENLIX, lecturer in AI and growth

Marco worked as a growth product manager at a Silicon Valley scale-up and has been teaching that way of working ever since. Today he runs ENLIX with Tobias and builds two products of his own on the same systems, which is what the courses open up.

  • Growth product manager at a Silicon Valley scale-up, Series A to B, backed by a16z, General Catalyst and Sapphire, with users in over 100 countries and more than 20,000 cities
  • Peer-reviewed research in the Journal of Business Research on generative AI in growth, with Prof. René Bohnsack. The research began in summer 2022, months before ChatGPT was public
  • Executive education lecturer at Católica-Lisbon, over 10 seminars, more than 1,500 people taught

Keep reading