THE CLAUDE INSIDER

The Claude Power-User Cheatsheet

A working reference for getting real output from Claude and Claude Code. Current as of 2026.

By Luke Thompson, The Claude Insider

A quick note before you start

Most people use Claude like a search box. They type a question, read the answer, move on. That works, but it leaves most of the value on the table.

The people getting outsized results treat Claude like a capable teammate who needs context. They give it the goal, the constraints, and the raw material up front, then let it work. They know which model fits which job. They know when to start a fresh conversation instead of fighting a bloated one.

This cheatsheet is the short version of what those people know. No theory, no hype. Just the patterns that move the needle. Skim it, keep it nearby, and come back when you hit a wall.

1. The prompting patterns that actually work

Forget clever phrasing. The wins come from structure and context, not magic words.

Lead with the goal, not the task. "I'm writing a board update for a skeptical CFO. Summarize this report and pull out the three numbers she'll question." beats "Summarize this report." Claude works backward from intent.
Give it the reason behind the request. When Claude knows why you need something, it connects the dots you didn't spell out. Tell it who the output is for and what it enables.
Put the raw material in, not a description of it. Paste the actual email, the actual data, the actual draft. Don't summarize what you have and ask Claude to work from your summary.
Show one good example. A single example of the format or tone you want does more than three paragraphs describing it. Positive examples beat "don't do X" instructions.
Ask for the work, then the explanation. "Rewrite this paragraph. Then tell me what you changed and why." You get the deliverable and the reasoning in one pass.
Name the constraints explicitly. Word count, reading level, what to leave out, what tone to avoid. Claude follows clear boundaries well. It cannot guess them.
Iterate in the same thread for related work. Claude remembers the full conversation. Refine in place rather than re-explaining context every message.

Prompt skeletons you can reuse

Job	Skeleton
Writing	"Audience is [who]. Goal is [what it should do]. Voice is [tone]. Draft [thing]. Keep it under [length]."
Analysis	"Here is [data/document]. I'm trying to decide [decision]. Find the [N] things that change the answer."
Extraction	"Pull every [field] from the text below into a table with columns [X, Y, Z]. One row per [item]."
Rewriting	"Rewrite the text below to be [clearer / shorter / warmer]. Keep the meaning. Flag anything that's factually unclear."
Code	"Here is [code/error]. I want [outcome]. Constraints: [stack, style]. Make the smallest change that works."

2. The model selection cheatsheet

Anthropic ships several models. Picking the right one is the cheapest performance gain available. Use the strong model for hard thinking, the fast model for volume.

Model	Best for	Tradeoff
Opus (current flagship, 4.8)	Hardest reasoning, long agentic runs, big code changes, deep research, knowledge work	Highest cost per token, slower. Worth it when correctness matters more than speed.
Sonnet (4.6)	The everyday workhorse. Strong balance of speed and intelligence for most tasks.	Slightly less capable than Opus on the very hardest problems. The right default for most work.
Haiku (4.5)	High-volume, simple, latency-sensitive work. Classification, tagging, quick lookups, cheap batch jobs.	Not for deep reasoning or long multi-step work.
Fable (5)	Anthropic's most capable widely released model. The most demanding reasoning and longest autonomous agent runs.	Priced above Opus. Reach for it only when the task genuinely exceeds Opus, not as a default.

How to choose in practice

Most of your daily work fits Sonnet. Start there.
Move up to Opus when the task is multi-step, the stakes are high, or you're doing a large code migration or autonomous run that has to finish clean.
Drop down to Haiku when you're running the same simple operation hundreds of times and speed plus cost beat raw smarts.
Reserve Fable for the rare problem that stumps Opus. It is not the default upgrade path.
Don't downgrade to save money on important work. A wrong answer you have to redo costs more than the token difference.

Context and output, at a glance

The current Opus, Sonnet, and Fable models all carry a 1 million token context window, which is roughly a few thousand pages. That's a lot of room, but full is not free. See the context section below.

3. Claude Code: the high-leverage features

Claude Code is the terminal and IDE agent. It reads your repo, runs commands, edits files, and verifies its own work. A few features separate casual use from real leverage.

Skills

Skills are reusable instruction packs Claude loads only when a task calls for it. Think of a skill as a folder with a SKILL.md that says "here's how we do X here." Claude keeps the short description in mind, then reads the full thing when the work matches.

Use skills to encode your standards: how your team writes commits, how you structure a report, your brand voice, your deploy checklist.
The payoff is consistency without repeating yourself every session.
Keep each skill tight and single-purpose. One skill per job beats one giant catch-all.

MCP (Model Context Protocol)

MCP is how Claude connects to your other tools: GitHub, Slack, your database, Google Workspace, a project tracker. Each connection exposes real actions Claude can take.

