Claude Code Masterclass 2026: The $250K Guide (Part 1 — Foundation & Mastery) | Design Delight Studio

Quick Answer

Claude Code is Anthropic’s agentic coding tool — a full software-engineering agent that runs in your terminal, IDE, desktop, browser, mobile, and Slack. It reads your codebase, edits files, runs commands, executes tests, and manages git workflows through natural language. This masterclass teaches you every primitive that matters: CLAUDE.md (always-on rules), Skills (on-demand expertise), Subagents (context-isolated workers), Agent Teams (parallel collaboration), Hooks (deterministic safety rails), MCP (external tool access), plus the complete Ollama local setup for sovereign fallback. Part 1 is everything you need before you build. Part 2 is how you actually build with it.

ⓘ

The Part 1 → Part 2 split. Part 1 (this page, 13 modules) is foundations: what Claude Code is, how to install it, the mental model, the configuration surface, and all six primitives you configure before building. Part 2 (12 modules on a separate page) is production: the full command reference, git workflows, the DDS methodology, build-along walkthroughs for a React app and a Shopify section, advanced multi-agent patterns, cost control, IDE integration, three DDS case studies, the $250K cheat sheet, and what comes next. Do Part 1 first. You will be glad you did.

Key Takeaways — Part 1

• Claude Code is an agent, not autocomplete. It reads your whole codebase, runs commands, manages git. Anthropic writes most of its own code with it.
• Install via Homebrew or WinGet, never npm (deprecated in 2026). Native Windows needs Git for Windows; WSL does not.
• CLAUDE.md loads into every prompt. Keep it under 200 lines. Put always-true rules here; put sometimes-true rules in Skills.
• Skills use progressive disclosure: ~100 tokens per skill on every scan, full load only when the description matches your task. This is how AgentKit ships 40+ skills without context bloat.
• Subagents protect context. Offload heavy research to a subagent; get a clean summary back. Your main session stays sharp.
• Agent Teams are parallel. Use them when independent tasks need coordination. Use subagents when you just need research done without pollution.
• Hooks are deterministic. Shell commands that fire before or after tool calls. The difference between unattended-safe and unattended-risky.
• MCP extends reach. Start with Filesystem + Git + GitHub. Audit every server before installing. Each one adds capability and attack surface equally.
• Ollama is your sovereign fallback. Zero-cost local inference for private work. Cloud-tier Ollama (qwen3-coder 480B) is free through Anthropic for routine work.
• The pattern: Sonnet 4.6 default, Opus 4.6 on demand, Haiku 4.5 for the Explore subagent. The hybrid stretches your budget significantly.

✓

Claude Code requires explicit permission before modifying files or running commands (in the default permission mode). It operates in your local environment and talks directly to the Anthropic API with no opaque backend. You remain in control of what ships. Module 04 covers the four permission modes and when each is appropriate.

macOS / Linux · install

# Stable channel (recommended for daily work)
brew install --cask claude-code

# Latest channel (bleeding edge)
brew install --cask claude-code@latest

# Upgrade when you want to
brew upgrade claude-code
# or
brew upgrade claude-code@latest

Windows · WinGet (PowerShell)

# Install Git for Windows first if you don't have it
winget install Git.Git

# Install Claude Code
winget install Anthropic.ClaudeCode

# Upgrade (WinGet installs do NOT auto-update; native installs DO)
winget upgrade Anthropic.ClaudeCode

⚠

Shell confusion? If you see The token '&&' is not a valid statement separator, you are in PowerShell expecting CMD syntax. If you see 'irm' is not recognized, you are in CMD expecting PowerShell. Your prompt shows PS C:\ when you are in PowerShell and C:\ without PS when you are in CMD. Match the syntax to the shell.

WSL · Ubuntu/Debian

# Inside WSL, use Homebrew for Linux
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
brew install --cask claude-code

# Verify
claude --version

1

2

3

✓

File a bug with /bug from inside Claude Code whenever something misbehaves. The bug report ships with session context so Anthropic can actually fix it. You can also file on GitHub at github.com/anthropics/claude-code.

ⓘ

Skills superseded Commands in 2026. A file at .claude/commands/review.md and a Skill at .claude/skills/review/SKILL.md both create /review. Skills give you more control (auto-invocation, forking into subagents, supporting files), and take precedence on name conflicts. Use Skills going forward. Commands still work for backward compatibility.

