Claude Code 101

Business Context

Most engineers who adopt Claude use it through the browser: paste code in, read a response, paste it back. That works, but it leaves most of the value untouched.

Claude Code puts Claude directly in your terminal. It has access to your filesystem, can read and write files, run commands, and complete multi-step tasks across your codebase without copy-pasting. Engineers who have built this into their daily workflow ship faster, write fewer tests by hand, and spend less time on the mechanical parts of the job.

This lesson covers everything you need to go from zero to productive in Claude Code.

---

Core Concepts

What Claude Code Is and How It Differs from the Browser

Claude Code is a command-line tool that runs Claude inside your terminal. The core difference from the browser is filesystem access: Claude Code can read your files directly, write changes back, and execute shell commands.

This changes the type of task that becomes practical. In the browser, you are limited to what you can copy and paste. In Claude Code, you can say "refactor all error handling in the API layer to use the new AppError class" and Claude will find the files, make the changes, and run the tests.

Setting Up Claude Code

Prerequisites: Node.js 18 or higher.

Install and authenticate:

1. Run npm install -g @anthropic-ai/claude-code
2. Run claude login (opens browser authentication tied to your Anthropic account)
3. Navigate to your project: cd your-project
4. Start a session: claude
5. Run /init to generate a CLAUDE.md file

The CLAUDE.md file is the most important setup step. Claude reads it at the start of every session to understand your project: architecture decisions, naming conventions, what patterns to follow, what to avoid. Write it once and it applies to every future session in that project.

What to put in CLAUDE.md:

• How the repo is structured (key directories and what lives where)
• Naming conventions and code style rules
• Patterns to follow (and anti-patterns to avoid)
• How to run tests and common build commands
• Any constraints (libraries not to use, APIs to avoid calling directly)

The Claude Code CLI: Core Commands and Slash Commands

Claude Code runs as a REPL: you type, Claude responds and acts. Three modes of invocation:

Within a session, slash commands control behavior. The ones you will use most:

Keyboard shortcuts:

Working with Files and Your Codebase

Claude Code reads files on demand. You do not paste code into the prompt: you reference files by path and Claude reads them directly.

Reading before acting:

Read src/auth/middleware.ts and explain what validation it performs 
on incoming requests.

Making a targeted change:

In src/auth/middleware.ts, add rate limiting at the token validation step.
Use the existing Redis client in lib/cache.ts.
Add a test for the rate limit exceeded case in tests/auth.test.ts.

Working across multiple files:

Refactor the error handling in the API layer to use the new AppError class 
in lib/errors.ts. Update all files in src/routes/ that currently throw 
raw Error objects. Run the tests after each file change.

By default, Claude proposes each change and waits for your approval. Toggle auto-accept with Shift + Tab when you want Claude to apply changes without pausing.

Claude Code in the IDE

Claude Code integrates with VS Code and JetBrains. Once connected, a Claude panel appears inside the editor so you can run sessions without switching to a terminal.

VS Code setup:

1. Open the Extensions panel (Cmd+Shift+X)
2. Search for "Claude Code" and install
3. Open the Command Palette (Cmd+Shift+P) and run "Claude Code: Open Panel"

JetBrains setup:

1. Open Settings, then Plugins
2. Search for "Claude Code" in the Marketplace and install
3. The Claude Code panel appears in the right-side tool window

The IDE integration is most useful when you are actively editing. You can reference the file open in the editor without typing its path, and Claude's changes are immediately visible in your diff view.

Agentic Workflows

Standard sessions are interactive: task, action, review, repeat. Agentic workflows let Claude take multiple sequential actions with minimal interruption, suited for larger tasks where you have defined the expected output clearly.

Always use /plan before a multi-step task. Plan mode makes Claude describe what it will do before doing it. You can redirect, correct scope, or cancel before any work begins.

/plan

Implement the password reset flow. The spec is in docs/specs/password-reset.md.
Write the backend endpoint, the email template, and the unit tests.
Follow the patterns used in the existing registration flow.

Codebase-wide refactor:

Find all places in src/ that call the deprecated fetchUser(id) function.
Replace each call with userService.getById(id), which has the same signature.
Run the test suite after each batch of changes.

Review and fix failing tests:

Run the test suite. For each failing test, diagnose the failure and fix 
the implementation. Do not modify test files.

Key Points

• Claude Code has direct filesystem access: it reads and writes files without copy-pasting
• CLAUDE.md gives Claude persistent project context: initialize it with /init on every project
• Use /plan before any multi-file or multi-step task to verify direction before work starts
• The IDE integration (VS Code or JetBrains) is the lowest-friction entry point for most engineers
• Agentic workflows work best when the task is scoped, patterns to follow are clear, and the test suite can confirm correctness

---

Tools, Prompts, or Templates

Claude Code Setup Checklist

