Claude Code Tutorial: From First Session to Production Workflow

There are plenty of Claude Code tutorials that walk you through installation and stop where the real work begins. This one is the opposite: at Lasting Dynamics we use Claude Code daily on production client projects and we teach agentic coding in our academy, so this tutorial covers the part that actually determines whether the tool makes you faster — configuration, workflow, and habits.

What Claude Code is, in one paragraph

Claude Code is Anthropic's agentic coding tool. Instead of completing lines as you type, it works like a colleague you delegate to: you describe an outcome, and an agent plans, reads your codebase, edits files, runs commands and tests, and iterates until done. It's terminal-first (with IDE extensions, a desktop app, and a web version available), powered by Claude models, and extensible via MCP servers, hooks, skills, and subagents. The key mental model: it multiplies your engineering judgement — it doesn't replace it.

Setup: ten minutes, honestly

npm install -g @anthropic-ai/claude-code
cd your-project
claude

(Anthropic also ships a native installer if you'd rather skip npm.) On first run you authenticate with a Claude subscription (Pro, or Max for heavy use) or an API key.

Commands you'll use from day one:

• /init — analyzes the project and generates a starter CLAUDE.md
• /help — the command list
• /clear — resets context when you switch topics
• claude --continue / --resume — pick up a previous session

That's genuinely it for setup. The interesting part is what comes next.

Step 1: Write a CLAUDE.md worth reading

CLAUDE.md is a markdown file in your repo root that Claude Code loads at the start of every session. It's the difference between onboarding a talented new hire once and re-explaining your project every single morning.

What belongs in it — exactly what you'd tell a strong engineer on day one:

# Project X

## Commands
- build: `npm run build`
- test: `npm test`
- lint: `npm run lint`

## Conventions
- TypeScript strict mode, no `any`
- UI components live in src/components/ui
- DB changes ONLY via prisma/migrations
- Every bug fix starts with a failing test

## Boundaries
- Don't touch src/legacy/** without asking
- No new dependencies without justification

We maintain CLAUDE.md like code: it goes through review, it's updated when conventions change, and when the agent gets something systematically wrong, our first question is "is there a missing line in CLAUDE.md?"

Step 2: Take permissions seriously

Claude Code asks before doing potentially risky things — running certain commands, writing outside the project, calling external tools. Those prompts feel like friction until the day one of them saves you.

The discipline we teach: read what it's about to do, permanently allow only what's always safe (test runner, linter, build), and leave everything else on ask. Each permission prompt is a free review checkpoint on the agent's plan.

Step 3: The production workflow

This is the loop our engineers converged on after months of daily client work:

1. Briefs, not prompts. Context, constraints, definition of done: "Add input validation to /apply. Use zod like the rest of the project. Invalid input returns 400 in the standard error format. Add tests and make them pass." That brief beats any clever prompt.
2. Plan before code. On anything non-trivial, have Claude Code present its plan first (plan mode exists for exactly this) and review it like you'd review an approach in standup. Rejecting a bad plan costs seconds; rejecting a bad diff costs an afternoon.
3. Commit-sized increments. "Migrate the module" becomes "migrate this file, run its tests, stop." Small goals converge; huge goals drift.
4. Tests are the leash. An agent that can verify its work iterates toward correct; one that can't is guessing confidently. If your test suite is weak, the first thing to delegate is writing tests.
5. Git as the safety net. Frequent small commits; every verified increment lands. Claude Code is genuinely good at git — use that.
6. Review like you own it — because you do. Every AI-assisted line ships under your name. "The AI wrote it" is not a sentence that exists on a serious team.

Step 4 (later, not first): MCP, skills, hooks, subagents

Once the fundamentals work, the extension layer is where Claude Code pulls ahead:

• MCP servers connect the agent to your world: databases, browsers, ticketing systems, internal APIs (claude mcp add).
• Skills package repeatable procedures — deploy runbooks, review checklists — that load on demand.
• Hooks run commands automatically on events (lint after every edit), turning conventions into constraints the agent can't forget.
• Subagents handle scoped tasks (explore this codebase, research that question) in parallel without polluting your main context.

Honest advice: don't start here. Ninety percent of the value is in a good CLAUDE.md, precise briefs, and trustworthy tests. Extensions multiply a working workflow; they don't fix a broken one.

What it costs

Claude Code comes with Claude subscriptions (Pro for regular use, Max for heavy use) or runs pay-as-you-go on API tokens. Long agentic sessions on large codebases consume real tokens, so daily professional use almost always favors the subscription.

The cost nobody prices in: your review time. A tool that generates code faster than you can responsibly review it hasn't made you faster — it has moved the bottleneck and hidden it.

The five mistakes everyone makes

1. Vague goals on big codebases — the agent makes reasonable decisions you didn't want, at scale. Precision is the cure.
2. Marathon sessions without /clear — context fills with noise and quality drops. New topic, new context.
3. Approving every permission to go faster — see Step 2.
4. Using it to avoid understanding — code you don't understand today is the bug you can't fix in three months. If output isn't clear, ask the agent to explain it (it's excellent at that) instead of accepting and moving on.
5. Judging it on a five-minute try — like every professional tool, the value shows up with deliberate practice.

The best way to learn Claude Code

You can learn the commands in an afternoon. What takes longer is the judgement that makes the tool powerful: recognizing when a plausible diff is wrong, specifying work precisely, knowing what to test, knowing what good architecture looks like. Agentic tools have made it easier than ever to produce code you don't understand — and they've made engineers who do understand dramatically more productive.

That's the bet the Lasting Dynamics Academy is built on: for ten years we've trained the engineers we then hire, and today hands-on agentic AI work sits in the curriculum on top of the fundamentals — architecture, design patterns, testing — with real tasks reviewed weekly by a mentor. It's free, fully remote, selective, and everyone who completes it gets a job offer. If this tutorial matched how you want to work, that's exactly how the agentic coding program is taught — and the next cohort is open.

FAQ

Claude Code vs Cursor — which should I pick? Different tools for different task shapes; many of our engineers use both daily. If you can describe the outcome but not the edits, Claude Code; if you can already see the edits, an AI editor. Full comparison from our production experience: Claude Code vs Cursor.

Do I need to know how to code to use it? To play, no. To work, yes — and the better you are, the more it's worth. Without the judgement to review output, you're accumulating code you can't maintain.

Does it work on large legacy codebases? That's one of its strengths — exploration, long refactors, migrations. The commit-sized-increment rule counts double there, and you need a test suite you trust.

How long until I'm productive? With a solid CLAUDE.md and the workflow above: days. Real mastery — the multiplying kind — comes from deliberate practice and review by someone more experienced. That's precisely why the academy exists.