What You Will Learn

• Describe Claude Code's architecture and the LM→tools→environment loop
• Install Claude, run /init, and maintain project memory (claude.md)
• Feed precise context with @file mentions and screenshots; manage sessions with /compact and rewind
• Extend and automate workflows using custom commands, hooks, MCP servers, and GitHub integration
• Use Claude to refactor codebases, optimize performance, run UI regression tests, and open PRs
• Build domain-specific agents with the Agent SDK and apply security/privacy guardrails

Study Guide

Wait, Anthropic Made a FREE 7-Hour Claude Code Course?!

Here's what nobody tells you: the difference between a "smart autocomplete" and an AI development partner is night and day. One is a convenience. The other rewires how you build software, manage complexity, and move ideas into production. This course is your deep dive into Claude Code , an AI coding assistant from Anthropic that doesn't just suggest lines of code, it reads your repo, plans the work, edits files, runs commands, opens pull requests, enforces standards, and repeats until your task is done. It's an AI that can think and act inside your development environment.

We'll go from zero to advanced: architecture, setup, interaction patterns, context management, hooks, custom commands, MCP servers, GitHub integration, and the Agent SDK. You'll learn not just what it does, but how to use it to refactor large codebases, optimize performance, run UI regression tests through a browser, analyze data in notebooks, and enforce guardrails automatically. By the end, you won't just "know about" Claude Code , you'll have a clear playbook to deploy it solo or across your entire team.

