Operating Claude

There are two levels of choice in the interface, and they are frequently mistaken for one. The first level is a tab. The second is a mode inside one of those tabs.

The Home tab lists chats and Cowork tasks together, alongside Projects and Artifacts. Press New and the composer offers a Chat/Cowork toggle at the bottom-left of the message box. The Code tab is genuinely separate: its own session list, its own working directories, its own diff review.

Every surface, and what it is actually for

Claude Science and Claude Security also exist. Neither is relevant to either of your roles, and both are out of scope here.

This is the choice you make most often and the one with the largest consequences — for what you get back, and for how much of your allowance it consumes.

Chat is a conversation. You ask, it answers, you correct, it answers again. Nothing happens between your turns. Cowork is a delegation: you describe an outcome and Claude works through it in an ephemeral cloud virtual machine on Anthropic's infrastructure, taking many steps, reading and writing files, calling connected tools, and coming back with finished work. This is true on every surface — starting a Cowork task from the desktop app still runs it in the cloud, which is why it continues with your laptop shut and why it can be picked up on your phone mid-task.

What Cowork adds

• Real output files — .xlsx with working formulas, .pptx, .docx, .pdf — not a description of one.
• Connectors, skills and plugins, all managed from Customize in the sidebar.
• Read and write access to folders you have explicitly connected on your computer.
• Scheduled and recurring tasks.
• Subagents working parallel strands of the same job.
• Browser control via Claude in Chrome, and computer use — Claude driving apps on your screen.Pro & Max only

What Cowork costs, and what it doesn't do

Anthropic states plainly that Cowork consumes significantly more of your usage allowance than standard chat, and that Chat, Cowork and Code all draw from the same pool. A Cowork task that reads twenty files, calls three connectors and writes a deck is doing dozens of model turns; the meter reflects that. Section 06 covers the mechanics.

Other stated limits: Cowork sessions cannot be shared between people. Live artifacts and plugins that use local MCP servers are desktop-only. Cowork is labelled beta on mobile.

Local folders and the desktop bridge

A cloud Cowork session can reach folders on your machine only while the Claude Desktop app is open on that machine — the desktop app is the bridge. Nothing outside the folders you connect is reachable, the sandbox cannot see your corporate network, and permanent deletion always requires explicit permission.

Approval modes

Claude Code is an agentic tool that reads a codebase, edits files and runs commands. The reason it matters to someone who specifies interfaces rather than builds them is that it will read without writing.

It runs in three places, all the same engine: a terminal CLI, the Code tab in the desktop app, and claude.ai/code in the browser. The desktop tab is the one to start with — it gives you diff review, a browser pane, a file pane, and git worktree isolation so several sessions can run against the same repo without colliding.

Ask and Plan modes

Both restrict Claude to reading and reasoning. Nothing is edited. This turns a repository into something you can interrogate: what does this component actually accept, where is this token used, how many places would change if we altered this behaviour. Answering that before you write the spec is the difference between a spec engineering accepts and one that comes back.

Realistic uses at your level

MCP, in one paragraph

MCP is the protocol Claude uses to talk to other systems. In practice you'll meet it as connectors — Figma, GitHub, Google Drive, Slack, Jira — installed from Customize → Connectors. The Figma one is the relevant one for you: it reads design context out of a file and can write designs and components back into one. Section 09 covers the trap that catches most people setting up a custom connector.

The surface most relevant to Track A, and the one that most needs its limits stated before its capabilities. Two products share the name and run the same editor.

How you steer it

The bottom two rows are the cost lever. Since the June overhaul, direct manipulation makes no model call at all. Nudging something by hand is free; asking for it in chat is not.

What "importing your design system" actually does

It ingests a linked or uploaded repo, screenshots, a dropped design file, or even a PowerPoint that reflects the brand, and extracts a palette, a type scale, component shapes and layout patterns. You publish the result and new projects in the org inherit it. Since June it also self-checks output against the imported system before showing you anything.