1

2

3

4

⚠

Never run full-auto without Hooks. Module 12 covers the Hooks that make full-auto safe: blocking commits of .env/.key/.pem, preventing rm -rf on untrusted paths, requiring tests to pass before commit. Full-auto without Hooks is how you wake up to a force-pushed main.

ⓘ

Status line rate-limits. As of 2026 Claude Code exposes rate_limits in statusline scripts — 5-hour and 7-day windows with used_percentage and resets_at. Wire these into your prompt to avoid surprise throttle. Covered with the full command reference in Part 2 (Module 14).

ⓘ

Why Ollama at all? Four reasons: (1) Sovereignty — client data or regulated work never leaves your machine. (2) Zero marginal cost — run thousands of calls without metering. (3) Resilience — your workflow keeps working when your plan hits rate limits. (4) Experimentation — test skills, hooks, and MCP against a local model before burning API budget. The DDS Sovereign AGI Suite uses local Ollama for private inference and Anthropic API for frontier tasks. That is the sovereign pattern.

macOS / Linux / Windows native

# macOS or Linux (one-liner)
curl -fsSL https://ollama.com/install.sh | sh

# Windows native: download the installer from ollama.com
# It registers ollama.exe on PATH and runs as a background service on 127.0.0.1:11434

# Verify
ollama --version
curl http://127.0.0.1:11434/api/tags

~/.zshrc or ~/.bashrc (or Windows env vars)

export OLLAMA_FLASH_ATTENTION=1       # faster attention computation
export OLLAMA_CONTEXT_LENGTH=8192    # tune per your VRAM; larger = more memory
export OLLAMA_KEEP_ALIVE=-1           # keep loaded model in memory across calls
export OLLAMA_KV_CACHE_TYPE=q8_0    # 8-bit KV cache: half the memory, negligible quality loss

# Reload shell, then verify
ollama serve  # if not already running as a service

Pull models · local and cloud

# Local models (download to disk, run on your GPU)
ollama pull qwen2.5-coder:14b
ollama pull qwen2.5-coder:32b      # if you have 24GB+ VRAM

# Cloud models (run on Ollama's infrastructure, free tier)
ollama pull qwen3-coder:480b-cloud
ollama pull deepseek-v3.1:671b-cloud

# List everything available to you
ollama list

~/.claude/settings.json (snippet)

{
  "providers": {
    "ollama-local": {
      "type": "openai-compatible",
      "baseUrl": "http://127.0.0.1:11434/v1",
      "apiKey": "ollama",
      "models": ["qwen2.5-coder:14b", "qwen2.5-coder:32b"]
    },
    "ollama-cloud": {
      "type": "openai-compatible",
      "baseUrl": "https://ollama.com/v1",
      "apiKey": "$OLLAMA_API_KEY",
      "models": ["qwen3-coder:480b-cloud"]
    }
  }
}

1

2

3

4

✓

DDS deep dive reference. The complete Ollama for Windows walkthrough — every plugin, every model comparison, every setup step — lives at the Ollama for Windows Complete Guide. This module gave you the Claude Code integration layer. That guide is the Ollama mastery layer. Read them together.

.claude/rules/react-components.md

---
paths: "src/components/**/*.tsx"
---

## React component rules
- Functional components only
- Typed props interface above the component
- Named export, no default
- Co-locate styles as `Component.module.css`
- Co-locate tests as `Component.test.tsx`

CLAUDE.md · DDS template

# Project: [Name]
# Stack: [tech stack one line]
# Last reviewed: 2026-04-16

## Identity
You are working in a production codebase. Output is shipped, not prototyped.
Every change must be reviewed before merge. Bias to safety over speed.

## Code Style — Non-Negotiable
- TypeScript strict mode. No `any` without a justifying comment.
- Functional components only. No React classes.
- Named exports only. No default exports.
- `const` over `let`. Never `var`.
- Error messages are user-facing: friendly, never expose stack traces.
- File length cap: 300 lines. Split larger files into focused modules.