Who This Course Is For (And Why It's Worth Your Time)

Use Claude Code if you want leverage, not just faster typing. If you're a developer, tech lead, engineering manager, or decision-maker, this will show you how to turn an AI into a real teammate. You'll learn how to make it read your code with context, follow your style guide, avoid risky edits, and ship repeatable work without babysitting it. The payoff: less time on glue work, fewer regressions, and a steady rise in throughput and quality.

Learning Objectives

By the end of this course, you will be able to:

- Explain the architecture of an AI coding assistant: the language model, tools, and environment , and why all three matter.
- Install and launch Claude Code in a project-scoped CLI setup, and initialize a new or existing codebase the right way.
- Create and manage a persistent project memory using the claude.md file generated by /init.
- Feed precise context (files, screenshots, conventions) so the model delivers accurate, on-point results.
- Control long sessions with interruption, rewind, and conversation compaction.
- Extend Claude Code using custom commands, hooks, MCP servers (like Playwright or n8n), and GitHub integration.
- Automate validation and safety rails with pre-tool and post-tool hooks.
- Understand and prototype custom agents with the Agent SDK for specialized domains beyond coding.

The Mental Model: What Claude Code Actually Is

Claude Code isn't a plugin. It's an AI agent that combines a powerful language model (reasoning) with a toolbox (action) and your environment (files, terminal, servers). It runs a loop: gather context, plan, act , then repeat. When you internalize this loop, you stop treating it like a chat bot and start delegating work like you would to a junior engineer who learns fast.

Core Concepts (with plain-English definitions):
- AI Coding Assistant: An LM with tools that can read, write, and run actions in your environment. It doesn't just talk , it does.
- Language Model (LM): The "brain" that reasons about your goals, code, and instructions. It can't touch the outside world without tools.
- Tools: Capabilities like reading files, editing files, and running shell commands. Tools give the LM hands.
- Environment: Your local machine, file system, terminal, and processes. Claude Code operates here with scoped access.
- claude.md: A persistent system prompt for your project created by /init. It stores architecture, key files, dependencies, conventions , and it's automatically included in every request.
- MCP Servers: External services that grant Claude Code new tools (e.g., a browser via Playwright, automation via n8n).
- Hooks: Pre and post scripts around tool usage to enforce rules, validate changes, and automate checks.
- Agent SDK: TypeScript/Python libraries to build your own agents using Claude Code's core capabilities.

Example 1:
You ask: "Convert the authentication flow to use OAuth, update routes, and add tests." Claude reads your files, identifies auth modules, plans changes, edits code, runs commands to install libraries, and writes tests. It repeats the loop until it's done, then creates a PR.

Example 2:
You paste a screenshot of a misaligned UI. Claude sees it, opens your component files, tweaks CSS/TSX, uses a browser via Playwright MCP to verify visually, and shares a before/after summary with screenshots.

Architecture Deep Dive: The LLM-Tool Framework

The magic isn't just the model. It's the model plus tools plus a tight loop.

- Gather Context: It reads your files, explores the repo structure, checks dependencies, and uses prior project memory (claude.md).
- Formulate a Plan: It proposes a sequence of actions with clear steps: what to edit, what to install, what to test.
- Take Action: It runs the plan with tools like edit_file and run_bash_command. Then it checks results, adjusts, and loops.

Tools are the difference between "talking about code" and "shipping code." Without tools, the model can only speculate. With tools, it can run the TypeScript compiler, edit a migration, and spin up a test server.

Example 1 , Performance optimization:
You say: "Profile our data parser and remove bottlenecks." Claude reads the parser, runs a profiler via bash, identifies hotspots, rewrites loops, adds benchmarks, and iterates until performance passes a target threshold you defined in claude.md.

Example 2 , Data analysis in notebooks:
You drop a CSV and say: "Analyze churn drivers and plot retention cohorts." Claude creates a Jupyter notebook, installs dependencies, runs the notebook, adds visualizations, and exports graphs for a slide deck.

Installation and Launch: Start Project-Scoped

Claude Code runs in your terminal as a CLI. You should scope it to a specific project to prevent unintentional edits elsewhere and to give it crisp, relevant context.

Install (terminal):
curl https://claude.anthropic.com/install.sh | sh

Launch (from inside your project root):
cd your-project
claude

Running Claude from your project's root is a best practice. It limits actions to that folder and gives immediate visibility into your codebase.

Example 1:
Monorepo? Launch Claude at the workspace root so it sees packages/, shared utilities, and your build scripts , otherwise it may miss important context.

Example 2:
Microservice repo? Launch Claude in a specific service directory so it doesn't hop across unrelated services during a focused task.

Initialize Your Project with /init

/init is where Claude earns your trust. It scans the repo and builds a permanent, structured memory for the project.

Command:
/init

This generates .claude/claude.md , your project's long-term memory. It contains a summary of architecture, key files, conventions, dependencies, run commands, and anything else it needs to behave like an onboarded engineer. Every subsequent message includes this file automatically.

What claude.md often includes:
- Project summary and purpose (what it is, who it serves).
- Tech stack and dependencies (React, Node, Prisma, etc.).
- Key files and modules with roles (routing, data, auth).
- Commands to run the app and tests.
- Coding conventions (naming, patterns, style rules).
- Warnings and policies (no edits to .env, follow type-safety).

Example 1:
In a Next.js app, claude.md includes pages/ structure, app router usage, API routes path, Tailwind conventions, and environment variables expectations , so Claude doesn't guess blindly.

Example 2:
In a data science repo, claude.md captures the notebook structure, data folders, dependency versions, and known pitfalls (like memory constraints during training) so Claude plans accordingly.

Project Memory and Persistent Rules

claude.md is your primary, reliable memory. Update it to teach Claude persistent rules and preferences.

Best practice:
- Add team conventions: "Always use TypeScript for new components."
- Add patterns: "Use functional React components with arrow functions."
- Add safety policies: "Never commit secrets. Never edit .env."
- Add workflows: "Open a PR with a summary when a task completes."

Some users may use a /memory command to append new long-term instructions. Depending on your setup, you can keep using it. That said, editing claude.md directly is straightforward, explicit, and version-controlled , which makes team adoption cleaner.

Example 1:
Add to claude.md: "When adding backend endpoints, always write a contract test and include OpenAPI docs in /docs/openapi.yaml."

Example 2:
Add to claude.md: "Use Zod for input validation. If user input enters the system, validate it. No exceptions."

Feeding Claude Context on Demand: The @ File Trick

Big repos are noisy. You can point Claude to exactly what matters using @ to include files in your prompt.

Usage:
Refactor the logic in @src/utils/api.ts to reduce duplication.
Write tests for @packages/auth/src/jwt.ts and @packages/auth/src/roles.ts.

This forces the model to load the content of those files into context for the current request. It's like putting the right pages on its desk before you ask a question.

Example 1:
"Update error handling in @server/routes/users.ts to return Problem Details JSON and adjust tests accordingly."

Example 2:
"Extract the date utilities in @lib/date.ts and @lib/timezone.ts into a shared module @packages/shared/date. Update imports across the repo."

Give Visual Context with Screenshots

Words are clumsy for UI. Paste screenshots directly into the CLI so Claude can "see" what you see , misaligned components, broken layout, color contrast issues.

How to use it:
- Paste a screenshot (Ctrl/Cmd + V).
- Describe the change: "Fix spacing and make buttons consistent with our primary color."
- Let Claude locate relevant files, implement changes, and (optionally) verify in a browser via Playwright MCP.

Example 1:
Paste a screenshot of a modal with overflowing text. Ask: "Reduce padding on mobile, enable word-break, and adjust max-height." Claude edits CSS/TSX and shows updated screenshots.

Example 2:
Paste a dashboard with a confusing chart. Ask: "Rework this chart to stacked bars, add tooltips, and increase label contrast." Claude edits the component and updates theme tokens for accessibility.

Control the Workflow: Interrupt, Rewind, and Compact

Even good agents need steering. Claude Code gives you real-time control over its path.

Interrupt quickly:
Press Escape once to stop Claude mid-response. If it's drifting, cut it off and redirect with a clearer prompt.

Rewind mode:
Press Escape twice to open rewind mode. You can jump back to an earlier step in the conversation and continue from there. This is perfect when a misinterpretation spirals and you want to remove it from the context.

Compact long sessions:
Use /compact to summarize the entire conversation while preserving the key decisions and constraints. It frees context space and speeds things up.

Example 1:
You started a refactor, but Claude latched onto an old plan. Hit Escape twice, rewind to the point before the deviation, and say: "From here, only rewrite the caching layer. No API changes."

Example 2:
A long design session slows down. Run /compact and continue with: "Summarize our decisions so far, then propose a clean implementation plan for the remaining work."

Thinking and Planning Modes (How to Get the Depth You Want)

Claude Code can prioritize planning over acting when you need a detailed roadmap first.

Plan mode:
Use Shift + Tab to toggle into Plan mode. Claude will research files and create a careful execution plan without making edits yet. This is ideal for sensitive systems, database migrations, or major architectural changes.

Default mode:
Claude plans and executes automatically. Use this for routine tasks and iterative work where edits are expected.

Older "thinking mode" prompts aren't necessary. Claude already uses a high reasoning effort by default. If you want more planning, just ask for it explicitly or switch to Plan mode.

Example 1:
"Plan out a safe, step-by-step migration from CommonJS to ES Modules across packages/. Don't edit yet , just a bulletproof plan with fallbacks."

Example 2:
"Create a plan for extracting the analytics pipeline into a separate service. Include deployment changes, database migrations, and monitoring tasks. No code yet."

Real-World Use Cases: Where Claude Code Shines

Think beyond code completion. Here are three common, high-leverage scenarios and how to run them with Claude as your copilot.

1) Performance Optimization
- Ask Claude to profile a hotspot (e.g., a JSON parser or a rendering loop).
- It runs a profiler, benchmarks, proposes changes, implements them, and re-measures.
- You define success criteria up front in claude.md (like target ms or throughput improvements).
Example A: "Profile our Markdown-to-HTML pipeline and reduce processing time by 30%."
Example B: "Optimize server-side rendering for the dashboard route. Minimize blocking requests and cache results where safe."