What it does not do is bind to your system. It builds an approximation from pixels and hex values, then generates against the approximation and validates against the same approximation. Anthropic's own caveat is that import quality tracks source cleanliness, and large repos need you to link a subdirectory to avoid lag.

Figma

There is no Figma integration. No reading of variables, components or styles through the API. No .fig export. No round-trip. Figma does not appear in the export menu at all.

For a governed two-market system, that outbound path is a contamination vector rather than an asset: unbound values arriving in a library file, looking like system components. Worth a rule before anyone tries it.

/design-sync is the other direction: a bundled Claude Code skill that converts a repo's React design system and uploads it so Design generates with your real components. It is React-only, push-based, and not a live binding — a re-runnable upload, best done one component at a time. Non-React stacks have no supported path.

Cost and governance

Design draws on the same shared pool as chat, Cowork and Code. There is no separate design allowance — reports of a distinct weekly design budget describe the April-to-June state and are out of date. It is expensive: generations take minutes, artboards consume large amounts of context, and codebase ingestion alone has been reported to consume most of a weekly allowance. An afternoon of exploration competes directly with your coding budget, with no per-project attribution.

The honest read

Anthropic positions it as a complement to Figma aimed at the beginning of the design process, and that positioning is accurate rather than modest. Where it earns its place: divergence — six disposable directions for a campaign page in one canvas, faster than sketching; stakeholder artefacts — one-pagers, a client-review deck, a visual rationale doc, which is arguably its strongest use and nobody markets it that way; and explaining a pattern to an engineer mid-session on the /design canvas, where it sits next to the code and versions properly.

Where it does not belong: anything brand-compliant, anything with a mandated grid, type ramp or component, anything handed to a developer as spec, and anything that touches the BMW libraries. Practitioners consistently report a recognisable house aesthetic that reasserts itself even with a system loaded, inconsistency on non-standard layouts, and four to seven minutes per generation — too slow for a tight iteration loop.

Two independent dials, both in the model picker next to the send button. Model sets how much the thing knows. Effort sets how hard it works. They are routinely confused, and turning up the wrong one wastes allowance without improving the answer.

The models

Relative cost per token

Derived from published API list prices, which are the only hard numbers Anthropic gives. Subscription allowance is metered on tokens consumed, so these ratios are also the burn ratios.

Effort

Five levels in the app: Low, Medium, High, Extra high, Max. High is the default on every model that supports the setting. Effort governs the whole response — how many files it reads, how much it verifies, how far it pushes a multi-step task before checking in — not only the thinking.

Three traps

• Effort is not verbosity. On Opus 5 it does not reliably shorten or lengthen the visible answer. If you want brevity, ask for brevity.
• The scale is calibrated per model. Medium on Fable 5 is not Medium on Sonnet 5. Fable 5 at low effort often beats older models at their highest.
• Changing effort mid-conversation invalidates the prompt cache, which means the whole conversation is re-billed at full rate on the next turn. Set it at the start and hold it.

Extended thinking is a separate toggle and now does less than people assume: on Opus 5, Sonnet 5 and Fable 5 the model decides for itself whether to think, and the toggle mostly controls whether you see it. Opus 5 will not let you disable thinking at Extra high or Max.

One mechanic explains almost every surprise about cost, speed and quality degradation. It is worth ten minutes.

What a token is

A token is the smallest chunk of text the model reads or writes — roughly three and a half English characters, so a little under a word. The conversions that matter:

Input is everything sent to Claude: the system prompt, your new message, attached files, tool definitions, tool results, and the entire prior conversation. Output is everything Claude writes, including thinking blocks you never see. Output costs five times input on every model without exception — a verbose answer is five times as expensive per word as the document you pasted in.

The same mechanic explains quality. Anthropic calls the effect context rot: as token count grows, accuracy and recall degrade. More context is not automatically better. Starting a fresh chat is both the cheapest and often the most accurate move.

Two meters, running at once

