Claude isn’t the tool I open for a quick Teams summary — it’s the one I reach for when a document is too long to fully hold in my head. Projects, memory, and what a bigger context window actually buys you.
This is post three in the Leveling Up series, following Leveling Up Copilot. Same four habits from the overview post — prompting, context, iteration, knowing the limits — applied to a different tool.
One scoping note first: this post is about Claude, the assistant — not Claude Code, the developer tool I use to build this blog and the apps at home. I’ve written separately about Claude Code if that’s the one you’re curious about. They share a name and a company, but they’re not the same tool, and this post isn’t about writing software.
Where Claude Fits
Copilot is my daily-driver at Kwik Trip because it’s embedded in the M365 tools I already live in. Claude fits a narrower, different niche: long-context, document-heavy work — the kind of task where the bottleneck isn’t drafting something from scratch, it’s making sense of something long that already exists.
A 50-page requirements document. A lengthy vendor contract. A stakeholder situation with enough history that explaining it properly takes real length. That’s where I reach for Claude instead of whatever’s already open in Teams.
Projects: A Workspace That Remembers What It’s For
Claude Projects let you set up a persistent workspace scoped to one thing — a specific initiative, a recurring type of task — with its own instructions and its own set of reference documents attached.
The practical difference from a regular chat: you’re not re-explaining the same background every time. Set up a project once with the documents and context that define it, and every conversation inside that project starts already knowing what it needs to know. For a PM, that maps naturally onto how work is actually organized — not by tool, but by initiative. A project per major workstream, each one holding its own documents and its own accumulated context, is a more honest match for how the work is structured than one long undifferentiated chat history.
Memory: Context That Doesn’t Reset
Claude has a memory feature that persists relevant details across conversations — the same idea as Copilot’s memory from the previous post, a different implementation. The value is the same either way: you stop re-establishing the same standing context every time you open a new conversation.
This is the habit that’s easiest to underuse. A fresh conversation feels like a blank slate, so people re-explain themselves out of habit even when the tool doesn’t need it anymore. Once memory has the standing context, the prompting habit shifts — you’re supplying what’s new, not repeating what’s already known.
What a Longer Context Window Actually Buys You
“Longer context window” sounds like a spec sheet detail. In practice, it’s the difference between a tool that can hold an entire document in view while reasoning about it, and one that’s working from fragments.
Concretely: you can hand Claude a full contract and ask where the indemnification language creates risk relative to the rest of the document, and it’s reasoning across the whole thing at once — not summarizing in chunks and losing the connections between page 3 and page 40. That matters most on exactly the documents PMs dread reading closely: long, dense, and easy to miss something in on a first pass.
It’s not magic — you still have to ask a specific enough question to get a useful answer, per the same prompting habit from the overview post. But the ceiling on “how long a document can this usefully help with” is a lot higher than most people assume, and most people never test it because they’re used to tools that choke on anything past a few pages.
The Habits, Applied
Prompting here leans harder on precision than volume — with a big document already in context, the limiting factor becomes asking a specific enough question, not fitting enough information into the prompt.
Context is largely solved by Projects and memory once they’re set up — the discipline shifts from “re-explain every time” to “set up the project once, correctly.”
Iteration matters most on long-document analysis — a first pass often surfaces the obvious issues; a second pass (“now check specifically for X”) is where the less obvious ones show up.
Knowing the limits means remembering that a longer context window doesn’t equal correctness — Claude can hold the whole document in view and still get a detail wrong. Verify anything that matters before you act on it, the same as any other tool in this series.
What’s Next
Next in this series: Leveling Up Cursor — codebase-aware prompting, rules files, and what “agent mode” actually means if you’re not a developer but you’re willing to learn.
Links & References
This Series:
Related Monday Business Posts:
Copilot follows you into the tools you already have open. Claude is where you go when the document is too long to hold in your head — and knowing which situation you’re in is half the skill.