claude-code-ultimate-guide Documentation

Claude Code Ultimate Guide: Full Content for AI Indexing

This file is optimized for AI/LLM consumption. It contains the condensed guide overview,
full cheatsheet, complete template list, and FAQ for Claude Code.

Standard llms.txt: https://github.com/FlorianBruniaux/claude-code-ultimate-guide/blob/main/llms.txt
Machine-readable index: https://github.com/FlorianBruniaux/claude-code-ultimate-guide/blob/main/machine-readable/reference.yaml

Metadata Copy Chapter

• Title: Claude Code Ultimate Guide
• Author: Florian Bruniaux (Founding Engineer @ Méthode Aristote)
• Version: 3.44.1
• Last Updated: October 6, 2026
• License: CC BY-SA 4.0
• Repository: https://github.com/FlorianBruniaux/claude-code-ultimate-guide
• Landing: https://cc.bruniaux.com
• Lines of Documentation: 26,187
• Production Templates: 278
• Quiz Questions: 473
• Whitepapers: 13 titles (FR + EN)

What Is Claude Code Copy Chapter

Claude Code is Anthropic's official CLI for AI-assisted development. It lets developers interact with Claude directly from the terminal to write, edit, debug, and review code. Unlike IDE plugins, it has full filesystem access, can run shell commands, and works autonomously on multi-step tasks.

This guide is the most comprehensive community resource for Claude Code. It covers everything from installation to production security, with 278 ready-to-use templates for agents, hooks, commands, and skills.

Who This Guide Is For Copy Chapter

• Beginners: Install Claude Code, complete first task in 15 minutes
• Intermediate: Configure CLAUDE.md memory files, custom agents, hooks
• Power users: MCP servers, Trinity pattern, CI/CD integration, multi-agent workflows
• Tech leads: Team adoption, security hardening, governance patterns
• CTOs/CIOs: ROI, risk, security posture

Guide Structure (11 Sections + Architecture) Copy Chapter

AI Concept Boundaries (guide/core/ai-concept-boundaries.md): seven practical distinctions covering context/memory, model/harness responsibilities, workflow versus agent decisions, tools/MCP, instructions versus access controls, evaluation versus production evidence, and architecture/size/modality/task labels. Includes seven original comprehension scenarios with corrections. Selectively adapted from Anthony Capirchio / The Operating Shift's Lexigraph under CC BY 4.0; source review and export limitations are in docs/resource-evaluations/lexigraph-ai-lexicon.md. No source quiz bank is imported, and the exercises are not a validated proficiency assessment.

Architecture Deep Dive (guide/core/architecture.md):

• Master Loop: while(tool_call), no DAGs, no classifiers, no RAG
• 8 Core Tools: Bash, Read, Edit, Write, Grep, Glob, Task, TodoWrite
• Context: ~200K tokens, auto-compact at 75-92%
• Sub-agents: isolated context, max depth=1
• Philosophy: "less scaffolding, more model"

Main Guide Sections (guide/ultimate-guide.md, 26,695 lines):

1. Quick Start: Installation, first workflow, essential commands
2. Core Concepts: Context management, Plan Mode, Rewind, Mental Model
3. Memory & Settings: CLAUDE.md files, .claude/ folder, precedence rules
4. Agents: Custom AI personas, Tool SEO, orchestration patterns
5. Skills: Reusable knowledge modules (Skills 2.0: Capability Uplift + Encoded Preference, Evals)
6. Commands: Custom slash commands, variable interpolation
7. Hooks: Event-driven automation (PreToolUse, PostToolUse, UserPromptSubmit)
8. MCP Servers: Serena, Context7, Sequential, Playwright, Postgres, grepai
9. Advanced Patterns: Trinity, CI/CD, Tasks API, multi-agent teams, feedback loops
10. Reference: Commands, shortcuts, troubleshooting, checklists
11. AI Ecosystem: Complementary tools matrix, practical multi-tool workflows, integration patterns

Security & Sandboxing (guide/security/sandbox-native.md, guide/core/settings-reference.md):