2) Data Analysis and Visualization
- Claude scaffolds a notebook, installs dependencies, cleans the data, runs models, and outputs visualizations.
- You can ask for specific plots, statistical tests, or dashboards.
Example A: "Build a churn analysis notebook that compares retention by segment and exports PNGs."
Example B: "Run a cohort analysis and produce a report explaining the top 3 retention levers."

3) UI/UX Improvements via Browser Control
- With Playwright MCP, Claude can navigate your app, take screenshots, and verify UI changes visually.
- It can implement CSS/JS tweaks, rerun the browser, and iterate until the UI matches your request.
Example A: "Fix the mobile navbar overlap and add a sticky CTA. Validate on iPhone and Android viewports."
Example B: "Improve the contrast of chart labels and ensure AA accessibility. Provide before/after screenshots."

MCP Servers: Give Your AI New Superpowers

MCP Servers extend Claude Code with specialized tools. They can run locally or remotely.

Playwright MCP (browser control):
- Navigate pages, click elements, take screenshots, and run end-to-end tests.
- Perfect for front-end QA, visual fixes, and regression testing.
Example 1: "Run a login flow E2E. Capture screenshots at each step and report any flaky selectors."
Example 2: "Load the pricing page, compare spacing and typography to our design spec, and fix mismatches."

n8n MCP (workflow automation):
- Gives Claude access to node docs and tools to set up automation workflows.
- Useful for building integrations and internal automations from plain-English prompts.
Example 1: "Create an n8n workflow that triggers on new Stripe charges, enriches the data, and posts a Slack summary."
Example 2: "Build a nightly data sync between Airtable and Postgres with conflict resolution and logging."

GitHub Integration: Bring Claude into Your CI/CD Rhythm

Install the Claude Code GitHub app so your assistant participates directly in your repos , reviewing, committing, and opening PRs.

Command (from CLI):
/install-github-app