Everything shares one pool: claude.ai, desktop, mobile, Cowork, Code, Claude in Chrome, and the Microsoft 365 add-ins. Max 5x provides five times Pro's per-session capacity; Max 20x, twenty times. Those multipliers are all Anthropic publishes — there are no official message counts, token caps or hour figures for any consumer plan, and every hard number circulating online traces back to figures from August 2025 that were invalidated by a doubling in May 2026.

What happens at the limit

A hard stop, not a downgrade. Your history is preserved; you are blocked from new prompts. Switching to a smaller model does not restore access, because session and weekly limits apply across all models. The one exception is the Opus sub-limit in Code — that one is model-specific, and switching to Sonnet lets you keep working.

Habits that actually reduce consumption

• One chat per topic. The single highest-leverage habit. In Code, /clear is free; /compact is itself an expensive request.
• Match the model to the job. The ladder is 1× / 2× / 5× / 10×.
• Drop to Low or Medium effort for routine work. Thinking tokens bill at the output rate.
• Attach excerpts, not whole documents. A 300-page PDF is 240,000 tokens on every subsequent turn.
• Ask for concise output. Output is the expensive side of the ledger.
• Turn off connectors you aren't using. Past about ten active connectors, switch tool access from Auto to On demand.
• Give complete context up front so you spend one expensive turn instead of six cheap-looking ones.

Buying more

Usage credits are available on Max and are billed at standard API rates — no consumer markup, no discount. Add funds under Settings → Usage, with an optional monthly spend cap. Prepaid bundles are cheaper if you overflow regularly:

Where to look

Four separate mechanisms decide what Claude knows before you type anything. They have different scopes, different triggers, and different failure modes.

The distinction that matters: instructions are always on and therefore always occupying context, while skills are loaded conditionally and cost nothing when idle. Anything you need every time goes in instructions. Anything you need for one kind of task goes in a skill.

Projects

A project is a workspace with its own chat history, knowledge base, instructions and isolated memory. Knowledge files cap at 30 MB each, with no limit on how many.

How project knowledge is read changes silently depending on volume. Below the context-window threshold, everything is loaded whole. Above it, Claude switches to search — retrieving passages rather than reading the corpus — which expands capacity by roughly ten times. You cannot control or see this switch.

Project memory is isolated from every other project and from global memory. This is the most useful control in the whole personalisation system: work you don't want bleeding into other conversations goes in its own project and stays there.

Styles

The style picker — Normal, Concise, Explanatory, Formal, plus custom styles trained from a writing sample — no longer appears anywhere in Anthropic's current documentation. There was no removal announcement. If you relied on one, its function now lives in Instructions for Claude or in a skill. Treat this as inferred rather than confirmed.

Privacy, and the part that concerns your employers

On consumer plans — Free, Pro and Max — training on your conversations is opt-in, controlled by a "Help improve our AI models" toggle at Settings → Privacy. With it on, new chats and coding sessions may be used for training and are retained for up to five years. With it off, the standard 30-day retention applies. Check which way yours is set.

Incognito chats are available on all plans and are excluded from memory and from history entirely.

Artifacts are the panel to the right of the chat. They are also three different systems that share a name, with different limits and different sharing rules.

Chat artifacts

Markdown documents, code, single-page HTML, SVG, diagrams, and interactive React components. Each publish creates a version, selectable from a version picker. Highlighting text in a Markdown draft gives you Edit with Claude for a targeted revision that doesn't disturb the rest.

Published artifacts get a public link that works without a Claude account. They can hold persistent storage — up to 20 MB, enough for a tracker or a journal that survives between visits — call connectors for live data, and offer file downloads. An artifact can even call Claude at runtime, billed against each viewer's own subscription rather than yours.

Code artifacts and Cowork live artifacts

File creation and upload limits

The PDF rule catches both of your roles regularly — a 400-page brand guideline or a long implementation spec will silently lose everything visual past page 100. Split the file, or extract the pages that matter.

