Everything a working professional needs to actually use Claude — taught top to bottom, in one session.
Ground it in real files, build things you keep, package the procedure once, and verify every figure before it leaves your hands.
By the end of this chapter: you can open Claude anywhere, ground a question with a file, pick a model — and have set your preferences once.
One place to chat, create, and open your work — claude.ai on the web, the desktop app, or the phone. Same account, same history, everywhere. Learn the home base once and everything else clicks into place.
Ask in plain language. Attach a file or paste text to ground the answer in something real — that one habit is half of everything. The model picker sits right in the input; most work runs on the everyday default. Your Projects and past chats live in the side panel — one click back to anything.
Remember it like this: "Same Claude on every device. Chat is the front door; the file you attach is what makes the answer real."
A fresh conversation. By default nothing carries over — chapter 2 explains why that matters.
Every past conversation, searchable. The answer from three weeks ago is one click back.
Scoped workspaces that hold files, instructions, and their own chats. Chapter 3 lives here.
Attach a file, paste data, add a photo from your phone — the fastest way to ground an answer.
Choose which model answers. Most work runs on the default — chapter 8 tells you when to switch.
Web, desktop, mobile — same account, same history. Talk to it by voice on the phone.
Set your preferences once — Settings from your profile menu → your personal preferences — and Claude applies them to every chat. Your role, your tone, your format, your no-gos. Almost nobody does this, and it's the single biggest upgrade to your results.
Remember it like this: "A long prompt is usually a missing instruction. This is where that instruction lives."
"I'm an operations manager at a distribution company."
"Keep replies concise and professional."
"Use bullets and bold the action items."
"Skip the preamble — get to the point."
Four lines, set once. Every chat after this already knows you.
By the end of this chapter: you know why Claude can be confidently wrong, what grounding fixes, and can write a G-C-E-S prompt from memory.
Learn how the engine works, and everything it does stops feeling like magic — including the mistakes. This is the chapter that keeps you out of trouble.
Claude isn't fetching answers from a database. It generates them on the spot — predicting the most likely next piece, one token at a time. A spectacularly good guesser, not an encyclopedia.
The context window is its working desk. What you paste or attach is what it can reason over — nothing more. And by default a new chat starts with a blank desk: no memory of the last one.
Ask for a fact it doesn't have and it may generate a plausible-sounding one — a hallucination — in the same confident voice as a right answer. Tone tells you nothing about accuracy.
Give it the source — a file, a page, your data — and say "use only this." Grounded answers are far more reliable. Then check every fact, figure, and name before it leaves your hands.
Where your data lives — the three levels
Claude only knows what it's given. Knowing which level you're in tells you how reliable and how private an answer is. And the rule that never changes: permissions inherit — Claude can only ever see what you can see.
What you type or paste right now. Fast and private — but it forgets when the chat ends.
The files and instructions you loaded into a Project. Claude grounds every answer in them.
Through connectors — your live Drive or Microsoft 365. Only what your own permissions already allow.
The work order: G-C-E-S
Think of a prompt as a work order. A strong one has four parts — miss one and you get a weaker answer. This framework is ours, and it works with any AI tool.
What you want — "a 5-bullet recap," "a reply," "a summary table."
Why and for whom — "for a meeting with the buyer," "for leadership."
Tone, length, format — "professional," "under 150 words," "as a table."
What to use — "this thread," "the attached file," "only the data I pasted."
Which meeting? For whom? How long? What format? Claude has to guess — and often guesses wrong.
Goal, audience, format, source — all clear. One pass, usable result. Run both live and watch the difference.
By the end of this chapter: you've built one artifact you can reuse, and stood up one Project for a recurring workflow.
Stop regenerating answers. Start building things you keep. An artifact is a real thing Claude builds — a dashboard, a calculator, a document — that lives beside the chat and edits in place. You don't regenerate; you refine: "make negative variance red," "add a total row."
From any spreadsheet.
Like the one above.
From rough notes.
Projects — give Claude your world once
A Project is a container: your documents, your standing instructions, and its own chat history in one scoped space. Open it and Claude already knows your world — no re-explaining. One project per workflow — close, AP, reporting — not one giant catch-all.
Four steps, and you've got a workspace the whole team reuses every cycle — instead of rebuilding the same context from scratch.
Remember it like this: "It answers from your uploaded docs — not a guess. Build it once, and every month you open it and go."
"You support our month-end close. Always cite the source doc. Never assume — flag what's missing."
The project holds the stable context. The chat holds only what's new this month.
Where an instruction belongs — the four levels
Everything you just learned stacks into four levels, and one rule runs all of them: pick the lowest level that still covers it — and the moment you're typing the same thing again, move it up. Each level sticks harder than the one below it, so the higher you go, the less you repeat yourself.
A single instruction you type or reuse. Great for one-off work — nothing persists. The trap is using it for what you'll do again.
Standing rules, set once in Settings, applied to every chat. Who you are, how you like answers. Chapter 1's highest-leverage move.
A project holds context for one body of work (a noun). A skill packages a procedure that fires anywhere (a verb). Describing a subject? Project. A procedure? Skill — chapter 4.
Work that runs on a trigger or schedule — the top level, and the one to govern carefully. This is where cost and risk enter (chapter 8).
By the end of this chapter: you understand what a skill is, have watched one work, and have described one of your own jobs as a skill.
A skill captures how a job should be done — the steps, the format, the rules — so anyone can trigger it in plain language and get a consistent, professional result. You don't code a skill. You describe it.
The template, the required sections, the formatting, the guardrails — captured once, applied every run. Consistency on demand.
You don't run a program. You say what you want — the skill fires when your request matches the job it was built for.
A good skill drafts, flags gaps, and never invents a number or takes an irreversible action. It drafts; a human presses send.
A skill nobody uses helped no one. Build for the person who'll run it — their files, their formats, sensible defaults.
Something you do the same way often — a weekly report, a standard reply, a checklist review.
Walk Claude through how you do it — the format, the must-haves, and what it must never do.
It packages your procedure into a reusable skill. No code from you.
Next time, just ask. The skill fires and delivers the same standard, every run — the PDF-to-email skill was built exactly this way.
By the end of this chapter: you know how Claude reaches real data, what "agent" honestly means, and the golden rule that keeps all of it safe.
So far Claude only sees what you paste. Connectors change that — a secure door into the tools where your work already lives. This is the leap from "AI that reads what I paste" to "AI that works in my actual filing cabinet."
Google Drive, Microsoft 365, and more — turn one on in settings and Claude reads and works with your real files from chat. No downloading, no pasting.
The Model Context Protocol is the standard way to connect Claude to almost any system — including ones your company built in-house. One protocol, every tool.
Claude can only see what you can see. It works inside your existing access — a connector never widens your permissions or hands out new keys.
Answers now come from your actual systems, not a paste. This is what makes the work real instead of generic.
What "agent" actually means — the honest scale
"Agent" gets thrown around loosely. Here's the real spectrum — and the one golden rule that holds at every level: Claude gathers and drafts. A human approves. Never auto-post anything irreversible.
Claude uses tools — web search, code, file creation — to finish a multi-step task inside one chat.
Claude reaches into your systems to read and act on real data — still with you in the loop.
Cowork, Claude Code, the Agent SDK — a persistent worker running a defined job end to end. The level to govern carefully.
The built agent you already have: Cowork
Chat answers you; Cowork does the work. It's the level-3 agent included with every paid plan — Pro, Max, Team, and Enterprise — and you find it right next to Chat. Give it a goal and it plans the steps, runs them end to end, and hands you finished work to review. It runs on web, desktop, and mobile (mobile in beta); the desktop app is what reaches the folders and applications on your own computer.
Select Cowork, describe the task, connect only the folders it needs, review its plan, let it run. It shows every step — the files it opened, the tools it used, the choices it made — and you can redirect or stop it at any point.
Set a job once — daily, weekly, monthly — and it runs unattended. Close your laptop and it keeps going; you come back to the finished deck or spreadsheet. A one-off task saves an hour. A scheduled one saves it every week, forever.
There's no separate bill: Cowork is in your plan. The real cost is usage. A single Cowork task can burn far more than a chat, and every surface shares the same limits — a rolling five-hour window, plus weekly caps on paid plans. If your team hands off work all day, that's the case for Max.
It shows its plan and waits before anything significant, and write-capable connectors prompt per task. Owners can switch Cowork off org-wide; Enterprise can scope it to specific teams. The standing caution: don't connect folders holding sensitive material you wouldn't hand over.
Three real workflows — not toy examples
Actual jobs, start to finish. The pattern in all three: Claude does the gather-and-first-pass; you keep the judgment on every exception.
Give it both sides — bank extract and GL extract. It surfaces the unmatched items with a likely cause for each, and proposes clearing entries as drafts. Nothing posts without you.
Research is where AI is most tempting — and most dangerous, because it will happily invent a source. Web search on, real cited sources, and the rule: no link, no trust.
Set it up once in a Project — last month's report as the template plus your data source. Every cycle becomes a ten-minute review instead of an afternoon rebuild.
By the end of this chapter: you know what Claude Code, Claude in Chrome, and Claude Design each do, which of the three is actually yours, and the approval rule that keeps every one of them safe.
Chat answers you. Cowork does the work. Past those sit three more surfaces included in the same paid plan — and most people never open a single one. They aren't add-ons and they aren't extra money: Code works on the files on your machine, Chrome works inside your browser, and Design turns a rough idea into a finished deck. One of the three isn't for developers at all.
Reads a whole project, edits files, and runs commands on your computer. Terminal, editor, desktop app, or browser.
An extension that reads pages, clicks, types, and fills forms alongside you — the one that touches the open web.
Describe it and Claude builds the real thing — a deck, a prototype, a one-pager — then exports it to PowerPoint or PDF.
Claude Code — the one that edits real files
Anthropic's own description: an agentic coding tool that reads your codebase, edits files, and runs commands. The honest test of whether it's yours: does your work live in files on a computer, or in a browser and a mailbox? Files — keep reading. Otherwise, skip ahead to Chrome; you're not missing anything.
This isn't autocomplete in an editor. It reads the whole project, changes many files at once, runs the commands, and checks its own work. You describe the outcome in plain English; it plans the approach and executes it.
The terminal, VS Code and JetBrains editors, a desktop app, and the browser. Every surface runs the same engine, so your settings and standing instructions follow you from one to the next. Start a job on your laptop, check it from your phone — it's one session, not five tools.
It starts with read-only permission. Looking costs nothing and asks nothing. The moment it wants to change a file or run a real command, it stops and asks. It also can't write outside the folder you started it in.
Drop a CLAUDE.md file in the project and it's read at the start of every session — your standards, your rules, your do-nots. It's the same idea as preferences from chapter 1, aimed at one project instead of every chat.
winget install Anthropic.ClaudeCode.cd to move into the project you want it working on. That folder becomes its boundary.claude and press enter. You sign in the first time only.Don't want a terminal at all? You don't need one. The Claude desktop app has a Code tab, and claude.ai/code runs the whole thing in a browser with nothing installed — useful for kicking off a long job and checking back later.
Claude in Chrome — the one that clicks for you
A browser extension that lets Claude read, click, and navigate websites alongside you. Included with every paid plan. It's the most immediately useful of the three for non-technical work — and the one that demands the most judgment, because Anthropic's own documentation says it plainly: it is still risky. Teach it with that sentence attached.
Reads the text on a page, takes screenshots, types, clicks, and fills forms, and works across several tabs at once. It can keep going in the background while you do something else, and you can record a workflow once and have it repeat.
Install it from the Chrome Web Store, pin it, and click the Claude icon — a side panel opens beside the page you're on. It can also be driven from Cowork and from Claude Code.
Manually approve — it pauses before every action. Automatically approve — it keeps working and screens each action, blocking what it judges unsafe. Skip all approvals — nothing pauses and nothing checks. Start on manual.
Even after you've said "always allow" on a site, it still stops for three things: downloading a file, entering sensitive information, and granting an authorization. Whole categories are off-limits too — financial services, adult, and pirated sites.
Running a team? Team and Enterprise admins can restrict exactly which sites Claude is allowed to touch using allowlists and blocklists — worth setting before anyone installs it, not after.
Claude Design — the one nobody expects
The surprise of the three. It isn't a coding tool and it isn't a chat window: you describe what you want and Claude builds the actual visual — a deck, a prototype, a landing page, a one-pager. It's in beta on Pro, Max, Team, and Enterprise. One catch worth knowing before you go looking for it: Enterprise has it switched off by default.
Pitch decks, one-pagers and resumes, wireframes, interactive prototypes people can actually click, landing pages, dashboards, forms, and internal tools. It'll also generate several directions at once so you can pick instead of guess.
Start from a plain description, or hand it screenshots and images, existing decks and documents (Word, PowerPoint, Excel), design files, or a whole code repository. It reads what you already built and works in that vocabulary.
Comment directly on one element, edit the text right on the page, or nudge spacing, color, and layout with adjustment controls — then tell Claude to apply that change across the whole design instead of fixing twelve slides by hand.
The one that matters most for business work. Export to PDF, PowerPoint, standalone web page, or a zip — or push it straight to Canva, Adobe, and Miro. A rough outline becomes an on-brand deck you can open in PowerPoint and keep editing.
claude.ai/design.The honest limits — it's a beta. Web and desktop only, with no mobile app. Two people editing the same design at the same time is unreliable. A very large code repository can make the browser sluggish. And it changes often, so expect what you see to move.
So which one is actually yours?
Most people need one of the three, not all three. Match it to where your work already happens and ignore the rest until that changes.
Projects, repositories, folders of documents on your machine. Use the desktop app if the terminal isn't your world.
Portals, web systems, forms, research — the same twelve clicks every morning. Keep it on manual approval.
Proposals, pitches, recurring reports, anything that gets presented. Export it straight to PowerPoint.
By the end of this chapter: you know what a plugin bundles, can install one with a single command, and know the one trust rule that keeps you safe.
Chapter 4 taught you skills — one procedure, packaged once. A plugin goes further: it's a box that can hold many skills, custom agents, event hooks, and live connections, installed together with one command. A skill is a procedure. A plugin is a department.
Skills (procedures), agents (specialist workers with their own instructions), hooks (automatic actions when events happen), and connections to outside tools. Any mix, shipped as one package.
Type /plugin in Claude Code and the catalog opens. Anthropic's official marketplace is built in from your first launch — curated plugins for engineering, sales, finance, legal, HR, operations, and more.
/plugin install <name>@<marketplace> — that's the whole job. The plugin's skills appear under its own name, like /sales:call-prep, so two plugins can never collide.
A plugin can include instructions and code that run on your machine. Install only from sources you trust, and read what a plugin does before you add it — the same judgment you'd apply to any software.
Type /plugin in Claude Code. The official catalog is already registered — no setup.
/plugin install <name>@<marketplace>. Skills arrive namespaced under the plugin's name.
The plugin's skills fire on plain language, its agents show up as specialists, its hooks run on their events.
Your team's procedures can become a plugin too — write the skills (chapter 4), put them in one folder, share it. One install, whole team upgraded.
Plugins are a Claude Code feature — the terminal and the desktop app. In the claude.ai chat app, the same ideas arrive as skills (chapter 4) and connectors (chapter 5). Same concepts, different doors.
Your membership already includes the Vinyl Academy Skills Library — 22 ready-to-use business skills on the main site, downloadable today. Install them standalone, or fold them into your own team plugin.
By the end of this chapter: you pick models by task, can explain where AI cost actually comes from, and own the verify habit.
The part nobody teaches honestly. Claude comes in a small family named after forms of writing — the bigger the form, the bigger the model. Pick by the task, not by habit: you don't need the biggest one for most work.
High-volume, simple work — tagging, routing, quick drafts, first passes.
Most writing, analysis, and building. Start here — it's the daily driver.
Genuinely hard problems — complex reasoning, long multi-step work.
Maximum capability for the most demanding work — priced and metered as a premium.
Where the money actually goes
A person chatting on a paid plan is a flat monthly fee. The cost surprises come from machines acting on their own. Know the difference and you'll never get a shock bill. (Plans run roughly free → $20 → $100+ per month, per-seat for teams — numbers move, so verify at the source before quoting.)
Per-plan usage limits, not per-message charges. A licensed person chatting is effectively free — it's already paid for. Skills, Projects, Artifacts, and Cowork run on the plan you have; no per-skill fee.
Automated workflows and agents that run on their own consume usage every time they fire. The API and Claude Code bill per-token, separate from the app subscription. This is where cost accrues.
Share something useful too broadly and unlicensed users can trigger metered work in your name. The usage runs on your tab. Pin agents and workflows to a security group of licensed users — never all-company by default.
Approve licenses, require training, control who can trigger what. And before anything goes on a schedule: cost per run × runs per day × 365. Get it right on day one, not after the bill.
Running it for a team — the owner's corner
When it's the whole office and not just you, four things keep the bill boring and the setup clean. This is the governance your leadership will ask you about.
Team plans use two seat types — standard for moderate users, premium for power users with far more headroom. Mix them; you don't buy everyone the expensive seat. An owner provisions skills once and they appear for everyone.
Set spending caps at the organization and individual level so no single person runs away with usage. Extra usage beyond the plan is pre-purchased and billed at API rates — only if you've turned it on.
The Claude add-in for Excel, Word, and Outlook installs from the Microsoft store with no billing event — but it rides a paid Claude plan, not your M365 one. Rule: nothing goes live until someone confirms who's paying for it.
Paid seats include a monthly credit for autonomous agent work; past it, usage flows to API rates. The two-sentence law again: a person in a chat is the seat. A machine acting alone is a meter — estimate before you schedule.
22 ready-to-use Claude Skills — reconciliation, collections, vendor quotes, contracts, campaign briefs. Download one and Claude runs the whole procedure for you.
Open the Skills Library →