## Architecture
- Feature-based folders: /features/[name]/{components,hooks,utils,types,__tests__}
- All API calls go through /lib/api client. Never raw fetch in components.
- Env vars loaded through /lib/env.ts with Zod validation.
- No business logic in components. Logic lives in hooks or services.

## Testing — Mandatory Before Marking Complete
- Every function has a test file co-located under __tests__/.
- Minimum three cases per function: happy, edge, error.
- Run `npm test` and report results before claiming a task done.
- Never mark a task complete with failing tests.

## Validation Workflow
1. Read existing similar code first — match patterns.
2. Make change.
3. Run linter: `npm run lint`.
4. Run tests: `npm test`.
5. Show me the diff before committing.

## Git
- Conventional commits: feat:, fix:, docs:, refactor:, test:, chore:.
- Branch naming: feature/[ticket]-[slug] or fix/[ticket]-[slug].
- Never commit to main directly. Always branch.
- Never `git push --force` against shared branches.

## Forbidden
- Do not install packages without confirming with me first.
- Do not modify CI/CD configs.
- Do not touch /infra/ or /.github/workflows/.
- Do not read or echo .env contents.

## Communication
- If a requirement is ambiguous, ask one targeted question instead of guessing.
- If you find an unrelated bug, note it in the summary, do not fix it.
- End every task with: one-paragraph summary, test results, files changed.

⚠

Keep CLAUDE.md under 200 lines. It loads into every prompt. At 400 lines you are eating thousands of tokens before Claude sees your actual request. Rules that apply sometimes belong in Skills (Module 08) which load on demand. Rules that apply always belong here.

Memory-related commands

# View and edit project memory
/memory

# See current context window usage
/context

# Compact the conversation when context fills up
/compact

# Auto-compact toggle (compacts automatically near the limit)
/autocompact

# Undo recent code changes from this session
/rewind

# Summary when resuming a long session (added 2026)
/recap

# Focus view: hide transcript, see only Claude's final message
/focus

1

2

3

4

✓

The cheapest productivity gain in Claude Code is internalizing /context. Check it when you feel the session slowing. If you are above 75% context utilization, compact or start fresh. This alone improves perceived quality more than any model upgrade.

Skill anatomy

# Project scope: in your repo
.claude/skills/my-skill/
├── SKILL.md              # required: YAML frontmatter + instructions
├── scripts/              # optional: Python/Bash/Node helpers
│   └── run.py
├── references/           # optional: API docs, schemas, cheatsheets
│   └── api.md
└── assets/               # optional: images, templates, fixtures

# User scope: works across all projects
~/.claude/skills/my-skill/

# Plugin scope: bundled inside an installed plugin
~/.claude/plugins/<plugin>/skills/my-skill/

.claude/skills/shopify-section/SKILL.md

---
name: shopify-section-author
description: Author Shopify Liquid sections following the DDS Atelier 3.4.0 standards.
  Triggers on requests to create, build, or scaffold a Shopify section (.liquid file in
  /sections/), or any mention of section schema, blocks, or theme settings. Does NOT trigger
  for product templates, snippets, or page templates — those are separate skills.
version: 2.1
model: sonnet
effort: medium
user-invocable: true
agent: general-purpose
---

# Shopify Section Authoring Skill

When the user asks for a new Shopify section:

1. Read /sections/ to understand existing naming patterns and schema conventions.
2. Propose the section name, schema settings, blocks, and CSS scope.
3. Once approved, scaffold the file with:
   - Scoped CSS under a unique wrapper class
   - Liquid logic with defensive filters
   - JSON schema with valid ranges ((max-min)/step >= 3)
   - IIFE JS block with zero globals
4. Run `shopify theme check` if available. Report results.

See references/atelier-standards.md for the full style guide.

1

2

3

4

5

ⓘ

The hidden power: context: fork. Add context: fork to SKILL.md frontmatter and the skill executes in a forked subagent context — research happens in isolation, the main session receives the result. The built-in /batch skill uses this pattern with isolated git worktrees. Combine with the agent field to route to a specialist subagent (Module 10).

.claude/commands/review-pr.md

---
description: Review an open PR for quality, security, and test coverage.
model: sonnet
allowed-tools: ["Read", "Grep", "Glob", "Bash"]
---

Review PR $ARGUMENTS.

## Process