All three live under Customize in the left sidebar, each with a browse directory behind a plus button. They extend what Claude can do in different directions: skills change how it works, connectors change what it can reach, plugins bundle both.

Skills

A skill is a folder of instructions, and optionally scripts and reference files, that Claude loads only when it judges the task relevant. Because they are conditionally loaded, having twenty installed costs nothing until one fires.

The test for whether something should be a skill: would you otherwise re-explain the shape of the output every time you asked? A house format for design specs. A required structure for a customer runbook. A checklist that has to be applied identically each pass.

Custom skills are distributed as a ZIP whose root is the skill folder, containing skill.md with a name of 64 characters or less and a description of 200 or less. Skills installed from the directory are read-only — to change one, download a copy and re-upload it as your own. Anthropic ships skills for Excel, Word, PowerPoint and PDF; Notion, Figma and Atlassian ship partner skills.

Connectors

Add from Customize → Connectors or the plus button in the chat input. Connectors inherit your permissions in the source system — if you cannot see something there, Claude cannot reach it either.

Stated security considerations, worth taking seriously rather than skimming: prompt injection from a malicious or compromised server is a named risk; a connector's behaviour can change silently when its developer updates it; and third-party services process your data under their own terms, potentially outside your jurisdiction. For Research runs, disable write-capable tools.

Plugins

A plugin bundles skills, pre-configured connectors, and — in Cowork only — subagents and hooks. Install from Customize → Plugins → Browse plugins. The default marketplace is Knowledge Work; Anthropic also curates Financial Services, Legal, and Life Sciences, the last of which is worth a look for health-tech implementations work.

Work that should happen without you being present. Both features are Cowork, not Chat.

Scheduled tasks

Cowork → Scheduled → New task. Claude can walk you through setup, or you can enter the prompt, approval mode, cadence, model and folder manually. Cadence options are hourly, daily, weekly, weekdays, or manual. From the same page you can pause, resume, edit, delete, or run a task on demand.

Available on all paid plans. There is no published cap on how many you can have.

Dispatch

A persistent thread you message from your phone. Claude decides whether to handle the request in Cowork or spawn a Code session, works on your desktop using your local files, connectors and apps, and pushes a notification when it is finished or blocked.

Dispatch is Pro and Max only — explicitly not available on Team or Enterprise, which is the rare case where a household plan has a capability a corporate one does not. It requires the desktop app open and awake, and it is a single continuous thread rather than a set of parallel ones.

Set up once

• A project per programme, not per task. One for each market site, one for design-system governance. Each carries its own instructions and its own memory.
• Put the rules in project instructions: your spec format, the component naming convention, the accessibility standard you hold to, the two markets' legal and content constraints, and what you never want proposed.
• Connect Figma and GitHub. Figma reads design context and can write components back; GitHub gives Code a repo to read.
• Turn one thing into a skill the first time you find yourself re-explaining an output format. Your spec template is the obvious candidate.

Read the implementation before you specify the change

Code tab, Plan mode, on the repo. Nothing gets edited. The output is a scope estimate you can defend in a room.

Read-only. I need to understand the blast radius before I spec a change.

The change: move the configurator entry point above the fold on the
model detail page, and make it persist on scroll.

Tell me:
1. Which components render that entry point today, and their props.
2. Everything else that consumes those components.
3. Which of the layout values involved are design tokens and which are
   hard-coded.
4. Where the US and DE builds diverge on any of the above.
5. The three changes most likely to be argued about in review, and why.

Don't propose a solution. I want the map, not the route.

Design-system drift, on a schedule

The gap between what the library says a component does and what the code actually accepts widens every sprint, and nobody has time to audit it manually. This is a Cowork task set to run monthly.

Compare the Figma library components in [file] against their
implementations in [repo].

For each component, produce a row: component name, properties defined
in Figma, properties accepted in code, variance, and a severity —
cosmetic, behavioural, or accessibility-affecting.