What it enables:
- Automatic PR reviews with actionable feedback and suggested changes.
- Responses to issues and PR comments when @mentioned.
- Push commits and open PRs directly from the CLI.
- Consistent, policy-aware reviews that apply your team's conventions from claude.md.

Example 1:
"@claude review this PR for performance issues and confirm type coverage meets our standard." Claude leaves a structured review with diffs and suggestions.

Example 2:
"@claude open a PR that upgrades react-query, updates hooks accordingly, and includes a migration guide in the description."

Visual Context in the CLI: Paste, Fix, Verify

Paste images into the CLI so the assistant can reason with visual context. This radically shortens UI iteration cycles.

Example 1:
Paste a screenshot of the checkout page. Ask: "Fix inconsistent spacing, align totals with price columns, and standardize button radius." Claude edits and shows updated screenshots.

Example 2:
Paste a dark-mode bug where text is invisible. Ask: "Update theme tokens to meet contrast guidelines and ensure icons adapt across themes."

Custom Commands: Slash Your Repetitive Prompts

Turn your best prompts into reusable slash commands in .claude/commands. This is where you start to scale yourself and your team.

How to create:
1) mkdir -p .claude/commands
2) Create a markdown file, like .claude/commands/review.md
3) Put your go-to prompt inside.
Now run: /review

Dynamic arguments with $arguments:
Inside the command file, add $arguments to accept runtime parameters. For example, .claude/commands/spec.md could say: "Create a technical spec for: $arguments. Include data models, endpoints, and front-end components." Then run /spec subscription lifecycle.

Example 1:
/audit-access-control , "Audit role-based access for $arguments and ensure least-privilege access. Propose tests."

Example 2:
/create-test-for $arguments , "Generate unit tests and contract tests for the provided file or module."

Hooks: Safety Rails and Automatic Enforcement

Hooks run before or after a tool executes. They're your policy enforcers , not dependent on human memory or team discipline. Use absolute paths for reliability, and consider templating with $pwd to make configs shareable across machines.

Pre-tool hooks (run before):
- Prevent reading sensitive files like .env.
- Block edits to protected configs or migrations during freeze windows.
- Enforce that certain tools run only in a sandbox.
Example 1: Block read_file on .env and .env.* files. If attempted, print a warning and stop.
Example 2: Disallow edits to package.json unless a specific command like /allow-dep-upgrades is used.

Post-tool hooks (run after):
- Run validation like tsc --no-emit after edits.
- Trigger test suites when files change.
- Post notifications to Slack on successful changes.
Example 1: After any edit to .ts files, run tsc --no-emit. If errors occur, revert changes or request a fix loop.
Example 2: After run_bash_command that includes migration scripts, run a smoke test and rollback if health checks fail.

These hooks let you automate the "we always forget this step" tasks. They also reduce risk by stopping harmful actions before they happen.

The Agent SDK: Build Your Own Specialized AI

When you need more than a coding assistant, use the Agent SDK (TypeScript and Python) to build custom agents that leverage Claude Code's core abilities with your own logic, tools, and policies. You can create agents for legal review, financial analysis, research synthesis , anything that benefits from a plan-act loop plus tool access.

Example 1 , Legal document review agent:
- Reads contracts, flags risky clauses, compares terms to playbooks, and drafts redlines.
- Uses hooks to block sending data to external endpoints.
- Keeps a firm-specific claude.md so reviews follow consistent standards.

Example 2 , Finance data processing agent:
- Ingests CSVs from a data warehouse export, runs reconciliation steps, and produces variance reports.
- Uses post-tool hooks to run quality checks and email a summary to the accounting team.

Managing Long-Term Context: Your Strategy Playbook

Accurate outputs come from good inputs. Here's the practical flow for context management:

- Start with /init to generate claude.md.
- Keep claude.md tight and useful. Update it when policies or architecture change.
- Use @file to load relevant code for the current request.
- Paste screenshots for UI-heavy tasks.
- Use /compact on long sessions to keep the conversation snappy.
- Use Escape and rewind when a thread starts drifting.

Example 1:
Before a complex refactor, update claude.md with "Prefer composition over inheritance in new code." Then ask for a plan in Plan mode. Now the refactor follows your philosophy.

Example 2:
Before kicking off a test-automation push, add "Use Playwright with testIDs for selectors. Avoid brittle CSS selectors." Your generated tests will steer away from flaky patterns.

Security and Privacy: Practical Guardrails

You're giving a powerful agent access to your environment. Treat it like a new team member with restricted permissions, not admin keys to the kingdom.

