Blog

You're Probably Using Claude Wrong

But we can fix that ⚒️

June 29, 2026

I use Claude chat intentionally. Projects, focused conversations, context built strategically across them, skills layered in where they're useful. And yet, admittedly, I'm not using the tools available to me to their full potential. Claude Code and Claude Cowork have been sitting right there, largely untouched and underutilized.

That's the thing about getting good at one tool in a suite. It can quietly crowd out the others, not because they're worse, but because you've already got a system that works, a workflow that feels comfortable. It took stepping back and actually examining what each product is for before I started to see where Code and Cowork weren't just redundant options, but genuinely better fits for certain work. And that examination turned out to connect directly back to something I care about in my work. Efficiency, token management, and not leaving good resources on the table.

So, I want to share this exploration and the insights that have come from it. We're going to look across all three Claude products, what they're each for, and how to know which one you actually need.

Claude Chat: When you Want to Work Collaboratively

This is the one most people start with, and for good reason. Claude chat is turn-based, collaborative, and present in the conversation with you. You ask, it responds, you refine. It can write code, reason through problems, make files, search the web, pull from connected tools.

The key word is collaborative. You're involved at each step. The thinking is happening with you.

This is the right tool when the hard part is the thinking. When you need to be in dialogue with the output, when you're not totally sure what you want yet, when the back-and-forth is actually the point. Writing something tricky. Working through an analysis. Iterating on an idea.

Where it breaks down is when the task is well-defined and just tedious. When you already know exactly what needs to happen and you're manually walking Claude through it one step at a time, that's the signal to reach for Code or Cowork instead.

Set the Scope Before it Starts

The most important input is what you hand it upfront. Claude Code works best when the task is specific about what done looks like and, just as importantly, what not to touch. "Refactor the auth module to use the new token format" lands better than "clean up the auth stuff." Vague scope in an agentic loop means a lot of autonomous decisions you'll have to untangle later.

For ongoing projects, there's a CLAUDE.md file that lives in your repo and acts as persistent context. It carries project conventions, architecture decisions, things Claude should always know. It's the equivalent of Cowork's Projects, a way to stop re-explaining yourself every session. Worth setting up early if you're using Code regularly on the same codebase.

When to Step In

Once it's running, Claude Code is largely self-correcting. It reads the error, adjusts, and tries again without waiting on you. This is the whole point. But you're not locked out. You can interrupt mid-loop to redirect, narrow scope, or tell it to stop and explain what it's seeing before continuing.

The instinct worth developing is to let it run on well-scoped tasks and stay closer on anything that touches shared infrastructure or files you haven't fully mapped out. The loop is fast, which is a feature, but it also means a confidently wrong direction can cover a lot of ground before you notice.

Describe the Outcome, Not the Steps

The quality of your task description is everything. I know, we're back at prompt engineering. But it's an important fundamental for a reason. Cowork works best when you give it a goal and let it figure out the execution path. This is where you want to propose the big idea rather than the minutia of instructions to follow. "Summarize these five reports and pull out themes" is better than "read file 1, then file 2, then make a list" when using Cowork.

Before it starts running, Cowork surfaces its plan. This is where you can and should review Claude's approach before letting it loose, before the compute power gets used and those tokens get spent. This is the moment to catch misaligned intent early. If the plan looks off, redirect here rather than mid-execution. Much more cost-effective to correct the map before the territory has been covered.

The good news is that you can build checkpoints directly into your instructions. Something like "after each major step, summarize what you did and wait for my approval before continuing" tells Cowork exactly where you want to stay in the loop. You can set these as global instructions in Cowork settings so they apply across every task without having to repeat them. Autonomous flow, on your terms.

Keep in mind that the Claude Desktop app must remain open while Claude is working. Close it and your session ends. Which, on reflection, is the kind of thing you learn the hard way once.

If You Want to Redirect

You're not locked in once a task starts. You can steer mid-run, adding context, narrowing scope, changing direction. And if you've gotten a draft back that's close but not quite right, you can highlight the text you want changed, click "Edit with Claude," and type your request. Claude makes the edit right where you marked it, without you having to re-describe the section in your task thread. It's also a more efficient path than generating draft after draft in chat.

There's a hard guardrail worth knowing about. Cowork requires your explicit permission before permanently deleting any files. You'll see a permission prompt and need to select "Allow" before Claude can delete anything. This is a feature. When you're handing off multi-step work involving your actual local files, knowing that nothing gets deleted without a confirmation is the kind of safety net that makes the whole arrangement feel less risky. For my coder audience, this is your revision log.

The Mental Model

The core takeaway is simple. Chat is collaboration. Code and Cowork are delegation.

Stay in chat when the reasoning is the challenge and you want to be involved in each step. Reach for Code or Cowork when the task is well-defined but tedious and multi-step, when the bottleneck is executing across many files or tools rather than the thinking itself. Code is the coding flavor of that. Cowork is the everything-else flavor.

Chat can feel like it covers everything, because for in-the-loop, single-artifact work, it genuinely does. The other two earn their place once a task is big enough that babysitting it turn-by-turn becomes the friction.

Final Comments on Cost

A quick note on efficiency, because it connects to everything above. We all know tokens add up.

Every message in a chat conversation re-sends the entire prior history. Turn 50 is processing everything from turns 1 through 49. It's not a gotcha. It's just how the context window works. But it has real implications for how you structure your sessions.

Start fresh threads for unrelated tasks. This is the single highest-leverage habit. A new chat resets the accumulated context. Keeping one conversation alive across three different projects is not multitasking. It's paying for baggage fees.

Long pasted documents are sticky. Drop a big file early in a conversation and it rides along for every subsequent turn, even after you're done with it. For one-off document analysis, a dedicated thread you abandon afterward is cleaner than contaminating an ongoing one.

Front-load the detail. If you know what you want, one well-specified prompt is cheaper than ten corrective rounds. This is the "be specific" advice everyone gives but no one actually explains why. That's why. Iteration compounds.

For Code and Cowork, the dynamic is different. They manage their own context internally as they loop through tasks, but a big delegated job isn't free relative to chat. It's front-loaded. For repetitive multi-file work it's usually a net win. For a quick single edit, chat is leaner.

Knowing which tool is which doesn't mean abandoning the system you've already built. It means knowing exactly when to hand the work off, and to what. The good news is that now that we have better background on the tools and optimal application, we’re better equipped to use them effectively. Or at least, that is my hope of something you can take with you from this article.