Most engineers skip the setup steps and end up with Claude that does not know anything about their project. Five minutes now saves repeated context explanations for every future session.

Run this once per project, not once per session.

Installation
- [ ] Node.js 18+ is installed
- [ ] Claude Code is installed: npm install -g @anthropic-ai/claude-code
- [ ] Authenticated: claude login completed successfully

Project Initialization
- [ ] Navigated to project root
- [ ] Run /init to generate CLAUDE.md
- [ ] CLAUDE.md includes: directory structure, naming conventions, test command
- [ ] CLAUDE.md includes: patterns to follow and any anti-patterns to avoid

IDE Integration (optional but recommended)
- [ ] Claude Code extension installed in VS Code or JetBrains
- [ ] Panel opens successfully inside the editor

First Session Verification
- [ ] Claude can read a file without error
- [ ] Claude can run the test command successfully
- [ ] Claude Code Commands Reference is bookmarked for reference

---

Claude Code Commands Reference

A complete reference for slash commands, keyboard shortcuts, and CLI flags. Use this during your first sessions until the core commands are muscle memory.

---

Actionable Takeaways

1. Run /init in your main project today. The five minutes it takes to write a good CLAUDE.md will pay back on every session that follows. Include your directory structure, test command, and at least three conventions Claude should follow.

2. Replace one copy-paste coding workflow with Claude Code. Pick a recurring task (writing tests, reviewing for edge cases, drafting a PR description) and run it through Claude Code once. Compare the result to your browser workflow.

3. Set up the IDE integration. If you are in VS Code or JetBrains daily, the in-editor panel removes the context-switch cost entirely. Install it before your next coding session.

4. Use /plan before any task that touches more than two files. The cost of a bad plan is seconds. The cost of undoing three files of wrong changes is much higher.

5. Start with read-only tasks first. Ask Claude to explain a file, audit a function, or identify edge cases before you ask it to make changes. It builds your trust in the output before you accept file modifications.

---

Practical Examples

Engineer: Implementing a New Feature

Situation: You need to add rate limiting to an authentication endpoint.

Session:

Read src/auth/middleware.ts and describe how it currently handles 
token validation.

After Claude summarizes:

Add rate limiting at the token validation step. Requirements:
- 100 requests per minute per IP address
- Use the Redis client already initialized in lib/cache.ts
- Return 429 with a Retry-After header when the limit is exceeded
- Add tests in tests/auth/middleware.test.ts covering: within limit, 
  at limit, and over limit

Follow the existing middleware pattern in this file.

---

Engineer: Codebase-Wide Refactor

Situation: A deprecated function needs to be replaced across 20+ files.

Session with /plan first:

/plan

Find all usages of the deprecated fetchUser(id) function across src/.
Replace each call with userService.getById(id), which has the same 
return type and signature.
Run the test suite after each file to catch regressions.
Report any files where the replacement is ambiguous.

Review the plan Claude produces. Approve it, then let it run. Use /diff to review changes before auto-accepting.

---

Engineer: Diagnosing Failing Tests

Situation: CI is red and you do not know why.

Run the test suite. For each failing test:
1. Show me the error message
2. Identify whether the failure is in the test or the implementation
3. Fix implementation failures only (do not modify test files)
4. Re-run the affected test to confirm the fix

Start with the failing tests in src/payments/.

---

Technical Director: Codebase Audit

Situation: You need to assess the security posture of a new service before it goes to production.

/security-review

Audit the authentication and authorization logic in src/auth/ and 
src/api/middleware/. I want to know:
1. Where user input is validated (and where it is not)
2. Any endpoints missing authentication checks
3. Token handling practices: storage, expiry, rotation
4. Any hardcoded credentials or secrets in the codebase

Output: prioritized list of findings with severity (critical, high, informational).

---

Implementation Workflow

Your First Claude Code Session on Real Work

This exercise takes 20 minutes. Do it on a real project, not a test repo.

1. Install and authenticate if you have not already:

   npm install -g @anthropic-ai/claude-code
   claude login
   

2. Navigate to your project root and start Claude Code:

   cd your-project
   claude
   

3. Run /init to generate CLAUDE.md. Review what Claude writes and add at least:

   • How to run your tests
   • One convention specific to your codebase
   • One thing Claude should avoid doing

4. Pick a real task you have open right now. A function to write, tests to add, a section of code to refactor, or a PR description to draft.

5. Start with a read prompt. Before asking Claude to change anything, ask it to read the relevant file and describe what it sees. Verify that Claude understands the context correctly.

6. Give the task with clear scope. Include: what to change, which files are relevant, what patterns to follow, and how to verify the result (usually: run this test command).

7. Review the proposed changes with /diff before accepting. Check that Claude stayed within scope.

8. Iterate once. If the output needs adjustment, follow up in the same session with a correction. Note what you had to add: that belongs in your CLAUDE.md so Claude gets it right the first time next session.