- Run Claude from a project root, not from your home directory.
- Use pre-tool hooks to block reading or writing sensitive files (e.g., .env, keys, secrets, production configs).
- Keep claude.md under version control to track changes to conventions and policies.
- Lock down GitHub permissions to only what the assistant needs (review, PR creation, specific repos).

Example 1:
Add a pre-tool hook to block git push to main unless a "release approved" file is present. Claude will open a PR instead.

Example 2:
Add a post-tool hook to run a secret scanner after any edits and revert if something sketchy is detected.

Team Workflow Recipes

If you're an individual, you'll get immediate mileage. If you're a team, standardize and scale. Here's how.

For individual developers:
- Always /init a project so claude.md exists.
- Run Claude from the project root to scope actions.
- Turn your favorite prompts into commands in .claude/commands.
- Add pre-tool hooks for safety and post-tool hooks for validation (like tsc and tests).
- Use Plan mode for invasive changes and default mode for quick wins.

For development teams:
- Maintain a shared library of commands and hooks in the repo so everyone automates the same way.
- Integrate the GitHub app to automate PR reviews and consistent feedback loops.
- Use claude.md as living documentation for conventions and architecture; update it with every significant change.
- Consider the Agent SDK for internal tools tailored to your workflows (release management, triage, audits).

Example 1:
Set up a team command: /review-pr , "Review for performance, security, and conventions defined in claude.md. Provide a summary, severity tags, and suggested diffs."

Example 2:
Set up post-tool hooks to run tests and linting for every edit. Reject edits that don't pass. Claude will fix and retry automatically.

End-to-End Example: From Idea to PR

Let's walk through a concrete flow so you can mirror it on your next task.

Goal:
Add a "Saved Items" feature to an e-commerce app.

Steps:
1) /init to generate claude.md if not already created.
2) In claude.md, add: "Use optimistic updates. Component state in Zustand. All new components in TypeScript."
3) Ask in Plan mode: "Plan 'Saved Items' across routes, DB schema, API endpoints, and UI. No edits yet."
4) Approve the plan, then say: "Proceed."
5) Claude creates migrations, models, endpoints, React components, and tests.
6) Post-tool hooks run tsc and tests. If failures arise, Claude iterates until green.
7) You paste a screenshot from a staging environment. "Increase padding and adjust icon alignment." Claude updates UI, validates via Playwright MCP, and shares screenshots.
8) Run /install-github-app if not already installed.
9) Ask: "Open a PR with a summary, risk analysis, and manual testing steps." Claude opens it with a clean description.
10) Team members @mention Claude for follow-up edits, and it updates the PR.

Example 1:
Claude notices an N+1 query in the API and refactors it to use a single JOIN with appropriate indexes, then updates tests.

Example 2:
Claude sets up feature flags around the "Saved Items" release and updates claude.md with a deprecation plan for the flag once usage stabilizes.

Using Quotes as Anchors (Why the Loop Matters)

Some lines are worth keeping in your mental model:

"A coding assistant is composed of a language model with access to a set of tools. It gathers context, formulates a plan, and takes action, repeating until the task is complete."

"The /init command analyzes an entire codebase to create a claude.md file, which acts as the system prompt for all subsequent interactions within that project."

"Hooks allow for the execution of custom scripts before (pre-tool) or after (post-tool) Claude Code uses a tool, enabling automated validation, error checking, and policy enforcement."

Practical Tips and Best Practices

- Teach before you task. Update claude.md with your standards first, then delegate work.
- Scope your environment. Run Claude from the project root, not a random directory.
- Use @file mentions generously for surgical tasks.
- Toggle Plan mode for risky changes. Ask for contingency plans and rollback steps.
- Implement pre-tool hooks early. Prevent harm before it happens.
- Add post-tool hooks for types, tests, linting. Trust, then verify automatically.
- Paste screenshots for UI work. You'll save hours explaining alignment and spacing with words.
- Keep a commands library for your team. Shared automation = less drift.
- Use /compact during long sessions to keep it fast and focused.
- Don't be afraid to interrupt or rewind. You're the editor-in-chief.

Example 1:
Before a deps upgrade, add to claude.md: "Do not upgrade major versions without writing a migration note and running integration tests." The assistant will follow suit.

Example 2:
When merging a big feature, ask: "Add a post-merge checklist to claude.md and open a follow-up issue with 'hardening tasks' we shouldn't forget."

Implications and Applications Across Roles

Software Development:
- Pair programming, refactoring, bug fixes, feature scaffolding, performance work.
- Claude handles the tedious parts while you focus on architecture and tradeoffs.
Example A: "Refactor the legacy auth to JWTs, add refresh tokens, and update tests."
Example B: "Identify risky areas after the ORM upgrade and write targeted regression tests."

