The Claude Menu

There are approximately four thousand blog posts telling you how to 10x your AI productivity, unlock your inner prompt engineer, and basically become a cyborg by Thursday. This is not one of those posts.

This is the post I wish existed a few months ago, the one that explains the Claude menu before you sit down, order the wrong thing, and spend twenty minutes wondering why your meal arrived as a .tar.gz file.

First, a word on Claude's flavours

Claude.ai isn't one thing. It comes in several distinct versions, and picking the right one before you start is not a minor detail, it's the whole game. Think of it like a restaurant with multiple kitchens. They all serve food. They're not interchangeable.

Here's the menu:

🗨️ Claude Chat

The classic. A conversation window where you can ask questions, brainstorm, draft content, analyse documents, and generally have a very capable assistant at your disposal. This is your everyday workhorse, brilliant for thinking things through, writing, summarising, and getting unstuck. It doesn't touch your file system. It doesn't run code. It talks.

Best for: Writing, research, brainstorming, strategy, Q&A, drafting anything from emails to business cases.

📁 Claude Projects

This is Chat with memory. You can load in documents, give Claude persistent context about your business, your writing style, your codebase and it carries that through every conversation in the project. No more re-explaining yourself every session. This is the version that actually starts to feel like a colleague rather than a very well-read stranger.

Best for: Anything ongoing. Running a blog (hello), building a product, managing a client engagement, keeping a consistent voice across lots of content.

Gotcha: Each project conversation still starts fresh in terms of the back-and-forth. The documents persist. The chat history doesn't automatically carry over into new sessions. Worth knowing before you assume it remembers your last three conversations in detail.

💻 Claude Code

This is a different beast. Claude Code is an agentic coding assistant, it can read files, write files, run commands, and actually do things rather than just describe them. It comes in three variants that matter more than you'd think:

Browser (web container): Runs in a sandboxed environment. Claude can write and run code, but it can't touch your actual file system. Outputs arrive as downloadable files, including, memorably, .tar.gz archives.
Desktop app: Has access to your local file system. Much more capable for real projects. This is where things start feeling genuinely powerful.
CLI (command line): The full power version. Runs directly in your terminal, integrates with your existing tools, and gives you the most control. Steeper learning curve but worth it if you're doing anything serious.

Best for: Building actual software, automating tasks, working with codebases, anything where you need Claude to act rather than advise.

And then there's the API, this is for developers who want to build Claude into their own applications. Outside the scope of this post, but worth knowing it exists.

Learning #1: Pick your Claude before you start. Seriously.

I learned this the expensive way.

I was building what I'd decided to call an AI Operating System, a project to help me use both local and cloud AI models while retaining context across sessions, so it didn't feel like I was explaining my entire life to a brand new person every time I wanted to fix a bug or add a feature. Ambitious? Slightly. Worth it? Absolutely. Did I make it harder than it needed to be? Of course I did.

I started in Claude Code via the browser. Things were going well. Claude was writing code, I was feeling extremely capable, and then, nothing was actually saving anywhere useful. Instead of writing to my project folder, Claude was handing me .tar.gz files to download and manually unpack. The web container, as it helpfully explained once I asked, doesn't have access to your local file system. Good to know. Slightly late.

So I switched to Claude Code CLI. Fresh instance. Clean slate. Except the new instance had no history of what we'd built. It couldn't see the conversation from the browser session. And it very much wanted to start again from scratch, rewriting everything we'd already done rather than picking up where we'd left off.

The fix? Manually update my folder structure from the .tar.gz files, then start the CLI session from that baseline. It worked. But it cost a good chunk of time, a non-trivial number of tokens, and a certain amount of sitting quietly staring at the screen wondering what choices had led me here.

The lesson: Think through what you're actually building before you open a tab. If you need file access, start in the desktop app or CLI from minute one. Switching mid-session isn't just annoying it means your new Claude instance has no memory of your old one, and it will cheerfully want to rebuild everything from first principles.

Learning #2: Use Claude to structure the work before you do the work

This one changed how I approach basically everything.

The instinct when you have a new idea is to jump straight in and describe the thing, ask Claude to build or write or plan it, and see what comes back. Sometimes that's fine. For anything with real complexity, it tends to produce something that's almost right, in a way that's quite annoying to unpick.

Instead, I now use a sequenced prompt approach that borrows from how good projects actually get delivered. It goes like this:

Step 1 — The BA session: "Act as a Business Analyst. Ask me the questions you need to create a requirements document for [idea]." Claude asks. You answer. You end up with a real requirements document rather than a vibe.

Step 2 — The Tech Spec: "Act as a Technical Architect. Using this requirements document, ask me any questions you need to create a technical specification." Now you have both a what and a how.

Step 3 — The Project Plan: "Act as a Project Manager. Ask what you need to create a project plan." Now you have phases, dependencies, something resembling order.

Step 4 — Build it: "Act as a developer. Start on Phase 0. Let me know when it's done and how to test it."

The other trick worth adding: once you've got your requirements or spec, open a separate Claude instance and ask it to review the document and poke holes in it. A fresh set of AI eyes (so to speak) will catch things the first instance glossed over because it was the one that wrote them.

This approach takes a bit more setup time upfront. It saves a lot of "hmm this isn't quite right" time at the other end.

The short version

Claude is genuinely excellent. It's also a menu, not a button. The flavour you pick, the interface you use, and whether you do thirty seconds of upfront thinking before you dive in, these things matter more than any prompt engineering trick I've come across.

Pick the right Claude. Structure the work first. And if someone sends you a .tar.gz file, check which kitchen it came from before you order again.

More posts on practical AI and the things I've broken while building with it back to the blog.