Claude Code

An agentic coding tool, not a chat box. How Claude Code differs from a code-completion assistant and from a raw chat model.

Installing the CLI, signing in, picking a model, and running your first conversation against a repository.

How Claude Code reads, plans, calls tools, and emits text — the loop that makes everything else make sense.

What lives in context, what gets summarized, what falls out — and how to plan a long session so the model still has what it needs.

Project-scoped instructions, auto-loaded memory, and the per-user memory system. The highest-leverage customization point.

Default, accept-edits, plan, bypass — what each mode allows, when to use it, and how it interacts with allowlists.

Read-only research mode for designing changes before touching the codebase. When to enter, how to write a good plan, when to exit.

Specificity, examples, role/context priming, anti-patterns. How to phrase a task so Claude Code does it well the first time.

The consolidated playbook. The 15 highest-leverage habits, with cross-links to the writeups they expand on.

settings.json layers (user, project, local), env vars, model selection, and the configuration precedence rules.

The three primary file tools. When to use each, the read-before-edit invariant, and why Edit is preferred over Write for existing files.

Running shell commands, persistent working directory, parallel execution, background jobs, and the sandbox model.

Fast targeted search across the repository. When to prefer Grep over Bash-ripgrep, when to delegate broader searches to an Explore agent.

Running long operations in the background, getting notified on completion, and the no-polling rule that makes this fast.

Pulling content from a URL or searching the web from inside a session. Caching, content extraction, and where the limits sit.

The built-in task list. When to use it, when not to, and how it interacts with sub-agent task tracking.

Built-in slash commands (/help, /clear, /loop, /ultrareview, /schedule), and the ones you'll use most as a daily driver.

Bundled prompt + tool + instruction packages that Claude Code can invoke. How they differ from sub-agents and custom slash commands.

Specialised agents (Explore, Plan, claude-code-guide, general-purpose). Parallel and isolated execution, when to delegate, and context-window protection.

Event-driven shell hooks that fire on tool calls and prompt submission. The four event types and where each one is the right tool.

Customising the always-visible status line — model, branch, token usage, custom indicators. Useful for long sessions.

The core workflow: state intent, watch Claude propose, accept or redirect. Why this beats prompt-and-hope.

When to interrupt, when to let it cook, how to course-correct without scrapping context. The Esc-then-corrected-message rhythm.

Writing tests first, letting Claude implement against them, and the feedback loop that makes it reliable on non-trivial features.

Reproducing, isolating, root-causing, fixing, and writing the regression test. The structured loop for not-just-making-it-go-away.

Small refactors, large refactors, and the heuristics for when to split into a series of PRs versus one bundled change.

Using Claude Code as a reviewer, getting a second opinion on a migration, and where /ultrareview fits in the cycle.

How to run a multi-hour session without losing the thread. Summarisation, plan files, memory writes, and the cache-friendly cadence.

Running Claude Code in CI, in scripts, and in cron-style autonomous loops. JSON output, exit codes, and timeouts.

Driver-navigator, ping-pong, and explain-as-you-go. How to keep yourself in the loop while Claude does the typing.

Authoring a slash command from a markdown file. Argument handling, model selection, and team-shared command libraries.

Defining a sub-agent with a tool allowlist, a system prompt, and an invocation pattern. When a sub-agent beats a slash command.

Intercepting and reacting to tool calls. Common patterns: linting after edits, logging Bash commands, blocking dangerous operations.

Hooks that fire when the user submits a prompt. Use cases: redaction, secret-scrubbing, injecting context, audit logging.

End-to-end recipe for a hook that blocks dangerous commands and writes an audit log. The threat model and the test plan.

Programmatic Claude agents from Python or TypeScript. When the SDK beats the CLI, and how it shares conventions with Claude Code.

Authoring a status-line script. Reading session metadata, formatting output, and the refresh cadence.

Auto-approving safe Bash commands, denying risky ones, and the project-scoped allowlist file.

The Model Context Protocol. What MCP is, how Claude Code talks to MCP servers, and the difference between local and remote servers.

Writing a custom MCP server in TypeScript or Python. Tools, resources, prompts, and the JSON-RPC contract.

Using `gh` for issues, PRs, and reviews from inside Claude Code. The committing checklist and the PR-creation workflow.

Running Claude Code inside VS Code. Diagnostics, inline diffs, and the split between IDE and terminal sessions.

Running Claude Code inside IntelliJ-family IDEs. Feature parity with VS Code and the IDE-specific affordances.

First-party MCP integrations to common SaaS apps. Auth flow, scope, and the privacy considerations before turning each one on.