Learn to use Claude well

From a hand-written character dictionary to real subword tokenizers: how text becomes the numbers a model reads, and why that changes cost.

What each Claude Code permission mode auto-approves, how to write allow and deny rules, and how to hand it more autonomy without handing it your machine.

Read a diff, approve or redirect each edit, and keep every change easy to undo, so you can move fast with a coding agent and still trust what lands.

The techniques that separate power users from casual ones: plan mode, effort, subagents, parallel worktrees, hooks, MCP, context control, and rewind.

The difference between durable memory, the live session state of a run, and files on disk, plus how to resume a session and rewind a bad edit.

Retrieval is a design choice you make on purpose. Learn when pasting the whole document works and when to inject only the parts the task needs.

The full Claude Code memory stack, from CLAUDE.md to auto memory, plus when to /clear, when to /compact, and how to keep it clean.

A million tokens sounds infinite. See what it buys you in code, what still gets missed, and why targeted context beats stuffing the window.

Log prompts, tool calls, latencies and outcomes so you can trace a bad AI answer back to its cause and fix the step that failed.

Build a small evaluation set, score outputs against it, and run it on every change so you catch quality regressions before your users do.

A decision guide for choosing between hands-on Claude Code and delegated Claude Cowork, with the task types each one fits.

Where an AI system actually spends money, tokens, retries, oversized contexts, the wrong model, and the levers that cut spend without hurting quality.

What changes when an agent leaves your laptop: where it runs, how it gets secrets and tools, and the smallest safe first deployment.

Set Claude Cowork up to succeed: point it at the right files, paste the ticket, name the constraints, and say what it should leave alone.

Why agents forget between steps, and three simple ways to carry knowledge forward: passing state, scratch space, and stored notes.

What a tool is for an agent, how to describe one clearly, and why the description decides whether the agent picks the right tool.

Guardrails are the checks around a model that validate inputs and outputs, block unsafe actions, and fail safely without making the system useless.

Models time out, refuse, and return junk: design retries, fallbacks, validation, and clear failure messages so one bad call does not take the system down.

Give each parallel coding agent its own git worktree so two sessions on the same repo never overwrite each other's uncommitted work.

Bound an agent with a clear goal, a tool allow-list, step limits, checks, and stop conditions so it finishes instead of looping.

Give an agent real-world abilities by connecting MCP servers, and decide which servers and permissions it gets so it stays safe and useful.

A repeatable way to review autonomous work safely before you merge it, so you trust the code instead of hoping it is fine.

What breaks when AI traffic grows (rate limits, queues and slow calls) and the patterns that keep your system responsive under load.

A debugging loop for AI agents: trace every step, reproduce the bad run, find the one weak step and tighten it until the agent behaves.

One agent splits a job, hands each piece to a worker in its own context, then combines the results. Learn when that beats a single agent.

Hand a bug to Claude Cowork with a symptom, a way to reproduce, the suspected area, and a clear pass condition, then review the diff it returns.

Hand Claude Cowork the work people skip: tests for behaviour you already shipped and fresh docs, with a brief that keeps the output in your house style.

When to let Claude reason step by step before it answers, how to ask for it from the Claude Code CLI, and the tasks where thinking first pays off.

Split a large request into a plan and small steps so Claude has clear targets, and use plan mode in Claude Code to review the plan before code changes.

The end to end shape of a basic RAG flow: ingest, embed, retrieve, then answer with Claude, built through the Claude Code CLI.

What a vector database does and how to pick one: pgvector for a small project, a dedicated vector store once you need production scale and speed.

Split documents into retrievable chunks: sensible sizes, overlap, structure-aware boundaries, and the metadata that makes each chunk findable.

Set up the GitHub MCP server so Claude reads issues, pull requests, and code from your repos directly, with no more copy and paste between tabs.

Give Claude safe, read-only access to a Postgres database through an MCP server: how to wire it up and what to lock down.

Point Claude at a folder of notes or docs through a filesystem MCP server so it answers questions from your own files instead of guessing.

What an embedding is in plain English: a list of numbers that captures meaning, so you can search by what text means instead of the exact words it uses.

Measure whether your RAG setup answers well: build a labelled question set, score retrieval and generation separately, and track the results.

Choose what goes in the prompt so Claude has everything the task needs, without burying the important parts under noise and extra detail.

A repeatable loop for diagnosing a bad result and tightening your prompt until Claude gives you what you want, every time you run it.

A debugging checklist for a dead MCP connection covering the command path, args, env, logs, and how to test the server on its own.

Telling Claude who to be and how to sound changes which facts it surfaces, how deep it goes, and how the final answer reads to you.

Add a web search MCP server and the official fetch server so Claude Code can look things up online and read live web pages for you.

Run keyword search and embedding search together, then fuse the two ranked lists so you catch exact terms and meaning in one query.

Add an MCP server to Claude Code in three steps: register it, confirm it connects, and watch Claude call its tools for the first time.

Keep retrieval accurate as your documents change: re-index updates, sync deletions, and clear out stale content on a regular schedule.

When to run an MCP server as a local subprocess versus connect to one hosted over HTTP, and the trade-offs each choice carries.

Improve retrieval so Claude gets the right passages every time: better chunks, sharper queries, and metadata filters that cut the noise.

The permissions, secrets, and scopes to settle before you connect an MCP server, and how to keep every connection least-privilege.

