Module 2 of 6
Core Concepts
Before diving into commands and workflows, it helps to share a common vocabulary. This module covers five ideas you'll see everywhere: prompts, skills, context, tokens, and how to pick the right model for a job.
What is a prompt?
A prompt is whatever you send to Claude to get a response — an instruction, a question, a paste of code, a file, or all of the above combined. Every turn of a conversation is a prompt-and-response cycle: you provide input, Claude produces output based on that input plus everything earlier in the conversation.
Prompts aren't limited to a single line of text. A good prompt often includes:
- Intent — what you actually want done, stated plainly.
- Context — relevant background, constraints, or examples.
- Format guidance — how you want the answer shaped (a table, a diff, a short summary).
- Success criteria — how you'll know the response is good enough.
Rule of thumb: a vague prompt ("fix this") forces Claude to guess your intent. A specific prompt ("this function throws on empty arrays — add a guard clause and a unit test for the empty case") gets you a usable answer on the first try. The Writing Effective Prompts module goes much deeper on this.
What is a skill?
A skill is a packaged, reusable set of instructions (and sometimes scripts or reference files) that teaches Claude how to do a specific job well, on demand. Instead of re-explaining a process every time — "when reviewing a PR, check for X, Y, Z, then format the output like this" — you write that once as a skill, and Claude loads it only when it's relevant.
Think of a skill as the difference between a colleague who has to be re-briefed on a process every single time versus one who already has the playbook memorized and pulls it out the moment the situation calls for it.
Why skills exist
They keep specialized know-how out of the main conversation until it's needed, so Claude stays fast and focused for everyday requests, but can still go deep when a task matches a skill it knows about.
Where you'll meet them
Skills can ship with Claude Code, come from your organization, or be authored by you. Slash commands are often a thin, hand-typed trigger for invoking one.
We cover how to invoke, discover, and author skills in the Slash Commands & Skills module.
What is context (the context window)?
Context is everything Claude can "see" while generating a response: your current message, the prior turns of the conversation, any files or documents you've shared, tool results, and system instructions. The context window is the maximum amount of that material the model can hold at once, measured in tokens (more on tokens below).
Once a conversation's content exceeds the context window, the oldest or least relevant material has to be dropped or summarized to make room for new input. That's why long-running sessions can sometimes "forget" details from much earlier in the conversation — they've simply aged out of the window.
Practical implications:
- Pasting an entire large codebase or log file eats into the budget available for reasoning and back-and-forth.
- Restating key constraints periodically in long sessions helps keep them "in view."
- Starting a fresh conversation for an unrelated task is often better than continuing an old, cluttered one.
What is a token?
A token is the basic unit of text a model reads and writes — roughly a chunk of a word, not quite a whole word and not quite a single character. As a rough estimate, 1 token ≈ 4 characters of English text, or about ¾ of a word. So "agentic coding" is about 3–4 tokens, not 2 words.
Tokens matter for two reasons:
- Context budget — the context window is measured in tokens, so longer input (and longer output) consumes more of that shared budget.
- Cost and speed — usage is typically metered by tokens in and tokens out, and generating more tokens takes more time.
| Example text | Rough token count |
|---|---|
Fix the bug | ~3 tokens |
| A one-paragraph explanation | ~40–60 tokens |
| A 300-line source file | ~2,000–4,000 tokens |
| A lengthy PDF or design doc | tens of thousands of tokens |
You don't need to count tokens by hand day-to-day — just keep in mind that "more pasted material" always means "less room left" in the context window, and think about trimming irrelevant material before sharing it.
How to think about selecting a model
Claude is offered in different model variants that trade off speed, cost, and depth of reasoning. Rather than memorizing model names, it helps to reason from the shape of the task:
Lightweight & fast
Best for quick, well-defined tasks: simple Q&A, formatting, short summaries, boilerplate edits. Optimize for speed when the task is low-stakes and you'll iterate quickly anyway.
Balanced
A good default for most day-to-day work: everyday coding, explanations, drafting, and moderate-complexity analysis. Strong quality without the slowest response times.
Most capable
Reach for the top-tier model for hard, high-stakes, or ambiguous problems: tricky debugging, architectural decisions, multi-step agentic work, or anything where a mistake is costly to unwind.
A practical heuristic: start with your default model. If the task is repetitive, high-volume, or latency-sensitive, consider dropping to a faster model. If Claude is struggling, giving shallow answers, or the task genuinely requires deep multi-step reasoning, step up to the most capable model rather than fighting it with more prompting.
Model choice isn't permanent or all-or-nothing — you can switch models mid-project as the nature of the work changes, and different clients expose model selection in different ways (see the Claude Clients module).