1. Projects & Persistent Context
A fresh claude.ai chat knows nothing about you, your role, your recurring formatting preferences, or the reference material you use every week — you'd have to restate all of it, every session. A Project fixes this: it's a container with its own custom instructions and attached files that every conversation started inside it automatically has access to.
You're helping with weekly customer feedback analysis for a B2B SaaS
product. Context that applies to every conversation in this project:
- Our three customer tiers are Starter, Growth and Enterprise
- "Churn risk" language should stay internal-facing, never customer-facing
- Default output format: a short summary, then a bulleted list of themes
- Attached: our current product roadmap and Q3 OKRs — reference these
when relevant to a request
With this set once, every new conversation in the Project already knows the tier names, the internal-only phrasing rule, and can reference the attached roadmap — none of which you have to type again. This is the single highest-leverage claude.ai feature for any recurring task, and it's the free-tier version of an idea Claude Code takes even further in Week 10.
A Project doesn't extend the context window — it means you don't need the same background crammed into every single conversation in the first place. That's often the actual fix for "I keep having to re-explain this."
2. Working with Long Documents & PDFs
Claude can take an entire PDF or long document as a direct attachment — there's no need to copy-paste chunks of text and lose formatting, tables and structure along the way. The technique that matters most here is one from Week 3: require Claude to ground its answers in the actual document, with quotes.
"Using only the attached document, answer: what are the termination
conditions?
Format:
1. Your answer
2. The exact sentence from the document that supports it, with the
section/page it appears in if visible
3. If the document doesn't address this, say so explicitly"
Requiring the supporting quote does two things at once: it makes Claude's answer easy to verify against the source, and it makes it obvious when Claude is drifting toward a plausible-sounding answer that isn't actually backed by the text — you'll see a quote that doesn't quite say what the answer claims, which is your signal to push back.
Ask for a structured summary first (key sections, main claims) before diving into detail questions — it's easier to spot if Claude's overall grasp of the document is off before you trust its answers to specific questions. Comparing two documents works the same way: attach both, and explicitly ask Claude to note where they agree and where they conflict.
3. Drafting, Editing & Iterating
A common failure mode: ask for a draft, dislike part of it, say "make it better," get an entirely regenerated draft that lost the parts you actually liked. Treat Claude like a collaborative editor instead — give targeted feedback on specific parts, not a vague global instruction.
VAGUE:
"This is okay but make it better."
→ Regenerates the whole thing; unpredictable what changes.
TARGETED:
"Keep paragraphs 1 and 3 exactly as they are. Paragraph 2 is too vague —
give it one concrete example. Tighten the closing sentence — it's
currently repeating what paragraph 1 already said."
The targeted version protects what's already working and points precisely at what isn't, which produces a much smaller, more predictable edit — and preserves your own phrasing in the parts that were already right, instead of Claude quietly rewriting them into its own voice on every pass.
If Claude's drafts consistently sound generically "AI," paste in a short sample of your own past writing and ask it to match that tone specifically — a concrete example works far better than describing tone in the abstract ("make it more casual"), the same lesson as Week 2's few-shot technique.
4. Artifacts for Reusable Output
For anything substantial enough to want as its own piece of content — a document, a script, a diagram, a structured report — claude.ai can put it in a separate Artifact pane instead of inline in the chat. Artifacts update in place as you ask for changes, so you're editing one evolving piece of content instead of scrolling back through a chat log to find the latest version.
# Without an artifact: every revision is a new message in the chat.
# Finding "the current version" means scrolling to the last code block.
# With an artifact: "change the header color to blue" updates the SAME
# artifact in place. There's exactly one current version, always visible,
# and you can see the diff of what changed.
Reach for an artifact anytime the output is something you'll copy out and use elsewhere rather than just read once — a report you'll share, a script you'll run, a diagram you'll reference later. For a quick one-off answer you're not going to reuse, plain chat is simpler.
Artifacts and Section 3's targeted-feedback habit compound: "change paragraph 2, leave the rest" against an artifact gives you a precise, trackable single source of truth for a document you're actively refining over many turns.
5. Hands-on Exercise
Set up a Project, ground answers in a real document, and iterate on a draft
Three exercises that build the daily-work habits from this week.
Part 1 — A Project for something you actually do repeatedly:
- Create a Project for a real recurring task (weekly status updates, reviewing a specific kind of document, drafting a certain type of message).
- Write custom instructions covering at least 3 pieces of context you'd otherwise repeat every time.
- Start two separate conversations inside the Project and confirm both already "know" the context without you restating it.
Part 2 — Grounded answers from a real long document:
- Attach a real PDF or long document (a contract, a long article, a technical spec).
- Ask 3 specific questions using the grounded-answer pattern from Section 2 (answer + supporting quote + "not addressed" fallback).
- Verify at least one quote by checking it against the actual document.
No document handy? A public terms-of-service page or a long README from an open-source project works fine for practicing the pattern.
Part 3 — Iterate without regenerating:
- Ask for a first draft of something real (a short bio, a project README, a cover letter paragraph).
- Give two rounds of targeted feedback (name specific parts to keep, specific parts to change) instead of "make it better."
- Compare the final result to what a vague "make it better" loop would likely have produced — note how much of your original phrasing survived.
6. Knowledge Check
Four quick questions. Expand each to check your answer.
Q1
What problem do claude.ai Projects actually solve, and what don't they do?
What problem do claude.ai Projects actually solve, and what don't they do?
They let custom instructions and attached files persist across every conversation started inside the Project, so recurring context doesn't need re-explaining. They don't extend the context window of any individual conversation — they remove the need to cram the same background into it repeatedly.
Q2
Why does requiring a supporting quote from a document improve answer quality, beyond just letting you verify it?
Why does requiring a supporting quote from a document improve answer quality, beyond just letting you verify it?
It surfaces the mismatch when an answer drifts toward something plausible-sounding but not actually supported by the text — a quote that doesn't quite back the claim is a visible signal to push back, which a bare unsupported answer wouldn't give you.
Q3
Why does "make it better" tend to produce worse iteration results than specific, targeted feedback?
Why does "make it better" tend to produce worse iteration results than specific, targeted feedback?
A vague instruction gives Claude no signal about which parts were already working, so it tends to regenerate the whole piece — including the parts you liked and your original phrasing in them. Targeted feedback protects what's working and focuses the edit on what isn't.
Q4
When should you reach for an Artifact instead of a plain chat reply?
When should you reach for an Artifact instead of a plain chat reply?
When the output is substantial enough that you'll copy it out and reuse it — a report, a script, a document you're iterating on — rather than a quick answer you'll just read once. Artifacts keep one current version you can revise in place instead of scrolling a chat log for the latest copy.