DevOps and CI/CD:
- PR reviews, automated standards enforcement, deployment checklists, release notes.
- Policy as code through hooks and claude.md.
Example A: "Auto-review PRs for Dockerfile best practices and image size."
Example B: "Generate release notes from merged PRs and ensure semver labels are correct."

Education and Onboarding:
- New engineers ask Claude to explain modules, find critical files, or walk through data flows.
Example A: "Explain our event-driven architecture with a diagram and list of producers/consumers."
Example B: "Walk me through the signup flow from router to database, step by step."

Specialized Professions via Agent SDK:
- Legal, finance, research , anywhere repeatable analysis and document workflows exist.
Example A: "Review NDAs for non-standard clauses and suggest redlines."
Example B: "Analyze quarterly spreadsheets for anomalies, produce a summary, and generate a PDF report."

Recommendations for Smooth Implementation

For Individuals:
- Launch Claude from the project root and run /init as your first step.
- Build a few custom commands for recurring tasks: /review, /spec, /create-test-for.
- Add pre-tool hooks immediately to protect secrets and critical configs.
- Ask for plans first on risky work. Then execute.
- Track wins: time saved, defects avoided, PR turnaround time.

For Teams:
- Standardize. Keep shared commands and hooks under version control.
- Use the GitHub app for PR reviews and consistent, policy-aware feedback.
- Keep claude.md clean and updated with architecture and conventions; treat it like living documentation.
- Explore the Agent SDK for internal assistants tailored to your stack (release manager, triage bot, audit agent).
- Measure impact: lead time, change failure rate, review coverage, coding standard adherence.

Example 1:
A team sets up a /create-spec command that forces every feature to include data models, endpoints, UI, tests, and risks. Output quality jumps overnight.

Example 2:
Another team's pre-tool hooks block edits to infra files during a release freeze. Accidental outages drop to zero.

Practice: Test Your Understanding

Multiple-choice drills:
1) Why do coding assistants need tools? Because the language model alone can only process text , it can't interact with files, shells, or browsers.
2) Plan mode vs default mode? Plan mode focuses on reasoning and research without edits; default plans and executes.
3) How to create a command with parameters? Create a .md in .claude/commands and use $arguments inside it.
4) Which hook blocks reading .env? A pre-tool hook intercepting read file.
5) What's claude.md for? A persistent system prompt with architecture, conventions, and key context.

Short answers:
- Long session slowing down? Use /compact to summarize history and free context window space.
- Want a convention remembered forever? Add it to claude.md in the project root.
- What's an MCP Server? A capability extender. Example: Playwright MCP lets Claude control a browser for UI tests.

Discussion starter:
Claude can review PRs, push commits, and reply to comments. Benefits: faster reviews, consistent standards, fewer bottlenecks. Risks: over-trust, policy gaps, or unreviewed automated changes. Safeguards: pre-tool hooks, protected branches, required human approvals, scoped permissions, and clear conventions in claude.md.

Key Insights Worth Memorizing

- The power comes from the hybrid: LM for reasoning + tools for action.
- claude.md is the brain of the project , update it; treat it like a teammate's playbook.
- Extensibility is everything: MCP servers, hooks, custom commands, GitHub integration.
- Pre-tool hooks are your guardrails. Avoid trouble before it starts.
- The Agent SDK turns Claude from a coding assistant into a platform for your own domain-specific agents.
- Context management (file @-mentions, screenshots, /compact, rewind) determines accuracy and speed.

Frequently Used Commands and Patterns You'll Reuse

Initialization:
/init , analyze the repo and generate claude.md

Context and control:
@path/to/file.ts , load a file's content into context
/compact , summarize long conversations to free context
Escape , interrupt
Escape, Escape , rewind mode