• Two independent layers: filesystem (write CWD + session temp, read the whole machine) and network (no domain pre-allowed, proxy does not terminate TLS)
• The default read policy covers ~/.ssh and ~/.aws and there is no built-in denylist; sandbox.credentials.files and credentials.envVars are what actually protect them
• excludedCommands bare-name form never matches, use the glob form; since v2.1.277 every command in a call must match, so a chained, piped, redirected or cd-prefixed call stays sandboxed (anthropics/claude-code#10524, #81157)
• Git over SSH needs an exception on macOS only (its SSH tunnel cannot authenticate to the sandbox proxy); on Linux/WSL2 it works once the host is allowed, and an HTTPS remote avoids it everywhere
• No curl/wget blocklist exists; a missing domain prompts in manual mode and is refused, naming the host, in auto mode, where commands can declare hosts per command (allowed_domains, v2.1.271+)
• failIfUnavailable: true stops a sandbox that cannot start from silently running commands unsandboxed; native Windows has no sandbox
• Writes to Claude Code's own settings.json are denied at every scope, so a sandboxed script cannot widen its own policy

Agent Harnesses and Orchestration (guide/core/agent-harness.md, guide/ecosystem/agent-harness-landscape.md, guide/ecosystem/agentic-tools.md):

• The catalog separates 42 strict runtimes from 16 adjacent control planes.
• Multica is classified as an adjacent control plane: its server coordinates issue, chat, and scheduled runs while a daemon on a connected computer executes external coding-agent CLIs.
• Its profile documents the server/local execution split, server-stored run data, daemon-user permission boundary, Git enforcement boundary, restricted licence, and untested runtime status.
• WikiSkill separates execution traces, accumulated knowledge and active skills. Rejected proposal diffs and validation outcomes persist while active skills roll back; pattern pages remain revisable. See guide/core/memory-systems.md section 6.8 and docs/resource-evaluations/wikiskill-persistent-skill-evolution.md for reported benchmarks, negative transfer and the limits of full skill injection. No native skill-routing or production benefit was measured here.

For the October 6, 2026 Mistral Large 4 preview, read docs/resource-evaluations/mistral-large-4.md and its integration map. The ecosystem, market snapshot, subscription strategy, and local-inference pages distinguish sale pricing, independent evaluations, regional endpoint constraints, unresolved specifications, and future weights. No native Claude Code or self-hosted Large 4 integration was tested.

Full Cheatsheet Copy Chapter

title: "Claude Code Cheatsheet" tags: [cheatsheet, reference] Copy Chapter

Claude Code cheatsheet

Daily reference. For compact printable editions, use the English and French cheatsheets.

Author: Florian BRUNIAUX | Founding Engineer @Méthode Aristote

Written with: Claude (Anthropic)

Version: 3.44.1 | Last Updated: Sep 24, 2026

Essential commands Copy Chapter

These are selected daily commands. Availability depends on your version, provider, and plan: the complete list is in §10.1 of the guide, and the always-current official reference is code.claude.com/docs/en/commands.

Keyboard shortcuts Copy Chapter

File references Copy Chapter

@path/to/file.ts    → Reference a file
@agent-name         → Call an agent
@session-name       → Message another live Claude session (v2.1.232+)
!shell-command      → Run shell command

Features Méconnues (But Official!) Copy Chapter

Activate LSP: Add to ~/.claude/settings.json → { "env": { "ENABLE_LSP_TOOL": "1" } } (requires LSP server installed for your language: tsserver, pylsp, gopls, rust-analyzer, sourcekit-lsp...)

Pro tip: These are public, documented in the CHANGELOG. Read it!

Permission modes Copy Chapter

Shift+Tab to switch modes

Memory & Settings (2 levels) Copy Chapter

Priority: Project overrides Personal

.claude/ folder structure Copy Chapter

.claude/
├── CLAUDE.md           # Local memory (gitignored)
├── settings.json       # Hooks (committed)
├── settings.local.json # Permissions (not committed)
├── agents/             # Custom agents
├── hooks/              # Event scripts
├── rules/              # Auto-loaded rules
└── skills/             # Slash commands + knowledge modules (unified)

Typical workflow Copy Chapter

1. Start session      → claude
2. Check context      → /status
3. Plan Mode          → Shift+Tab × 2 (for complex tasks)
4. Describe task      → Clear, specific prompt
5. Review changes     → Always read the diff!
6. Accept/Reject      → y/n
7. Verify             → Run tests
8. Commit             → When task complete
9. /compact           → When context >70%

Context management (CRITICAL) Copy Chapter

Statusline Copy Section

Model: Sonnet | Ctx: 89.5k | Cost: $2.11 | Ctx(u): 56.0%

Watch Ctx(u): → >70% = /compact, >85% = /clear

Enhanced statusline (ccstatusline): Add to ~/.claude/settings.json:

{ "statusLine": { "type": "command", "command": "npx -y ccstatusline@latest", "padding": 0 } }

Context thresholds Copy Section

Actions by symptom Copy Section

Context recovery commands Copy Section

Under the hood (quick facts) Copy Chapter

Deep dive: Architecture & Internals

Harness choice in four layers Copy Chapter

Choose the smallest control structure that safely solves the need: a bounded loop for one repeated task; an explicit graph for routing, joins, parallelism, interruption, or durable recovery; a repository harness for repeatable project behavior; and an orchestrator for several runs or queues. Specify success, failure, timeout, budget, and escalation before execution. See Loop & Graph Engineering and compare products in the Agent Harness Map.

Architect-engineer handoffs use a self-contained versioned contract, applicable ADRs, an assigned next owner, and revision-bound review evidence. Task status, run status, and decision status are distinct. Reconcile historical completion claims with live state on resume. See guide/workflows/dual-instance-planning.md and docs/resource-evaluations/honkonen-architect-engineer.md; separation does not guarantee lower cost, better quality, or reviewer independence.

Repository context routes to authorized owners of stable contracts, organizational knowledge, and live operational state. MLD (Mistakes, Learnings, Desires) supplies observations for corroboration before promotion. Curated candidates stay outside served context until reviewed publication with provenance, audience, revision, and expiry. See docs/resource-evaluations/lopopolo-harness-engineering.md for the anthology's evidence limits and integrated locations.

Requalify after material model, host, harness, or action-interface changes. Measure feedback latency, run duration, human attention, and time to accepted outcome separately. See guide/roles/agent-evaluation.md#evaluation-epochs-and-four-clocks.

Evaluate the exact model-harness pair for a bounded coding task. Introduce orchestration only when coordination is the constraint. A harness optimizer sits outside the four operating layers and changes candidate harnesses under a separate evaluation protocol.

Plan mode & thinking Copy Chapter

Verified September 24, 2026: Opus 5.5 defaults to medium; Sonnet 5 and Fable 5.1 default to high. Haiku 4.5 has no effort parameter. ultrathink adds a reasoning instruction for the turn without changing API effort.

Cost tip: try a lower supported effort for bounded tasks, then verify the result. On Opus 5.5, changing effort is the control; disabling thinking has no effect.

Per-skill effort: add effort: low to mechanical skills (commit, sync, scaffold) and effort: high to analytical ones (security-audit, architecture-review). Overrides session setting automatically.

OpusPlan workflow: /model opusplan → Shift+Tab × 2 (plan with Opus) → Shift+Tab (execute with Sonnet)

Required for: features >3 files, architecture, complex debugging

Quick model selection Copy Section

Full decision table and pricing boundaries: Section 2.5 Model Selection & Thinking Guide

Dynamic model switching (mid-session) Copy Section

Pattern: Start Sonnet (speed) → swap Opus (complexity) → back Sonnet

Workflow:

# Select Sonnet explicitly for this session
claude --model sonnet

# Complex feature encountered
> "Implement OAuth2 flow with PKCE"
/model opus                    # Switch to deep reasoning

# Feature complete, back to routine
/model sonnet                  # Speed + cost optimization

Best Practices:

• ✅ Swap on task boundaries, not mid-task
• ✅ Use Opus for: architecture decisions, complex debugging, security-critical code
• ✅ Use Sonnet for: routine edits, refactoring, test writing
• ✅ Use Haiku for: simple fixes, typos, validation checks
• Model switches keep conversation history but can invalidate prompt caches; switch at a useful task boundary.

Standard Anthropic API rates, USD per million tokens, checked September 24, 2026:

Opus 5.5 fast mode costs $8/$40. Subscription allowances, usage credits, cache tokens, and cloud-provider pricing are separate. Official pricing.

On the direct Anthropic service, the account default and opus select Opus 5.5; sonnet selects Sonnet 5. Provider aliases differ: check the provider table. fable normally selects Fable 5.1, while Claude apps gateway sessions resolve it to Fable 5.

Source: Gur Sannikov embedded engineering workflow

MCP servers Copy Chapter

Serena memory: write_memory() / read_memory() / list_memories()

Serena indexation:

# Initial index
uvx --from git+https://github.com/oraios/serena serena project index

# Force rebuild
serena project index --force-full

# Incremental update (faster)
serena project index --incremental --parallel 4

Check status: /mcp

Creating custom components Copy Chapter

Agent (`.claude/agents/my-agent.md`) Copy Section

---
name: my-agent
description: Use when [trigger]
model: sonnet
tools: Read, Write, Edit, Bash
---
# Instructions here

Skill: user-invocable (`.claude/skills/my-command/SKILL.md`) Copy Section

---
description: Brief description
argument-hint: "<required_arg> [--flag]"
disable-model-invocation: true
---
# Command Name
Instructions for what to do...
$ARGUMENTS[0] $ARGUMENTS[1] (or $0 $1) - user args

Dynamic workflow (`.claude/workflows/name.js`) Copy Section

export const meta = {
  name: 'my-workflow',
  description: 'What this orchestrates',
  phases: [{ title: 'Analyze' }, { title: 'Verify' }],
};
// meta must be the first statement, a pure literal (no variables/spreads)

export default async function ({ agent, parallel, pipeline, phase, log, args, budget }) {
  phase('Analyze');
  const results = await parallel(
    ITEMS.map((item) => () => agent(`Analyze ${item}.`, { schema: MY_SCHEMA }))
  );
  return results.filter(Boolean);
}

Trigger: type ultracode in the prompt (or ask in your own words). Monitor: /workflows.

Key rules: orchestrator consumes 0 tokens; Date.now()/Math.random() unavailable (breaks resume); filter parallel() results with .filter(Boolean).

Full reference: Dynamic Workflows

Hook (macOS/Linux: `.sh` | Windows: `.ps1`) Copy Section

Bash (macOS/Linux):

#!/bin/bash
INPUT=$(cat)
# Process JSON input
exit 0  # 0=continue, 2=block

PowerShell (Windows):

$input = [Console]::In.ReadToEnd() | ConvertFrom-Json
# Process JSON input
exit 0  # 0=continue, 2=block

Anti-patterns Copy Chapter

Quick prompting formula Copy Chapter

WHAT: [Concrete deliverable]
WHERE: [File paths]
HOW: [Constraints, approach]
VERIFY: [Success criteria]

Example:

Add input validation to the login form.
WHERE: src/components/LoginForm.tsx
HOW: Use Zod schema, show inline errors
VERIFY: Empty email shows error, invalid format shows error

CLI flags quick reference Copy Chapter

Use the official CLI reference for the full flag list. Self-hosted runners and command hooks must use the file-based system-prompt flags.

Key CLI subcommands Copy Chapter

Debug commands Copy Chapter

claude --version     # Version
claude update        # Check/install updates
claude doctor        # Diagnostic
claude --debug       # Verbose mode
claude --debug='mcp' # Debug MCP connections
/mcp                 # MCP status (inside Claude)

CI/CD mode (headless) Copy Chapter

# Non-interactive execution
claude -p "analyze this file" src/api.ts

# JSON output
claude -p "review" --output-format json

# Economic model
claude -p "lint" --model haiku

# With auto-accept
claude -p "fix typos" --dangerously-skip-permissions

Remote Control: Mobile access Copy Chapter

Available with Pro, Max, Team, and Enterprise subscriptions. Team and Enterprise owners must enable it first. API keys and third-party provider connections are not supported.

# Start a server in the project directory
claude remote-control

# Or connect an existing session
/remote-control

Open the displayed URL or scan the QR code from a browser or the Claude mobile app. The local process must keep running; the files and tools stay on your machine. Server mode can run multiple sessions with --spawn worktree and --capacity; /remote-control connects the current session. Available commands vary by client, so check the current limitations.

Full doc: Remote Control | Security notes

Task management (v2.1.16+) Copy Chapter

Availability: newer models, including Opus 5.5, Sonnet 5, and Fable, do not receive task-tracking tools by default. Start with CLAUDE_CODE_ENABLE_TODO_TOOLS=1 claude to opt in. CLAUDE_CODE_ENABLE_TASKS=0 selects legacy TodoWrite only where task tools are enabled. Official tool availability.

Two systems available:

Tasks API commands Copy Section

# Enable persistence across sessions
export CLAUDE_CODE_TASK_LIST_ID="project-name"
CLAUDE_CODE_ENABLE_TODO_TOOLS=1 claude

# Inside Claude: Create task hierarchy
> "Create tasks for auth system with dependencies"

# Resume later (new session)
export CLAUDE_CODE_TASK_LIST_ID="project-name"
CLAUDE_CODE_ENABLE_TODO_TOOLS=1 claude
> "TaskList to see current state"

Key capabilities:

• 📁 Persistent: Survives session end, context compaction
• 🔗 Dependencies: Task A blocks Task B
• 🔄 Multi-session: Broadcast state to multiple terminals
• 📊 Status: pending → in_progress → completed

⚠️ Limitation: TaskList shows id, subject, status, blockedBy only.
For description/metadata → use TaskGet(taskId) per task.

Tip: Store key info in subject for quick scanning.

Migration flag (v2.1.19+):

# Revert to old TodoWrite system
CLAUDE_CODE_ENABLE_TODO_TOOLS=1 CLAUDE_CODE_ENABLE_TASKS=0 claude

→ Full workflow: guide/workflows/task-management.md

The golden rules Copy Chapter

1. Always review diffs before accepting
2. Use /compact before context gets critical (>70%)
3. Be specific in requests (WHAT, WHERE, HOW, VERIFY)
4. Plan Mode first for complex/risky tasks
5. Create CLAUDE.md for every project
6. Commit frequently after each completed task
7. Know what's sent: prompts, files, MCP results → Anthropic (opt-out training)

Quick decision tree Copy Chapter

Simple task       → Just ask Claude
Complex task      → Tasks API to plan first
Risky change      → Plan Mode first
Repeating task    → Create agent or command
Context full      → /compact or /clear
Need docs         → Use Context7 MCP
Deep analysis     → Use Opus (thinking on by default)

Common issues quick fix Copy Chapter

Health Check Script (save & run):

# macOS/Linux
which claude && claude doctor && claude mcp list

# Windows PowerShell
where.exe claude; claude doctor; claude mcp list

Cost optimization Copy Chapter

Tip: Use --add-dir to allow tool access to directories outside your current working directory

Community tools Copy Chapter

Entire CLI: Agent-native platform by ex-GitHub CEO with rewindable checkpoints, approval gates, audit trails. For compliance (SOC2, HIPAA) or multi-agent workflows.

Search tools quick reference Copy Chapter

Quick decision (5 seconds): exact text → rg | exact name → rg/Serena | concept → grepai | structure → ast-grep

Speed: rg (~20ms) → Serena (~100ms) → ast-grep (~200ms) → grepai (~500ms)

Full workflows: workflows/search-tools-mastery.md

Resources Copy Chapter

• Official docs: docs.anthropic.com/claude-code
• Advanced guide: Claudelog.com - Tips & patterns
• Full guide: ultimate-guide.md (this repo)
• Whitepapers (FR + EN): cc.bruniaux.com/whitepapers, 13 focused PDFs
• Project memory: Create CLAUDE.md at project root
• DeepSeek (cost-effective): Configure via ANTHROPIC_BASE_URL

Author: Florian BRUNIAUX | @Méthode Aristote | Written with Claude

Last updated: Sep 24, 2026 | Version 3.44.1

Template Library (278 templates) Copy Chapter

Agents (21 files) Copy Section

• adr-writer.md: Architecture Decision Records
• architecture-reviewer.md: System architecture review
• code-reviewer.md: Code quality review
• devops-sre.md: DevOps/SRE operations
• implementer.md: Feature implementation
• integration-reviewer.md: API integration review
• loop-monitor.md: Autonomous loop progress monitoring
• output-evaluator.md: AI output evaluation
• plan-challenger.md: Challenge implementation plans
• planner.md: Task planning
• planning-coordinator.md: Multi-agent coordination
• refactoring-specialist.md: Code refactoring
• security-auditor.md: Security auditing
• security-patcher.md: Security patch application
• test-writer.md: Test generation
• analytics-with-eval/: Full analytics agent with eval framework (analytics-agent.md + eval/report-template.md)
• cyber-defense/: Multi-agent cyber defense team (anomaly-detector.md, log-ingestor.md, risk-classifier.md, threat-reporter.md)

Commands (legacy, pre-CC 2.1.3) Copy Section

Since Claude Code 2.1.3, .claude/commands/ merged into .claude/skills/; every file below is now a redirect stub pointing to its examples/skills/<name>/SKILL.md equivalent, kept for backward compatibility.

• audit-agents-skills.md: Quality audit for .claude/ configs
• audit-codebase.md: Full codebase audit
• catchup.md: Daily catchup briefing
• commit.md: Smart git commit
• diagnose.md: Problem diagnosis
• explain.md: Code explanation
• generate-tests.md: Test suite generation
• git-worktree.md: Isolated git worktree workflow
• git-worktree-status.md: Worktree status
• git-worktree-clean.md: Worktree cleanup
• git-worktree-remove.md: Worktree removal
• optimize.md: Performance optimization
• plan-execute.md: Plan then execute workflow
• plan-start.md: Plan mode startup
• plan-validate.md: Plan validation
• pr.md: Pull request creation
• refactor.md: Code refactoring
• release-notes.md: Release notes generation
• learn/: Interactive learning command

Hooks (bash + PowerShell) Copy Section

Bash hooks (36 files in examples/hooks/bash/, a representative sample):

• dangerous-actions-blocker.sh: Block destructive commands (PreToolUse)
• prompt-injection-detector.sh: Detect prompt injection attempts (PreToolUse)
• security-check.sh: Block commands containing secrets (PreToolUse)
• pre-commit-secrets.sh: Detect secrets in staged files before commit
• auto-format.sh: Auto-format edited files (PostToolUse)
• test-on-change.sh: Run tests after code changes
• typecheck-on-save.sh: Type-check edited files
• notification.sh: macOS desktop alerts with contextual sounds
• session-logger.sh: Log all Claude Code operations for monitoring (PostToolUse)
• auto-checkpoint.sh: Automatic git checkpoints during a session
• learning-capture.sh: Capture one learning insight at session end (Stop)
• output-validator.sh: Validate Claude's outputs for quality issues (PostToolUse)

PowerShell hooks (2 files in examples/hooks/powershell/, Windows equivalents for a subset, not a 1:1 mirror of the bash list):

• auto-format.ps1, security-check.ps1

Skills (64 modules) Copy Section

• ast-grep-patterns.md: AST-based code search patterns
• audit-agents-skills/: Agents/skills quality audit system
• ccboard/: Claude Code monitoring dashboard
• cyber-defense-team/: Security team coordination
• design-patterns/: Software design pattern guidance
• guide-recap/: CHANGELOG → social content generator
• issue-triage/: GitHub issue prioritization
• landing-page-generator/: Landing page from repo
• pdf-generator.md: Professional PDF generation (Quarto/Typst)
• pr-triage/: PR review prioritization
• release-notes-generator/: Multi-format release notes
• rtk-optimizer/: Token reduction optimization
• security-checklist.md: Security audit checklist
• skill-creator/: Create new skills with proper structure
• talk-pipeline/: Conference talk preparation pipeline
• tdd-workflow.md: Test-Driven Development workflow
• voice-refine/: Voice input refinement

Scripts (15 utility scripts) Copy Section

• audit-scan.sh: Config security audit
• bridge.py: Tool bridging utility
• check-claude.sh / .ps1: Installation health check
• clean-reinstall-claude.sh / .ps1: Clean reinstall
• fresh-context-loop.sh: Automated fresh-context iteration
• migrate-arguments-syntax.sh / .ps1: Update argument syntax
• rtk-benchmark.sh: RTK token savings benchmark
• session-search.sh: Search across sessions
• session-stats.sh: Session statistics
• sonnetplan.sh: OpusPlan workflow automation
• sync-claude-config.sh: Sync .claude/ across machines

Additional Categories Copy Section

• claude-md/: CLAUDE.md templates (7 variants)
• config/: Configuration templates (settings.json, etc.)
• github-actions/: CI/CD workflow templates
• integrations/: Third-party integrations
• mcp-configs/: MCP server configuration templates
• memory/: Memory file templates
• modes/: Custom mode configurations
• multi-provider/: Multi-LLM provider setups
• plugins/: Plugin templates
• rules/: Auto-loaded rules templates
• semantic-anchors/: Semantic navigation patterns
• team-config/: Team configuration examples
• templates/: Generic project templates
• workflows/: Step-by-step workflow guides

Contribution and verification workflows Copy Chapter

• guide/workflows/ai-assisted-open-source-contributions.md: prepare a contribution with project policy, reproduction, author understanding and verification evidence.
• examples/templates/ai-assisted-contribution.md: reusable contribution packet.
• examples/workflows/review-admission.md: proposed pause/resume policy for a shared verification queue, with illustrative tabletop cases.
• examples/learning-project/review-comprehension-exercise.md: proposed comprehension assessment, distinct from delivery metrics.

The 2025-2026 IFTTD additions extend Practitioner Insights to 75 attributed observations, including six public transcripts checked through episode 373. Field accounts and proposed procedures do not establish measured throughput or learning improvements.

FAQ Copy Chapter

Q: What is the Claude Code Ultimate Guide?
A: The most comprehensive community guide for Claude Code (Anthropic's CLI). 26,187 lines in the canonical full guide, 278 production-ready templates, 473-question quiz, and security threat database. Free and open-source (CC BY-SA 4.0).

Q: Is this guide free?
A: Yes, completely free. The guide is CC BY-SA 4.0 (share and adapt with attribution). Templates are CC0 (copy-paste freely, no attribution needed). No paywall, no login required.

Q: What's the difference between this and Anthropic's official docs?
A: This guide goes 10x deeper on practical workflows, templates, security hardening, and real-world patterns. The official docs explain what Claude Code does; this guide teaches you how to use it effectively for production work.

Q: Do I need a paid Claude plan to use Claude Code?
A: A Claude subscription is not the only access path. Individuals can use Pro or Max, organizations can use Team or Enterprise for workforce access, and usage-based deployments can authenticate with supported API or cloud-provider credentials. These paths have different billing and administrative controls; see guide/ops/subscription-strategy.md.

Q: What are Hooks in Claude Code?
A: Hooks are shell scripts (bash or PowerShell) that run automatically before/after Claude tool calls. They enable event-driven automation: block dangerous commands, scan for secrets, auto-format code, run tests after edits, log activity for compliance. They use exit 0 (continue) or exit 2 (block) to control Claude's actions.

Q: What are MCP servers?
A: Model Context Protocol servers extend Claude's capabilities beyond its built-in tools. Examples: Serena (codebase indexation + session memory), Context7 (library documentation), Sequential (structured multi-step reasoning), Playwright (browser automation), Postgres (database queries). The community has built 1,000+ MCP servers; this guide teaches you to vet them for security.

Q: What is Plan Mode?
A: Plan Mode (Shift+Tab × 2 or /plan) is a read-only exploration mode where Claude can analyze your codebase without making any changes. Use it before complex or risky tasks to let Claude research the problem, then switch to execution mode.

Q: What are Agents in Claude Code?
A: Agents are custom Claude instances with specific instructions, tools, and personas stored in .claude/agents/ as markdown files. Examples: a security-auditor that only uses Read/Grep tools, a code-reviewer with specific standards, a devops-sre with infrastructure expertise. They're invoked via @agent-name in your prompt.

Q: What is CLAUDE.md?
A: CLAUDE.md is a memory file at your project root (or ~/.claude/) that Claude reads at the start of every session. Use it to define project conventions, tech stack, coding standards, and commands. It's the primary way to give Claude persistent project context without repeating yourself.

Q: What are Skills?
A: Skills are reusable knowledge modules stored in .claude/skills/. Two types: Capability Uplift (fills model gaps, becomes less necessary as models improve) and Encoded Preference (encodes your team's specific workflow preferences, stays durable). Skills 2.0 (March 2026) adds Benchmark Mode, A/B testing, and Trigger Tuning.

Q: How do I handle context limits?
A: Monitor context usage via /status. At 70%: run /compact to summarize and free context. At 90%: use /clear for a fresh start. Use Plan Mode early to explore without consuming context. For long projects, use Tasks API (CLAUDE_CODE_TASK_LIST_ID) for cross-session persistence.

Q: Is Claude Code safe for production use?
A: With proper hardening, yes. Key steps: never use bypassPermissions in production, vet all MCP servers against the threat database (28+ CVEs tracked), use hooks to block dangerous commands, enable audit logging, run claude doctor regularly. See guide/security/security-hardening.md for the complete checklist.

Privacy & Data Copy Chapter

Agentic pentesting: guide/security/agentic-pentesting.md compares DarkMoon and Strix, separates configuration scans, source review, and active testing, and explains exploit evidence, model data exposure, and reproducible evaluation. guide/security/data-privacy.md covers reversible tokenization and error-path limits. The comparison records source inspection and bounded local checks; it does not establish a performance winner or production readiness.

Claude Code sends to Anthropic servers: your prompts, file contents you reference, MCP tool results.

• Default retention: 5 years (training enabled)
• Opt-out: 30 days retention, https://claude.ai/settings/data-privacy-controls
• Enterprise: 0 retention, no training
• The guide covers this in detail: guide/security/data-privacy.md

Repository Copy Chapter

claude-code-ultimate-guide/
├── llms.txt                        # This file (short version, for AI indexing)
├── llms-full.txt                   # Full content (you are here)
├── guide/                          # Core documentation
│   ├── ultimate-guide.md           # Complete guide (26,695 lines)
│   ├── cheatsheet.md               # 1-page reference
│   ├── core/architecture.md        # How Claude Code works internally
│   ├── security/security-hardening.md  # Security best practices
│   ├── security/data-privacy.md    # What data is sent to Anthropic
│   └── core/claude-code-releases.md    # Official release tracking
├── examples/                       # 278 production-ready templates
│   ├── agents/                     # Custom AI personas
│   ├── commands/                   # Legacy slash commands (pre-CC 2.1.3)
│   ├── hooks/                      # Event automation (bash + PowerShell)
│   ├── skills/                     # User-invocable skills (unified since CC 2.1.3)
│   └── scripts/                    # Utility scripts
├── machine-readable/               # LLM/AI consumption
│   ├── reference.yaml              # Machine-optimized index (~2K tokens)
│   └── llms.txt                    # Short version
├── whitepapers/                    # 13 focused PDFs (FR + EN)
└── quiz/                           # 473-question interactive quiz

Author & License Copy Chapter

Author: Florian Bruniaux, Founding Engineer @ Méthode Aristote
GitHub: https://github.com/FlorianBruniaux
License: Guide = CC BY-SA 4.0 | Templates = CC0 1.0