Ask heavy AI users what they keep Claude around for, and you’ll hear the same answers: long documents, careful writing, and analysis that doesn’t lose the plot. Claude’s superpower is depth over length — huge context handling with unusually faithful instruction-following — and prompting it well means playing to exactly that.
This guide is the Claude-specific layer on top of our universal cheat sheet: the structuring trick Claude responds to better than any other model, the long-document workflows, the Projects setup, quirk fixes, and a copy-paste prompt pack. As always with tool guides, features evolve — we focus on the durable behaviors. Guide #20 of the Prompt Engineering roadmap.
What Makes Claude Different
- Very large context windows — entire books, codebases, or research packets in one conversation, with strong recall across them
- Writing quality — widely preferred for nuanced, natural prose that needs less de-AI-ifying
- Faithful instruction-following — complex multi-part requirements survive better, especially when structured (next section)
- Projects — workspaces with standing instructions and knowledge files that brief every chat inside them
- Styles & artifacts — reusable tone presets, and standalone documents/code rendered beside the chat
Who Uses Claude for What — Find Your Lane
Whatever your lane, the next section is the one trick everyone should learn first.
Quick Start — Your First 3 Claude Prompts
Brand new here? Run these three in your first five minutes — each shows off a different Claude strength, and together they teach more than an hour of reading:
If those three land (they will), everything below is the systematic version of what you just felt.
The Claude Structuring Trick — Tags
Here’s the most Claude-specific tip in existence, straight from how the model was trained: Claude loves clearly labeled sections, and XML-style tags are the clearest labels there are. When a prompt mixes instructions with pasted material, tags remove every ambiguity about what’s what:
Summarize the document for a busy executive: 5 bullets, lead with the biggest number, flag risks separately.
</instructions>
<document>
[paste your entire document here — however long]</document>
<format>
Bullets, then a short “Risks” section. Under 150 words total.
</format>
You don’t need valid XML — just consistent opening/closing labels. The payoff grows with prompt size: on a 20-page paste, tagged prompts dramatically out-perform “here’s a doc, summarize it, also under 150 words, oh and flag risks” run-on style. Use tags whenever a prompt has 2+ distinct parts (instructions, source text, examples, output rules).
The Perfect Claude Prompt Structure
The universal five parts — Role, Task, Context, Format, Constraints (full anatomy here) — with two Claude tunings. First, Claude rewards explicit quality bars: tell it what “good” means for this task and it will genuinely aim there. Second, tags scale the structure: on short prompts write naturally; the moment a prompt has pasted material or 3+ requirements, switch to the tagged layout.
<task>Rewrite my tutorial’s introduction</task>
<context>Audience: complete beginners in Pakistan; they fear code</context>
<requirements>1. Under 120 words 2. One friendly analogy 3. No jargon 4. End with what they’ll build</requirements>
<draft>[paste]</draft>
Same anatomy, two costumes — pick by prompt size. Either way, Claude’s instruction-following means every requirement you actually write tends to actually happen; the skill is writing them.
The Long-Document Playbook (Claude’s Home Turf)
- Paste whole, then layer. Don’t pre-chop documents — give Claude everything, then question in layers: “one-paragraph summary” → “the 5 key arguments with section references” → “critique the weakest one.”
- Demand quotes as anchors. “For every claim in your summary, include the exact quote it’s based on” — this converts summarization from trust-me to check-me, and Claude is unusually good at faithful quoting.
- Cross-document work: tag each source (<doc1>, <doc2>…) and ask for the comparison table: where they agree, where they conflict, whose evidence is stronger.
- Contracts & dense material: “Explain section by section in plain language. Flag anything unusual, one-sided, or missing that a careful reader would question.” (Then verify with a professional — AI reading ≠ legal advice.)
Projects, Styles & the Setup That Sticks
- Projects = your custom instructions, scoped. Create one per real workstream (“Tech Blog”, “Thesis”, “Client X”), write its standing brief once — audience, tone, ban list — and drop reference files in as project knowledge. Every chat inside starts pre-briefed. It’s the Claude answer to repeating yourself.
- Styles lock your voice. Feed writing samples to create a custom style, and Claude matches it across chats — few-shot made permanent.
- Model tiers, the durable rule: fastest tier for quick everyday tasks, middle tier as the daily driver, top tier for the hardest reasoning and most important writing. Names change; the ladder doesn’t.
Claude’s Quirks (and the One-Line Fixes)
The Claude Daily 10 — Copy-Paste Pack
Prompting Claude by Task — Quick Playbooks
✍️ Writing
Claude’s prose advantage compounds with two habits: separate the editing passes (structure → tone → line-polish, one message each — mixed feedback produces mixed rewrites), and use artifacts for anything you’ll iterate on — the document lives beside the chat and each refinement updates it in place instead of reprinting walls of text. For voice work, a saved style beats re-pasting samples.
Watch the editor at work — one real pass, so you know what to expect:
That’s the standard you can demand on every paragraph you write — and with a saved style, it happens in your voice, not a generic one.
💻 Coding
Claude’s context size changes the coding workflow: paste related files together so it sees the real architecture, not fragments. Tag them (<file name=”app.py”>…</file>) and ask architecture-level questions first (“how does auth flow through this?”) before line-level fixes. For debugging, the evidence pattern rules here too: code + input + expected + actual, and “trace to the divergence point.”
🎓 Research & study
This is where the long-document playbook and the quote-anchor trick combine: upload the readings, demand quotes as evidence, then flip to Socratic mode (“now quiz me on this paper, one question at a time”). A semester’s PDFs inside one Project turns Claude into a subject-specific tutor that never loses your syllabus.
Claude vs ChatGPT — The Honest Line
Keep both if you can; they’re colleagues, not rivals. Reach for Claude when the job is long, careful, or written — big documents, nuanced prose, multi-file code reading. Reach for ChatGPT when you want its ecosystem — custom GPTs, in-chat images, the widest tool set (full playbook in our ChatGPT Prompting Guide). Skills transfer completely: everything from the techniques track works identically in both, and strengths shift with each release — test your own workload rather than trusting anyone’s leaderboard.
The 60-Second Claude Setup
- ☑ One Project created for your main workstream, with its standing brief written (audience, tone, ban list)
- ☑ Reference files uploaded to that Project — the docs you keep re-explaining
- ☑ A custom style saved from 2–3 samples of your writing
- ☑ The tag habit adopted — <instructions> / <document> on any prompt with pasted material
- ☑ Model ladder reflex set — fast for quick, middle for daily, top for hard
Five checkboxes, and every Claude conversation you have from now on starts pre-briefed, pre-styled, and pre-structured.
Files, PDFs & Images — Multimodal Claude
- PDFs are first-class citizens: upload research papers, reports, or scanned documents and apply the full long-document playbook — layered questions, quote anchors, section-by-section plain-language walkthroughs. For multi-PDF work, name them as you reference them: “in the second PDF (the 2025 report)…”
- Images as context: screenshots of errors (“explain and fix”), whiteboard photos (“transcribe, then organize into an action list”), charts (“read the values into a table, then tell me the story”), UI mockups (“write the HTML/CSS for this”).
- Spreadsheets & data files: profile first, always — “columns, types, ranges, anything suspicious — THEN answer my question, showing your working.” A confident chart built on dirty data is worse than no chart.
- The combo move: file + instructions + format tags in one prompt — “<instructions>compare the attached contract against this checklist</instructions> <checklist>…</checklist>” — Claude’s faithful structure-following makes these compound prompts land reliably.
Advanced Power Moves
- Artifacts as living documents. Anything you’ll iterate on — an article, a component, a plan — ask for it as an artifact and refine it in place: “update the intro only,” “add error handling to the parse function.” The document evolves beside the chat instead of being reprinted in fragments; ten revisions stay one clean artifact.
- Extended thinking on demand. For genuinely hard problems, ask Claude to reason at length before answering — “take your time and think this through thoroughly before responding” — or use a thinking-enabled mode where available. It’s chain-of-thought with a bigger budget; save it for problems that deserve it.
- The full-context interview. Claude’s context size enables a unique move: paste EVERYTHING messy — meeting notes, emails, half-drafts — and say “interview me: ask 5 questions to figure out what I’m actually trying to produce, then produce it.” The mess becomes the brief.
- Multi-turn document surgery. On long pieces, direct edits like a film editor: “scene by scene” — tighten section 2, merge sections 4–5, rewrite only the transitions. Claude tracks the whole document across turns; use that instead of full-rewrites that churn what was already good.
- Reliability stack for high stakes. Role + step-by-step + the tag-separated <thinking>/<answer> format, run 3× with a self-consistency vote — the strongest accuracy setup Claude offers in plain chat.
Troubleshooting — When Claude Misbehaves
Claude Everywhere — Same Skills, Every Surface
- Mobile app: best for capture-and-continue — photograph the whiteboard or document on the go, start the analysis, finish on desktop in the same conversation
- Desktop & web: home of the serious workflows — Projects, artifacts, long-document work all shine on a big screen
- For developers, the API: everything in this guide scales into applications — the tag trick and structured prompting matter even more when no human is watching each reply (that path starts in our Advanced track)
Privacy & Data Sense
- Universal rules apply: no passwords, API keys, or client-confidential material in any chat; anonymize real people’s data before analysis (“replace names with Person1, Person2”)
- Know your data settings: review the privacy controls for how conversations are retained and used — decide deliberately, not by default
- Project knowledge is convenience AND responsibility: files you upload to a Project persist there — audit occasionally and remove what’s stale or sensitive
Mistakes Claude Users Make
- Pre-chopping documents out of habit — Claude’s whole advantage is taking the full text; let it
- Run-on mega-prompts without tags — 2+ parts, no labels, then blaming the model for mixing them up
- Ignoring Projects — re-explaining your blog/thesis/client in every single chat
- Accepting hedge-mode — never demanding the one-line commitment Claude will happily give if asked
- Asking tiny questions in the top tier — and burning limits on tasks the fast tier handles identically; save the heavy model for heavy work
- Never using artifacts for iterative work — refining a document through chat reprints instead of in-place edits, then losing track of which version was good
- One eternal chat — the 3-strike rule applies here too: pollution in, restart with a distilled prompt
Frequently Asked Questions
Long-context work and careful writing: whole documents and codebases in one chat, faithful instruction-following, and prose that needs less editing. Reach for it when the job is long, nuanced, or written.
Simple labels like
A Project holds standing instructions and reference files that apply to every chat inside it — your context, written once. Create one per real workstream so you never re-explain your situation.
Fastest tier for quick tasks, middle tier as the daily driver, top tier for the hardest reasoning and most important writing. Specific names change with releases; the ladder logic doesn’t.
Ask for commitment explicitly: ‘ONE recommendation, caveats in a single line at the end.’ Claude follows that instruction faithfully — the hedging is a default, not a limit.
Yes — role prompting, few-shot, chain-of-thought, the whole toolkit transfers. What differs is the product layer: Projects instead of GPTs, styles instead of custom instructions, and the tag trick that Claude specifically rewards.
Claude supports web search in its apps (availability varies by plan/region). Without search, its knowledge has a training cutoff — for anything recent, enable search or verify independently.
Artifacts are standalone documents or code that render beside the chat and update in place. Ask for one explicitly (‘create this as an artifact’), then direct edits surgically: ‘change only the intro, leave everything else identical.’ Perfect for anything you’ll iterate on.
A mode (or simply a request — ‘think this through thoroughly before answering’) where Claude reasons at length before responding. Use it for genuinely hard problems: tricky debugging, multi-constraint planning, math. Skip it for everyday tasks where it just adds time.
There’s a free tier plus paid plans with stronger models, higher limits, and more features (details change — check current pricing). As with every AI tool, skill transfers: a well-prompted free tier beats a lazily-prompted paid one.
Long, careful, written — that’s Claude country. 📚
Next: Gemini Prompting Guide — guide #21.
