You’re Using Claude Like It’s One Tool. It’s Six.

Most senior engineers I talk to have a mental model of Claude that stopped updating the week they first opened claude.ai. Type a question into a box, get an answer back. That model was never wrong, exactly. It’s just incomplete enough to leave most of the tool’s actual leverage on the table.

The basic approach

The default usage pattern looks like this. Open a chat tab, ask a question, get a decent answer, close the tab, repeat tomorrow with zero context carried forward. It works for isolated questions. It falls apart the moment your work has state, like a codebase, a recurring format, or a set of standing instructions you re-type every single session. At that point you’re not using an assistant, you’re using a very articulate search box. Re-explaining your context every time is the tell.

The actual pattern, six independent decisions

What actually matters in practice is that using Claude is really six separate decisions stacked on top of each other, and most people only ever make the first one on purpose.

Where you open it. Browser, desktop app, mobile, or inside Chrome as a browsing agent. This isn’t cosmetic. Desktop can reach your local files and folders directly, which changes what kind of task is even viable there versus in a locked down browser tab.

Which model you pick. Lighter models trade reasoning depth for speed and cost on high volume, simple jobs. Heavier models are for the work where being wrong is expensive, like architecture calls, ambiguous debugging, anything you’d actually want a second opinion on before shipping.

How hard it thinks. Independent of which model you’re on, you can dial reasoning effort up or down. This is the one people get backwards most often. More thinking budget is not a free accuracy upgrade. Past a certain point it just gives the model more room to be confidently wrong with better prose. Match effort to the actual cost of a mistake, not to how important the task feels.

How you work with it. A single back and forth chat is the default, but it’s not the only mode. You can hand off a whole task and walk away, or load a project with your standing instructions and files once so every new conversation starts already knowing your context instead of starting cold.

What you get back. Chat replies are the floor, not the ceiling. The same request can come back as an editable document, a real downloadable file, or a live artifact that keeps updating against your actual data instead of going stale the moment you close the tab.

What it’s plugged into. Connectors to your existing tools, memory that carries relevant context between sessions, and skills, instructions you write once that get applied automatically going forward. This is the layer that turns an assistant you re-brief every day into something closer to a colleague with context.

The tradeoffs

None of this is free. Every layer you add on top of plain chat is a small tax. More setup, more surface area to configure correctly, more to explain to a teammate who’s watching you work. A project with fifteen loaded files and three skills is genuinely harder to reason about than a blank chat. It’s worth it when the task recurs, not worth it when it doesn’t.

Effort and model choice are the sharpest tradeoff of the six. Reaching for the heaviest model and maximum reasoning effort by default feels like the safe choice. It’s actually the expensive one, in both latency and in the failure mode where longer output reads as more authoritative without being more correct.

When this is overkill

If the task is a single, isolated question with no recurrence and low cost of being wrong, like a syntax lookup, a one off rewrite, or a quick sanity check, none of this matters. Open a chat, ask, move on. Configuring a project, wiring connectors, and picking reasoning effort for a question you’ll ask exactly once is solving a problem you don’t have.

Takeaway

Treat these as six knobs, not one. Before you open Claude for a recurring piece of work, decide deliberately. Which surface, which model, how much reasoning effort the mistake cost actually justifies, what mode of work fits the task, what output format you actually need, and what should persist versus what should stay disposable. Getting that stack right once is worth more than getting a slightly better prompt every day.