Sort by severity. Exclude components where the only variance is naming.
Output as .xlsx with one row per component and a second sheet listing
components that exist in one place and not the other.

End with the five variances you'd raise first and one sentence each on
why.

Market variance as a first-class artefact

The recurring cost on a two-market programme is that variance lives in people's heads. Make it a document.

For the [component] spec I'm writing, produce the market-variance
section covering US and DE.

Cover: required legal disclosure and where it must sit, price and
figure formatting, string-length tolerance for German, any consent or
cookie interaction, and image or content restrictions.

Where the two markets need genuinely different behaviour rather than
different content, say so plainly and flag it as a design decision
rather than a localisation one — those are the ones that get missed.

Accessibility as states, not as a checklist

Here's the interaction spec for [component].

Map WCAG 2.2 AA to it by state — default, hover, focus, active,
disabled, loading, error, empty. For each state give me the criteria
that apply, what would fail, and the annotation I should put on the
Figma frame so engineering doesn't have to interpret it.

Where a criterion can't be satisfied without changing the interaction
design, say so instead of proposing a workaround.

Research synthesis that survives a stakeholder

Ask for disagreement rather than themes. Themes flatten the thing that makes research useful.

These are [n] session transcripts and the intercept survey.

Don't give me themes. Give me:
1. Where participants contradicted each other, and what distinguishes
   the two groups.
2. Where participants contradicted themselves — said one thing, did
   another.
3. What the data does not support, including anything the brief
   assumed going in.
4. The two findings that would change the roadmap if true, and what
   evidence would confirm or kill each.

Quote directly. Attribute every claim to a session.

Divergence, before Figma

The one use of Claude Design that survives contact with a governed system is throwing away options fast. Run it on the /design canvas inside Code rather than at claude.ai/design — it versions properly there, and it sits next to the repo. Section 04 covers what it can and cannot be trusted with.

Six directions for the [campaign / model launch] landing page, as
separate artboards on one canvas. Desktop only.

Constraints: the hero must carry a configurator entry point and a
legal disclosure line. Assume German string lengths, so nothing that
breaks past roughly 40% expansion.

Make them genuinely different — not six versions of one layout. Vary
where the vehicle imagery sits, how the model range is entered, and
whether pricing appears above the fold.

I'm going to throw five of these away. Don't polish.

Treat the output as a sketch that argues for a direction. It is not a spec, it does not carry your tokens, and nothing from it should reach a library file. If the goal is to get a built interface back into Figma as real editable layers, that is Code to Canvas, not Claude Design.

Set up once

• A project per customer. Its knowledge holds their configuration decisions, integration inventory and constraints. Its memory is isolated from every other customer's — which is the point.
• One project for the method itself, holding your standard runbook structure, your gate criteria, and your escalation thresholds.
• Turn the runbook structure into a skill so it applies without being pasted.
• Connect the systems you actually live in — mail, calendar, whichever tracker — and leave the rest disconnected. Past about ten active connectors, performance degrades and you should switch tool access to On demand.

Source-to-target mapping as a real worksheet

Attached: the source schema export and our target field list.

Produce a mapping worksheet as .xlsx:
- One row per target field: target field, type, required, source field,
  transformation, confidence.
- Flag every target field with no clean source, and every source field
  with no destination.
- A second sheet for transformation rules written so an engineer can
  implement them without asking me what I meant.
- A third sheet listing the questions I need to put to the customer,
  ordered by how much rework the wrong answer causes.

Use no real data. Where you need an example value, invent one and mark
it as synthetic.

Runbook and go-live checklist

Using the configuration decisions in this project's knowledge, produce
the implementation runbook in our standard structure.

Then produce two things separately:
- A go-live checklist with an owner and a verification step per line.
  A line that can't be verified isn't a line.
- A rollback plan covering the three failures most likely to happen in
  the first 48 hours.

Mark every step that depends on the customer doing something. Those are
the ones that slip.

