Master Claude from the ground up to the frontier.

How to read this hub, and the ladder you are climbing. Master each rung before you lean on the next — prompting craft compounds; agentic patterns sit on top of it.

The whole system in one frame before you dive in: you, the Claude core, the tools it reaches for, the surfaces it ships through, and the model tiers above — up to the Fable 5 horizon.

What Claude is, the surfaces it lives in, which model to reach for, and the anatomy of a prompt that doesn't waste a turn.

Role: You are a senior data engineer reviewing a SQL Server ingestion script.
Task: Find correctness bugs and race conditions; ignore style.
Input: <the script below>
Constraints: Windows/pyodbc; preserve ? placeholders; pure-ASCII output.
Output: a table of {line, issue, severity, fix} — nothing else.

Every Claude from the first release to today's frontier — the lineage, the tier system, the capability milestones, and the Mythos tier above Opus (including why Fable 5 access stopped).

The highest-leverage skill on this page. Most quality gains come from steering better, not from a bigger model. Eight techniques you combine fluidly.

Rewrite this status update.
Keep: the three metrics, the blocker.
Drop: hedging, throat-clearing.
Tone: direct, peer-to-peer.
Length: <= 90 words.

Work through this step by step, then give the final answer last.
1) restate the constraint
2) enumerate options
3) trade-offs
4) pick + justify

<context>schema + rules here</context>
<data>the messy rows</data>
<task>classify each row; output one JSON per line</task>

Return ONLY valid JSON, no markdown fences, matching:
{"verdict":"matched|pending","reason":string,"confidence":0-1}

The advanced moves that separate fluent operators from prompt-typists. Chaining, meta-prompting, verification loops — the techniques you reach for when one good prompt isn't enough.

I want to <goal>. Write the best prompt to get this from you.
Then critique your own prompt and give me the improved version.

Answer the question. Then list 3 ways your answer could be wrong,
check each against the facts, and give a corrected final answer.

messages=[{'role':'user','content': ask},
          {'role':'assistant','content':'{'}]  # forces JSON output

Before you start: what do you need from me to do this excellently?
List the questions, then wait for my answers.

Where durable knowledge lives so you stop re-explaining yourself. System prompts, projects, styles, preferences, memory, and reference-past-chats — layered.

Same model, different gears. Thinking depth, effort, speed, research, and computer control — the knobs that trade latency and cost for capability.

Claude isn't text-only. Feed it images, PDFs, screenshots, and data files — and it reads, analyzes, and reasons over them. Most people under-use this entirely.

How Claude produces real deliverables — documents, decks, sheets, apps — and the Skills system that encodes hard-won procedure into reusable expertise.

const r = await fetch('https://api.anthropic.com/v1/messages',{
  method:'POST', headers:{'Content-Type':'application/json'},
  body: JSON.stringify({ model:'claude-sonnet-4-6', max_tokens:1000,
    messages:[{role:'user', content: prompt}] })
});

How Claude reaches beyond its own knowledge — web search, code execution, connectors — and the judgment of when to use a tool versus just answer.

The reusable shapes of autonomous systems — ReAct, orchestrator-worker, RAG, reflection — framed as prompting + tooling discipline, not magic.

tools=[{ 'name':'lookup_record',
  'description':'Fetch a record by id',
  'input_schema':{'type':'object',
    'properties':{'id':{'type':'string'}}, 'required':['id'] }}]

Agentic engineering for real repos. Where Claude reads your codebase, plans, edits across files, runs commands, and you stay the architect.

Before editing: list the files you'll change, the approach, and what could break.
Wait for my go-ahead, then implement on a feature branch.

The extensibility stack most people never touch. CLAUDE.md, skills, subagents, hooks, plugins, and MCP turn Claude Code from a smart terminal into a programmable engineering platform.

The discipline that turns demos into systems you can trust. If you can't measure it, you can't improve it or defend it.

Embedding Claude into your own products and pipelines — the Messages API, streaming, batching, structured output, caching, and the retry discipline that survives real load.

resp = client.messages.create(
  model='claude-sonnet-4-6', max_tokens=1024,
  system='You are a precise data extractor.',
  messages=[{'role':'user','content': payload}])

for i in range(5):
    try: return call()
    except RateLimit: time.sleep((2**i) + random.random())
raise

The dense quick-reference layer. Feature toggles, one-liner prompt openers, output-control hacks, and the highest-leverage moves — the stuff you'll keep coming back to mid-task.

• “Reason step by step, then give ONLY the final answer.”
• “Before you start, ask me what you need to do this well.”
• “Write the best prompt for this, then critique and improve it.”
• “You're the reviewer whose job is to find why this fails.”
• “Return ONLY valid JSON matching this schema — no prose, no fences.”
• “List 3 ways this could be wrong, check each, then give the corrected version.”
• “Give me the thinnest end-to-end slice that runs, nothing more.”
• “Be concise. Prose, not bullets. No preamble.”

What goes wrong, why, and the exact move to fix it. Knowing the failure modes is half of mastery — the other half is recovering fast instead of re-rolling and hoping.

Systems that compound. Where evals become products, prompts get optimized in loops, and a single engineer ships what used to take a team.

The payoff of everything above: turning techniques into a personal operating system. How to prompt consistently, break work down, move from raw idea to shipped project, and compound what you build.

[CONTEXT] stack + schema + key facts here.
[RULES] environment + hard constraints (concrete, testable).
[TASK] one sentence, one outcome.
[OUTPUT] exact shape; nothing else.

# REVIEW
You are a skeptical staff engineer. Find correctness + race issues only.
Context: <stack/schema>. Output: table {file:line, issue, severity, fix}. Nothing else.

# BUILD ARTIFACT
Build a single-file, self-contained <html/py>. Constraints: pure-ASCII,
validate tag + bracket balance before output. Iterate on edits, don't regenerate.

# DECOMPOSE
Break this goal into atomic, independently-verifiable segments.
For each: {name, done-criteria, risk}. Don't start work — just the plan, then wait.

Claude isn't the only tool, and pretending otherwise wouldn't serve you. Here's an honest map of the field, where each assistant leads, what's free, the open/local options, and how power users combine them. Prices and models change fast — treat figures as approximate and re-check.

Where this is heading, and how to keep your edge as it moves. Framed as direction to lean into, not predictions to bank on.