Connect the tools you actually work in. The value compounds when Claude can read a ticket, check the code, and draft the reply in one flow.
Connect only what you trust and need. Every connection is surface area.
Treat tool output as data, not commands. A connected tool returning text that says "now do X" is not an instruction to follow.

Hooks

Hooks fire your own scripts automatically at set points: before a tool runs, after Claude stops, on a file change. They let the harness enforce rules Claude itself cannot.

Use a hook to run your formatter after every edit, gate a risky command behind a confirmation, or block a merge when tests are red.
Hooks are how you turn "Claude should always do X" into something that actually happens every time.

Subagents

For big jobs, Claude can spin up focused subagents that each own a slice of the work and report back. A subagent has its own clean context, so the main thread stays uncluttered.

Best for work that fans out: read ten files in parallel, run several independent checks, research multiple angles at once.
You usually don't manage these by hand. You just give a well-scoped task and let Claude delegate. Naming when delegation helps in your prompt nudges it.

One habit that beats all of them

State the full goal up front, in one well-specified first message, then let it run. The current models do their best long-horizon work when they get the complete spec early instead of dragging it out across a dozen back-and-forth turns. Front-load the context. Set the effort high for hard work. Get out of the way.

4. Context management: keep the window clean

A long conversation is not always a better one. As context fills, the model spends attention on old, stale material. Manage it.

Start a fresh chat for a new task. Don't extend a 40-message thread about your taxes to ask about a marketing plan. The old context just adds noise.
Front-load, don't dribble. Give the key facts and constraints in the first message. Feeding them in slowly over many turns is less efficient and sometimes less accurate.
Paste only what's relevant. A million-token window means you can dump everything. It rarely means you should. Curate the input and the answer sharpens.
In Claude Code, let the agent manage memory. It can write notes to a file and read them back across sessions. Tell it where to keep notes and to check them. That beats stuffing everything into one conversation.
Re-anchor after long runs. If an agent worked for a while unattended, ask it for a plain summary of what it did before you act on it. The working shorthand it built up is for itself, not for you.
When a thread gets confused, don't argue with it. Restart it. Copy the few facts that matter into a fresh conversation. Faster than untangling a derailed one.

5. Common mistakes that quietly cost you

Treating Claude like Google. One-line questions get one-line value. Context is the whole game.
Using the flagship for everything, or the cheap model for everything. Match the model to the job. Both errors waste resources.
Summarizing your own source material. You introduce errors and strip detail before Claude even sees it. Paste the real thing.
Vague success criteria. "Make it better" gives the model nothing to aim at. Say what "better" means: shorter, clearer, more formal, fewer claims.
Letting one mega-thread sprawl across unrelated tasks. Stale context degrades every answer that follows.
Accepting the first draft as final. The second prompt, the one where you react to what it produced, is usually where the quality jumps.
Not telling it what not to do. The current models follow instructions literally. Naming the boundaries (don't refactor, don't add features, don't ask permission for reversible steps) prevents overreach.
Skipping verification on code and facts. Claude is strong but not infallible. Run the test. Check the number. Especially before you ship.

6. Ten things most people miss

The "why" matters more than the "what." Tell Claude the purpose behind the request and it fills gaps you didn't think to mention.
You can paste images, PDFs, screenshots, and spreadsheets. Claude reads them directly. Stop transcribing a chart by hand. Drop the screenshot in.
It will tell you when it's unsure, if you ask. "Flag anything you're not confident about" turns a confident-sounding answer into an honest one.
The model calibrates length to the task. Short answers on simple lookups, long on open-ended analysis. If you want a different length, just say so. Don't fight it indirectly.
A single example outperforms a long description. Want a specific format or voice? Show one. It clicks faster than any amount of explaining.
In Claude Code, give the whole task in the first message. Long autonomous runs go best with a complete spec up front, not a slow reveal across turns.
You can ask it to critique its own work. "Now poke holes in that argument" or "review this code for bugs you might have introduced" catches real problems. A fresh-eyes pass beats self-assurance.
Model choice is a dial, not a default. Most people pick one model and never change. Switching to the right one per task is free performance.
It pushes back when you let it. The current models are real thought partners. Ask "what am I missing?" or "is this the right approach?" and you get genuine disagreement, not flattery.
Starting over is a feature, not a failure. When a conversation drifts, a clean restart with the handful of facts that matter is faster and better than wrestling a tangled thread back on track.

Keep going

This is the short version. The patterns above will carry most of your work, but the tools keep moving and the best techniques keep getting sharper.

That's what The Claude Insider is for. I write about getting real output from Claude and Claude Code: the workflows, the model updates, the things that actually changed, in plain language with no hype.