1. Run `gh pr view $ARGUMENTS --json title,body,files` to get metadata.
2. Run `gh pr diff $ARGUMENTS` to see the changes.
3. Check each file for:
   - Code quality (naming, complexity, structure)
   - Security concerns (injection risks, auth issues, secrets)
   - Performance (obvious inefficiencies, unnecessary allocations)
   - Test coverage (new code has tests; existing tests still pass)
4. For each finding, cite the file and line number.
5. End with a recommendation: Approve, Request Changes, or Comment.
6. Post the review as a PR comment with `gh pr comment`.

.claude/commands/ship-it.md

---
description: Run full pre-ship checks: lint, test, build, then summarize.
---

Run the complete pre-ship sequence:

1. `npm run lint` — must be clean
2. `npm test` — all tests pass
3. `npm run build` — build succeeds, no warnings
4. `git status` — confirm what is staged
5. If all pass, draft a conventional-commits message based on staged changes.

Do NOT commit or push. Just report status and propose the message.

.claude/commands/explain.md

---
description: Explain a function, file, or concept at a specific depth.
argument-hint: <target> [--depth shallow|deep]
---

Explain $ARGUMENTS.

If it names a file, read the file first.
If it names a function, grep for it and read the surrounding context.
If it names a concept, keep the answer to three paragraphs.

Depth shallow (default): what it does, in two paragraphs.
Depth deep: what it does, why it is written that way, what alternatives were
likely considered, and what could break it.

.claude/commands/add-tests.md

---
description: Add tests for a function or module following our test conventions.
model: sonnet
---

Add tests for $ARGUMENTS.

1. Locate the target. Read it and its current test file if one exists.
2. Identify uncovered branches and edge cases.
3. Write tests following our CLAUDE.md test conventions:
   - Minimum three cases: happy path, edge case, error case
   - Co-located under `__tests__/`
   - Descriptive test names (describe what, not how)
4. Run the test suite. Report pass/fail.
5. Do NOT refactor the target itself. Only add tests.

✓

Commands + Skills compose. A command like /ship-it can invoke a skill mid-prompt by referencing its trigger phrase. Your command orchestrates; your skills provide specialized expertise. The system becomes a layered workflow engine, not just a chat interface.

.claude/agents/security-reviewer.md

---
name: security-reviewer
description: Review code for security vulnerabilities. Use proactively after auth changes, new endpoints, or dependency updates.
model: opus
tools: ["Read", "Grep", "Glob"]
memory: project
isolation: worktree
maxTurns: 20
color: red
---

You are a security-focused code reviewer. Analyze code for:

- OWASP Top 10 vulnerabilities
- Authentication and authorization issues
- Input validation and injection risks
- Secrets in code, logs, or config
- CSRF, XSS, SSRF exposure
- Rate limiting and abuse vectors
- Dependency vulnerabilities

As you review, update your agent memory with patterns you find recurring.
Cite file and line numbers. Rank findings as Critical / High / Medium / Low.

⚠

No recursive spawning. A subagent cannot spawn its own subagent. If a task needs deep delegation, use Agent Teams (Module 11) instead. The non-recursion rule prevents fork bombs and runaway token costs.

1

2

3

Inline agent definition

claude --agents '{
  "code-reviewer": {
    "description": "Expert code reviewer. Use proactively after code changes.",
    "prompt": "You are a senior code reviewer focusing on quality, security, and best practices.",
    "tools": ["Read", "Grep", "Glob", "Bash"],
    "model": "sonnet"
  },
  "debugger": {
    "description": "Debugging specialist for errors and test failures.",
    "prompt": "You are an expert debugger. Analyze errors, identify root causes, provide fixes."
  }
}'

Prompt-based team definition

Build a team of four to ship the new checkout flow.

Roles:
- Architect: designs API contracts and data models. Outputs
  a spec document. No code.
- Backend engineer: implements /api/checkout endpoints per
  the spec. Writes tests.
- Frontend engineer: implements the checkout page components.
  Writes tests. May ask the backend engineer for clarification.
- QA reviewer: reads all output before merge. Signs off or
  requests changes. Does not write code.

Work in parallel after the Architect’s spec is approved. Status-update
me every 20 minutes. If any teammate blocks, they message the relevant
peer directly. I arbitrate only if the team cannot resolve among
themselves.

1

2