When pasting documents straight into the prompt is enough, when you need retrieval instead, and how to tell which one your task needs.

Add a reranking step to your RAG pipeline so the most relevant passages reach Claude first, instead of getting buried under near-misses.

Turn a prompt that worked into a reusable slash command with slots, then keep a small library of templates you reuse across projects.

Check MCP server config into the repo so everyone gets the same tools, and keep secrets out of the file with environment variable expansion.

A couple of worked examples in the prompt teach Claude the exact format and quality you want, and they work better than describing it in prose.

Four ways to cut Claude hallucinations: ask for sources, let it say it does not know, ground claims in your text, and verify before you trust.

A system prompt is the standing instruction that tells a model who it is and how to behave, applied to every reply in a session.

Expose one endpoint of your own API to Claude as a single MCP tool, with a clear input schema and a quick CLI test loop.

A clear instruction names four things (the task, the inputs, the output you want and the limits) so Claude does the work you meant.

What an AI coding agent actually does, the ways Claude Code can help day to day, and how to set it up well from your very first session.

A catalogue of the nine recurring patterns in AI engineering, what each one does, when to reach for it, and the trade you accept when you do.

Stand up a working MCP server with the official SDK, expose a tool and a resource, and connect it to a real client so Claude can use it right away.

Build production agents on the harness behind Claude Code: built-in tools, permissions, sessions, and your own custom tools, all from one SDK.

A tour of the Claude Code slash commands and skills worth knowing, what each one does, when to reach for it, and which ones you can safely ignore.

Automate formatting, linting, and logging around every tool call, and lock down what an agent is allowed to do with permission modes and deny lists.

Install a terminal coding agent, authenticate, point it at a real project, and ship your first committed change in about ten minutes.

Plan mode, memory, subagents, hooks, and code review: the everyday habits that make Claude Code fast, predictable, and safe to use on real projects.

Let Anthropic run the agent loop and sandbox for you. Define an agent once, then drive it over a simple REST API without managing any infrastructure.

Fill the context window with exactly what the model needs, in the right order, and prune everything else so answers stay accurate and costs stay low.

The context window is an agent's only working memory. What you load, what you leave out, and the order you use decide whether it succeeds or spirals.

Hand Claude a folder and a plain-English brief, and Cowork handles the steps, edits, and results while you watch or step away.

A clear anatomy of what Claude Code is under the hood, so you can configure it, extend it, and trust it on real work in your own projects.

A plain walkthrough of tokens, embeddings, probabilities and sampling, and why predicting the next word adds up to such capable behaviour.

How a coding agent splits work across subagents that each run in their own context, and why a subagent can inherit the main model or use a cheaper one.

Write self-contained task briefs that give Claude Cowork everything it needs to finish the job without stopping to ask you questions halfway through.

The rules file Claude Code reads on every request: what belongs in CLAUDE.md, what to leave out, and how to keep it lean so it sticks.

The habits that separate power users from casual users of Claude Code, from a tight CLAUDE.md to plan mode, subagents and reviewing the diff.

The building blocks of LangChain (models, prompts, tools and chains) in plain English, plus when a plain provider SDK is all you need.

Model an agent's control flow as a graph of state, nodes and edges, and learn the loops that let an agent act, check its work and pause.

Add, scope, and debug MCP servers across Claude Code and Claude Desktop, with real config and fixes for the usual failures.

What the Model Context Protocol is, the problem it solves, its three server primitives, and how a request flows from start to finish.

Patterns for orchestrating multiple agents (orchestrator, pipeline, routing and verifier) and running them reliably in production.

How Claude Code reuses a stable context prefix to cut cost and latency, and the habits that keep caching working for you.

Why code retrieval is its own problem, how coding agents find context with grep and structure, and when embeddings help.

Retrieval-augmented generation from first principles: chunk, embed, retrieve and ground the answer, then evaluate what you built.

Use git worktrees to fan out several Claude Code sessions across independent tasks at the same time, then integrate the results without merge chaos.

Install Claude Code, sign in, point it at a real project, and lay the groundwork that makes every later session go smoothly.

How to get reliable, structured results like JSON out of Claude in practice, and how to check you got exactly the shape you asked for.

Agentic development changes your job instead of replacing it. It rewards sharper judgment, clearer briefs and ruthless verification.

A practical map of the MCP ecosystem: the three primitives, the kinds of servers, how clients connect, and how to pick servers you can trust.

What drives your Claude Code bill, and the levers that cut it: model choice, effort level, and a clean, well-managed context window.

What tool calling is, how the request, decide, run and return loop works, and what makes a good tool, with real examples and no API boilerplate.

How Claude Code uses tools: the built-in set, adding more with MCP servers, and how the agent decides when to call them.

A tour of the MCP servers worth wiring up first (GitHub, docs, filesystem and databases) and how to choose and install one safely.

How Claude Code's effort setting trades speed and cost for reasoning depth, what it changes for coding specifically, and which level to use when.

Claude Cowork is an agentic tab inside Claude Desktop that takes a self-contained brief, runs the work on its own, and hands you back a finished result.

Match the task to the mode. Cowork earns its keep on scoped, independent, verifiable work; interactive chat suits exploratory or high-stakes work.

Turn repeatable multi-step tasks into pipelines by chaining custom slash commands, plan mode, structured hand-offs, and fan-out subagents inside Claude Code.