Customization:
/.claude/commands/*.md with $arguments , create reusable prompts
Pre-tool and post-tool hooks , enforce rules and validations
/install-github-app , integrate reviews, commits, and PRs

Examples you can adapt today:
- /spec $arguments , "Create a technical spec with models, endpoints, and components."
- /review , "Review staged changes for bugs, style, and improvements."
- /create-test-for $arguments , "Generate unit and integration tests."

Troubleshooting: When Things Go Sideways

- Claude is making risky edits: Add or tighten pre-tool hooks. Update claude.md with clearer restrictions.
- It keeps misunderstanding the task: Use Plan mode first, add @file context, and restate constraints at the top of your prompt.
- It's slow or drifting: Interrupt, rewind to a clean point, and run /compact.
- It's confused by repo structure: Run /init again if the architecture changed. Update claude.md with a fresh summary.

Example 1:
Claude tries to upgrade a dependency without a plan. Interrupt, add "Major version upgrades require a migration guide and test plan" to claude.md, then ask for a plan first.

Example 2:
Claude edits the wrong file in a monorepo. Use @packages/service-x/src/... to be explicit. Then rewind and re-execute with precise context.

From Assistant to Platform: Thinking Bigger

At first, you'll use Claude like a focused, tireless pair programmer. Soon, you'll realize it's a platform. You can bolt on tools, enforce policies, automate reviews, and even build new agents tuned to your domain. That's the leap: from typing less, to building a production-grade, AI-augmented workflow where quality improves as speed increases.

Example 1:
Create an internal "Release Manager" agent using the SDK that drafts release notes, verifies migrations, checks metrics post-deploy, and files follow-up issues automatically.

Example 2:
Create an "Onboarding Guide" agent that reads a codebase, generates guided tours, answers questions with file references, and produces diagrams for new hires.

Conclusion: The Playbook to Actually Use This

Claude Code isn't here to wow you with a demo and disappear into your toolbelt. It's here to take real work off your plate. The loop is simple but powerful: gather context, plan, act , repeat. Your job is to give it the right guardrails and the right inputs, then let it run. Start small: initialize a project, add clear conventions to claude.md, write two custom commands, and set up a pair of hooks (block secrets, run type checks). Then integrate GitHub reviews and experiment with MCP servers for UI work. When you're ready, explore the Agent SDK to build the first AI teammate that fits your workflows like a glove.

Do that, and you'll feel the compound effect: cleaner code, faster iterations, and an engineering process that gets lighter as it scales. Not because you're cutting corners , but because you're moving the repetitive, error-prone parts onto a relentless partner that never gets tired and always follows your rules.

Final step you can take right now:
Open your terminal, cd into a project, run claude, then /init. Add three conventions to claude.md, paste a screenshot of a UI bug, and ask Claude to fix it, verify it in the browser, and open a PR with a clear summary. That one small loop will show you what's possible , and it only gets better from here.

Frequently Asked Questions

This FAQ exists to answer the most common questions about Anthropic's free 7-hour Claude Code course and the Claude Code assistant itself. It is structured from basic to advanced so you can get clarity fast, then go deeper as your needs grow. You'll find setup steps, workflow tips, security practices, integration guides, and business-focused advice with practical examples you can use immediately. Where relevant, the answers include short examples to show exactly how to apply the concepts.

What is an AI coding assistant like Claude Code?

Claude Code is an agent that plans and acts, not just a chatbot. It combines a language model (LM) with tools that let it read files, edit code, run commands, and interact with your environment. The loop looks like this: Gather context (read files, inspect the project), formulate a plan (reason through steps), then take action (edit, run, verify).

Why it matters: The ability to use tools is what turns "text generation" into real delivery,bug fixes, refactors, tests, analyses, and CI actions. You guide outcomes with clear prompts, scoped context, and permissions. Result: You get a collaborator that can reason, propose steps, and execute them with guardrails.

Example:
"Audit our API handlers for error handling," then let Claude read routes, propose improvements, edit files, and run tests to verify changes.

What makes Claude Code so powerful?

It blends strong reasoning with tool access. Built-in tools like bash (run shell), read (inspect files), edit (modify code), and agent (spawn sub-agents) let Claude move from plan to execution. This supports end-to-end workflows: benchmark, locate bottlenecks, implement a fix, and validate results.

Impact in practice: It can refactor core modules, run type checks, write tests, and adjust CI,all inside your project context. It's useful for debugging, performance work, data analysis, and UI changes because it can both think and do.

Example:
"Improve the performance of this CSV parser," Claude profiles the hot path with bash, proposes a new algorithm, edits code, and re-benchmarks,then reports the delta.

What are some examples of tasks Claude Code can handle?

Claude is versatile across the stack. It can: analyze libraries, run benchmarks, and fix hot spots; perform full data analysis in notebooks; improve UI styling with browser tooling; and slot into CI to review pull requests automatically. Because it can read, edit, and run, it handles complex multi-step tasks well.

Real-world patterns: Product teams use it to generate specs and tests. Data teams use it for EDA and visualizations. DevOps teams use it for pipelines and infra scripts. Design-minded engineers use it to iterate UI with screenshots and browser control.

Example:
"Reduce churn from this dataset," Claude opens a notebook, explores cohorts, plots retention curves, and proposes specific product changes based on observed patterns.

How do I install and run Claude Code?

Install via the official script, then run from your project folder. In your terminal, run the official install command from Anthropic's documentation (you may see a host like claude.anthropic.com or claude.com in docs,use the one shown in your official guide). Then, cd into your project and run claude to launch within that context.

Why project scope matters: It keeps edits and commands contained to the intended directory. That's a simple but critical safety layer.

Example:
cd ./my-app → claude → "Set up auth" → Claude inspects files, proposes architecture, scaffolds modules, and runs checks without touching other folders on your machine.

Why is it recommended to run Claude Code in a specific project folder?

Scope = safety + relevance. Running Claude inside a project directory limits read/edit/run operations to that folder, avoiding accidental changes elsewhere and improving relevance of its analysis. It also makes context management easier, since Claude will find the files it needs without overloading the context window.

Business impact: Guardrails reduce risk by design. If your team has multiple repos, each gets its own isolated session, improving predictability and auditability.

Example:
In /clients/retail-portal, ask "Upgrade to React Server Components," and Claude explores only that codebase, updates dependencies, and runs tests without touching /clients/banking-portal.

What is the first command I should run in a new or existing project?

Run /init to create project memory. It scans your codebase,architecture, stack, scripts, conventions,and synthesizes a claude.md file that serves as the project's persistent context. Every future prompt automatically includes this summary so Claude works from shared ground.

Value: Less prompting, fewer misunderstandings, and more consistent outputs across sessions and teammates.

Example:
After /init, ask "Add passwordless login" and Claude leverages claude.md to align with your stack (e.g., Next.js + Prisma) and coding standards.

What is the claude.md file and why is it important?

It's your project's living brief. Generated by /init, claude.md stores architecture summaries, stack details, key scripts, and "rules of the road." It is auto-included in every prompt, acting like a permanent system prompt for that project.

Practical benefit: Teams get consistent behavior without repeating context. New teammates ramp faster. Claude's edits align with your conventions and constraints.

Example:
Include "Always write tests with Vitest" in claude.md, and Claude will generate Vitest tests when implementing features or refactors.

How can I add specific files to Claude Code's context for a single command?

Use the @file syntax. Mention files directly in your prompt with @path/to/file.ext. Claude will load their contents for that request, focusing attention where you need it.

Tip: Use this to spotlight critical modules, failing tests, or logs instead of relying on Claude to discover them in a large repo.

Example:
"Refactor @src/components/UserProfile.tsx and @src/utils/date.ts for performance; keep API stable."

How can I make Claude Code permanently remember a specific instruction?

Edit claude.md directly for persistent rules. Add guidance like "Prefer TypeScript" or "Follow the Airbnb style guide" to claude.md. Some setups include a /memory command that opens claude.md; editing the file itself is the most direct method.

Why this works: claude.md is always included in context, so the instruction persists across sessions and teammates.

Example:
"Always return typed responses from API routes" in claude.md leads Claude to add types and generate matching tests automatically.

How can I control Claude Code's execution flow?

You stay in the driver's seat. Press Escape once to interrupt an action or response immediately. Press Escape twice to enter rewind mode, jump back to an earlier point in the session, and restart from there. These controls help you correct direction without starting over entirely.

Best practice: Interrupt early if the plan drifts; then refine your instruction. Rewind if the last few turns created confusion or undesirable edits.

Example:
Interrupt a risky migration, clarify constraints ("no schema changes"), rewind to the planning step, and let Claude re-propose a safer path.

My chat session is getting very long. How can I manage the context window?

Use /compact to summarize the conversation. It condenses prior turns, preserving key decisions and learnings while freeing up context space for new work. This improves speed, reduces token usage, and keeps Claude anchored to what matters.

Tip: Compact after major milestones (e.g., after a refactor) so the next phase starts clean but informed.

Example:
"/compact" → "Now, create end-to-end tests matching the new flow." Claude uses the summary to proceed without losing prior decisions.

How can I automate repetitive prompts?

Create custom slash commands. Add markdown files to .claude/commands. The file name becomes the command (e.g., review.md → /review). Put your reusable prompt inside the file to standardize reviews, test plans, or release notes.

Why teams love this: Shared commands enforce quality and speed up recurring workflows.

Example:
"/review" triggers your standardized code review checklist: bugs, readability, security, and tests with clear action items.

How do I add parameters to my custom commands?

Use the $arguments placeholder. Whatever you type after the command name will be injected where $arguments appears in your command file. This makes commands dynamic while keeping a consistent structure.

Good use cases: Specs, release notes, incident write-ups, and user stories.

Example:
Command file: "Create a spec for: $arguments" → Run: "/spec user authentication flow"