3

✓

Rule of thumb: if teammates never need to talk to each other, you want subagents. The moment coordination matters, you want a team. Default to subagents — teams are powerful but burn context and tokens per teammate. Reach for them when parallelism genuinely pays off.

.claude/settings.json · hooks

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [{
          "type": "command",
          "command": "./.claude/hooks/block-sensitive-commits.sh"
        }]
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [{
          "type": "command",
          "command": "npx eslint --fix $CLAUDE_TOOL_FILE_PATH 2>/dev/null || true"
        }]
      }
    ],
    "SessionStart": [
      {
        "hooks": [{
          "type": "command",
          "command": "git status --short"
        }]
      }
    ]
  }
}

.claude/hooks/block-sensitive-commits.sh

#!/usr/bin/env bash
# Reads the proposed tool invocation from stdin as JSON
# Exit 0 = allow. Exit non-zero = block with message to stderr.

input=$(cat)
command=$(echo "$input" | jq -r '.tool_input.command // ""')

# Block commits of secrets
if echo "$command" | grep -qE 'git (add|commit).*(\.env|\.key|\.pem|id_rsa|\.p12)'; then
  echo "BLOCKED: will not commit sensitive file patterns" >&2
  exit 2
fi

# Block destructive git
if echo "$command" | grep -qE 'git push.*--force.*(main|master|production)'; then
  echo "BLOCKED: no force-push to protected branches" >&2
  exit 2
fi

# Block rm -rf on the repo root
if echo "$command" | grep -qE 'rm\s+-[rf]+\s+(/|\.|\*|~)'; then
  echo "BLOCKED: rm -rf on suspicious paths" >&2
  exit 2
fi

exit 0

ⓘ

The unattended-safety pattern. Combine three hooks for truly hands-off runs: (1) PreToolUse on Bash to block sensitive operations, (2) PostToolUse on Write/Edit to auto-lint, (3) Stop to send a Slack notification so you see the work when the agent finishes. Layer these on top of a subagent with isolation: worktree and you have a safe overnight engineer.

.claude/mcp_config.json

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/dir"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "$GITHUB_TOKEN" }
    },
    "postgres-readonly": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres",
                "postgresql://ro_user:pass@host:5432/db"]
    }
  }
}

1

2

3

4

5

6

ⓘ

Channels preview (2026). Claude Code now supports MCP channels — push-style messages from servers to the agent (--channels flag). Servers can notify when long-running operations complete, a webhook fires, or an external state changes. Treat channels as untrusted input: combine with a UserPromptSubmit hook that scrubs or validates before the agent acts.

⚠

Plugin subagent restriction. Subagents packaged inside a plugin cannot define their own hooks, mcpServers, or permissionMode. This is a security feature — a plugin you install cannot silently escalate its own capabilities. When writing subagents for a plugin, keep them contained.

Bottom Line

Claude Code works the same day you install it. It becomes powerful when you layer the seven primitives on top: a tight CLAUDE.md for always-on rules, Skills for on-demand expertise, Subagents to protect context, Agent Teams for parallel coordination, Hooks for deterministic safety, MCP for external reach, and Ollama for sovereign fallback. Every primitive in Part 1 is a force multiplier on the next. Lock them in now, and Part 2 is where you learn to build real production systems on top.

Continue to Part 2 · Production Playbook

Part 2 is where theory becomes muscle memory. 12 more modules: the complete 50+ command reference, git workflows for solo and team, the DDS Vibe Coding methodology (5 Pillars), build-along walkthroughs for a React app and a Shopify section, advanced multi-agent orchestration, cost control and rate limits, plugins and the ecosystem, deep IDE integration, three DDS case studies (VibeTube AI, Collection Hero Grid v4.2, SEO Magnet V2), the $250K cheat sheet, and what comes next.

Claude Code is Anthropic’s agentic coding tool that runs in your terminal, IDE, desktop app, browser, mobile, and Slack. Unlike autocomplete-style assistants, Claude Code is a full agent that reads your entire codebase, edits files, runs commands, executes tests, and manages git workflows through natural language. Anthropic reports that the majority of its own code is now written by Claude Code. It works with Opus 4.6, Sonnet 4.6, and Haiku 4.5.