Weekly status, assembled while you sleep

A scheduled Cowork task. Build it around connectors rather than local files, or it will only run when your laptop is open.

Assemble this week's status for each active implementation.

Per customer: what moved, what didn't and why, what's blocked and on
whom, and what changes next week's forecast.

Separate what I know from what I'm inferring. If a customer has gone
quiet for more than five working days, say so at the top — silence is
the signal I most often miss.

One page per customer. No preamble.

Escalation triage

Here's the thread. Redacted, no patient data.

Give me:
1. The timeline of what actually happened, separated from what people
   believe happened.
2. The real ask underneath the stated ask.
3. What we got wrong, stated plainly.
4. Two response options — one that holds the line, one that concedes —
   with the likely consequence of each.

Then draft the one you'd send. Direct, no apology padding, no
commitments I haven't authorised.

Discovery into requirements

These are my discovery notes.

Turn them into: confirmed requirements, assumed requirements I need to
validate, and out-of-scope items I should get in writing.

Separately, list the contradictions between what different stakeholders
told me, with who said what. Then the five questions whose answers most
change the shape of the implementation.

Don't smooth over the gaps. The gaps are the deliverable.

Advice about being specific is not useful, because everyone already believes they are being specific. These are the moves that change output quality reliably.

One asymmetry worth internalising: in Chat, one thing per turn — you are steering, and a turn that carries four questions gets four shallow answers. In Cowork, everything at once — you are delegating, and every constraint you leave out is one it has to guess about hours later with no way to ask.

This document is accurate as of 21 August 2026 and will not stay that way. Below is what is dated, what is contested between Anthropic's own pages, and what nobody publishes.

Dated

• A 50% increase to weekly Claude Code limits runs through 31 August 2026. It has been extended twice. Anthropic says it hopes to make it permanent but that capacity may be tight. Any judgement you form this month about whether your allowance is sufficient is flattered by roughly a third.
• Haiku 4.5 is the oldest model in the active lineup, with a February 2025 knowledge cutoff, and is eligible for retirement from 15 October 2026. Minimum notice is 60 days.

Contested between Anthropic's own pages

• Tab structure. The desktop changelog describes the merged Home; the desktop documentation still says three tabs. Rollout, or documentation lag.
• Context window. The support article states 1M tokens for Opus 5 and Sonnet 5 on all paid plans; the pricing page still says 200K. The support article is more specific and more recent.
• Weekly reset time. One page says Monday midnight; another says a fixed time assigned per account. Check yours under Settings → Usage.
• Claude Design on desktop. The get-started article says web and the desktop sidebar; the admin guide still lists it as web-only. Desktop is almost certainly current and the admin page stale.
• What the /design canvas exports. The skill definition says PNG and PDF; hands-on reports say PNG and an HTML zip. Unresolved, and probably version-dependent.

Not published at all

• Absolute usage limits. Anthropic publishes multipliers only — 5× and 20× Pro. Every message count, token cap or hours-per-week figure online traces back to August 2025 numbers invalidated by a doubling in May 2026. Treat all of them as folklore.
• Token multipliers per effort level. None published. Third-party estimates exist and are self-described as approximate.
• Caps on the number of scheduled tasks, skills, or projects on a paid plan.
• Canadian dollar pricing. Anthropic says regional pricing applies where supported. Check claude.ai/upgrade while signed in from Toronto for the authoritative local price and tax treatment.

Inferred, not confirmed

• That writing styles have been retired. They are absent from all current documentation; no removal was announced.
• That Haiku 4.5 has no effort control. It is missing from every effort-support table and documented as using the older thinking parameter, but the exclusion is never stated outright.
• Code to Canvas. Everything in section 04 about it rests on press coverage from February 2026 — I could not retrieve a primary Anthropic or Figma page. Verify against Figma's documentation before planning around it.
• Whether the /design canvas inherits an org-published design system. Undocumented either way; practitioners name their component library in the prompt rather than assume it.