On macOS and Linux, use Homebrew: brew install --cask claude-code for the stable channel, or claude-code@latest for the latest channel. On Windows, use WinGet: winget install Anthropic.ClaudeCode. Native Windows installs require Git for Windows. WSL setups do not. After install, navigate to your project directory and run claude. Installation via npm is deprecated as of 2026.

CLAUDE.md is your project’s always-on instructions file. Claude Code loads it into every prompt automatically. Put rules that apply to every task: code style, architecture decisions, preferred libraries, testing requirements, forbidden operations, communication conventions. Keep it under 200 lines — rules that only apply sometimes belong in Skills, which load on demand. Upper-path CLAUDE.md files load at session start; subdirectory files load when you work in those paths.

Yes. The Terminal CLI and VS Code extension support third-party providers including Ollama. Configure Claude Code to point at your local Ollama endpoint (typically 127.0.0.1:11434) and select a local coding model like qwen2.5-coder-14b for 12GB VRAM cards, or route to Ollama Cloud for free access to larger models like qwen3-coder:480b-cloud. The sovereign pattern is to use local Ollama for private inference and Anthropic API for frontier tasks.

Skills are Markdown-based workflows in .claude/skills/ directories containing a SKILL.md file with YAML frontmatter and optional scripts, references, and assets. They use progressive disclosure: Claude reads only the description at about 100 tokens per skill, and loads the full instructions (under 5000 tokens) only when relevant. Skills can auto-invoke when Claude detects a matching task, or run as explicit slash commands. As of 2026, the older .claude/commands/ format still works but skills take precedence on name conflicts.

A Subagent is a separate Claude instance that runs in its own context window, does a job, and returns only the results to your main conversation. Subagents report back to the parent and cannot talk to each other. Agent Teams, launched February 2026 alongside Opus 4.6, are multiple independent Claude sessions that coordinate via shared tasks and peer-to-peer messaging. Use subagents to protect your main context from heavy research. Use teams for parallel work that needs coordination.

Hooks are shell commands that fire automatically at Claude Code lifecycle events: PreToolUse before a tool runs, PostToolUse after, SessionStart at the start of a session, and others. Use them for deterministic control: auto-lint after file edits, block commits of sensitive files, send Slack notifications when the agent finishes, run tests before allowing git push. Hooks are what make it safe to run Claude Code unattended.

MCP (Model Context Protocol) lets Claude Code connect to external tools through standardized servers — databases, APIs, file systems, third-party services. You need it when your agent’s work requires data or actions beyond your codebase: querying Postgres, reading Shopify orders, sending email, browsing the web. Start with the safe set: Filesystem, Git, GitHub. Audit any server before installing — each one adds capability and attack surface in equal measure.

Sonnet 4.6 is the default for most daily work — strong enough for complex multi-file edits, fast enough for iteration, cheaper than Opus. Opus 4.6 is for the hard tasks: architecture decisions, large refactors, multi-hour autonomous engineering, complex debugging. Haiku 4.5 powers the built-in Explore subagent for fast read-only codebase analysis. The hybrid pattern — Sonnet as default, Opus on demand, Haiku for research — stretches your usage budget significantly.

Plan Mode (toggled with the /plan command) makes Claude propose each tool action and wait for your approval before executing it. Use it when working in an unfamiliar codebase, before a large refactor you want to review step by step, or any time you want to inspect what the agent is about to do before it does it. Plan Mode is your safety net when you are not ready to run in full auto-accept.

Claude Code maintains auto-memory in ~/.claude/projects/ tracking patterns it discovers across sessions — build commands, architectural decisions, coding preferences. The first 200 lines of MEMORY.md load at every session start. Use /memory to view and edit. You can also tell Claude things like “remember that we use Vitest, not Jest” and it will persist for future sessions. CLAUDE.md is your explicit version-controlled knowledge. Auto-memory is what Claude learned on its own.

Claude Code the tool is free to install. Usage is billed either through a Claude subscription (Pro/Team/Enterprise) or through Anthropic Console API credits. Claude Code is also included with Team plan Standard seats. Enterprise users can route through existing Amazon Bedrock or Google Cloud Vertex AI instances. Terminal CLI and VS Code extension also support third-party providers like Ollama for zero-cost local inference. Use /usage to check your plan limits and current consumption.