This is the kickoff workshop in our AI Fridays series. The goal of these 30 minutes is simple: by the end you should know what Claude is, where you can use it, and what the buzzwords mean — without the jargon hangover.
You don't need to take notes. This document is the notes. Skim during the workshop, read after, and use it as a reference any time someone uses a term you don't recognise.
Each section is short by design. If you're skimming, focus on the bold sentences and the comparison table at the end — that's where the practical decisions live.
LLM stands for Large Language Model. It's a neural network trained on enormous amounts of text — books, websites, code, conversations. After training, it can generate fluent, useful text by predicting what comes next, one chunk of text at a time.
That's it. The technology under all the buzz is fundamentally a really good autocomplete that has read the internet.
Because at scale, "predict the next chunk of text" turns out to be a remarkably general skill. To predict the next word in a code review, the model has to understand the code. To predict the next sentence in a customer support reply, it has to understand the customer's frustration. So the prediction task forces it to learn structure, reasoning, and tone — not just word frequencies.
The major players as of 2026:
For everyday work, you'll be using Claude. Other tools are out there; we picked Claude because it's currently strongest on careful, structured work — and it has the best toolset for the kind of internal automation we want to build.
Every LLM company offers multiple models — different sizes, different speeds, different prices. Bigger models tend to be smarter but slower and more expensive to run.
| Claude model | What it's for | Trade-off |
|---|---|---|
| Haiku | Fast, cheap, lightweight tasks (classification, simple drafts) | Less depth on complex reasoning |
| Sonnet | The everyday workhorse — most tasks land here | Good balance of speed, cost, depth |
| Opus | Hardest reasoning, most nuanced writing, longest plans | Slower and pricier per call |
Current generation as of May 2026: Haiku 4.5, Sonnet 4.6, Opus 4.7.
Most of the time you don't pick the model — the tool does. But if you're using the API or building something custom, you'll choose explicitly.
Claude (and most modern LLMs) can run in different modes:
You don't have to switch modes manually most of the time. The tool you're using picks the right one for the task.
The context window is how much text Claude can "remember" in a single conversation. It's measured in tokens (more on those next).
Claude Sonnet 4.6 supports a 1 million-token context window in beta — roughly 750 pages of text. Claude Opus 4.7 also supports 1 million tokens. Older Claude models, and many third-party tools embedding Claude, still default to 200,000 tokens (~150 pages). When the conversation exceeds the window, the oldest content drops out.
If a conversation feels like Claude is "forgetting" earlier instructions, slowing down, or getting vague, you've likely overfilled the context window. Focused context beats more context. Three ways to manage long sessions:
/compact to replace the current conversation with a structured summary. Most startup content (CLAUDE.md, skills, MCP tools) reloads automatically afterwards.A token is a chunk of text. Roughly three-quarters of a word for English text on older Claude models. Newer models (Opus 4.7) use a different tokenizer that may produce up to ~35% more tokens for the same text. Hello world is around 2 tokens. A short email is around 200 tokens. The Bible (King James) is about 800,000 tokens on older tokenizers.
Tokens matter for two reasons:
Anthropic offers three different ways to talk to Claude. Same underlying model, very different surfaces.
What it is: a web app at claude.ai, plus a desktop app you can install on Mac and Windows. The chat interface — like ChatGPT but Claude.
Who it's for: everyone. Marketing, sales, ops, customer support, leadership, engineering — anyone who wants to ask Claude a question, draft a message, summarise a doc, brainstorm.
What you can do: conversational chat, upload documents, get back text/code/analysis. You can also create Projects (more on those in Part 3) — available on all plans, with a Team subscription enabling shared Projects with colleagues.
Drafting an email, rewriting a customer message, summarising a long PDF, getting unstuck on a hard task, brainstorming names for a feature.
A few features live only in claude.ai chat:
What it is: a feature inside the Claude desktop app focused on knowledge work. Imagine Claude Code's superpowers (file access, web access, automation) but designed for non-developers and broader tasks.
Who it's for: everyone who isn't a developer but wants Claude to do things, not just talk. Marketing, ops, PMs, customer support, leadership.
What it can do: work autonomously on your files, navigate the web, connect to your Notion / OneDrive / Slack via MCPs (Part 3), run multi-step automations, produce documents and reports.
Scheduled tasks: Cowork can run a task on a recurring schedule (hourly, daily, weekly, weekdays only) using everything you've connected. Type /schedule inside any task to set one up. Example: "Every Monday at 9am, scan our Notion AI hub for changes since last week and post a summary to #ai-updates on Slack." Caveat: only runs while your computer is awake and Claude Desktop is open — runs are skipped if the machine is asleep, then auto-rerun on wake.
Pulling together a weekly report from Notion + Salesforce, drafting and saving a contract from a template, organising a folder of files, building a dashboard, automating recurring tasks.
What it is: a command-line tool that lives in your terminal. You type claude and you're in a conversation with Claude — but Claude can also read your files, edit code, run tests, and execute shell commands.
Who it's for: developers. Specifically, software engineers and anyone comfortable working in a terminal. Not relevant for non-technical roles.
What it can do: agentic coding. Give it a task ("fix this bug," "add OAuth to the login flow"), and it'll read the relevant files, plan a change, edit code, run tests, and report back. Iterates autonomously.
Bug fixes, refactors, dependency upgrades, writing tests, scaffolding new features, code reviews. The kind of "this is mostly mechanical but tedious" work.
These seven terms come up constantly. Here's what each one actually means, ordered roughly from atomic capability to broadest container.
A skill is a folder of instructions and examples that Claude auto-loads when relevant. Think of it as a recipe card the model picks up when the situation calls for it.
Example: a customer-support skill that auto-fires when you ask Claude to draft a reply, applying your team's tone and SOP without you having to ask each time.
Default skills you get out of the box: every Claude product ships with skills you can use without installing anything. The ones most useful for everyday work in Claude.ai chat and Cowork:
Browse and manage them via Customize → Skills. Claude Code also bundles developer-focused skills (/simplify, /debug, etc.) for engineering workflows.
Install custom skills: place a SKILL.md file in ~/.claude/skills/<name>/ (user-wide), or in .claude/skills/<name>/ (project-only), or via a plugin. In Claude.ai chat and Cowork, install via the Skills directory in the UI.
Invoke: Claude auto-loads it when its description matches what you're asking, or you can type /name to invoke it manually.
Slash commands are a subset of skills that can only be manually invoked — you type /name to trigger them. Built-in examples: /help, /clear, /memory, /context.
Useful for actions with side effects (like /deploy) where you want a human in the loop, not Claude deciding to fire them.
Install: install a skill the normal way (see Skills above) and add disable-model-invocation: true to its frontmatter — that hides it from auto-invocation, leaving manual invocation only.
Invoke: type /name in your conversation. That's the only way.
MCP stands for Model Context Protocol — a standard for connecting Claude to other apps and services. A connector is an MCP that links Claude to a specific app.
Examples: the Notion connector reads and writes your pages. Slack searches and posts messages. A Zendesk or Intercom connector triages support tickets and drafts replies. An SEO connector (Ahrefs, Google Search Console) pulls keyword and ranking data into the chat.
Install: Claude.ai chat and Cowork both use the same Connectors Directory — click to add and authenticate. Claude Code uses claude mcp add <name> … from the terminal.
Invoke: Claude calls the right connector automatically when the task needs it. You don't trigger it directly.
Used in: Cowork, Claude Code, some Claude.aiSubagents are mini-Claudes the main Claude can spawn to handle a chunk of work. Their context is isolated from the main session — they read 50 docs, only the summary comes back.
Example: when Claude needs to do a deep research task, it spawns an agent. The main conversation stays clean.
Install: custom subagent definitions go in .claude/agents/<name>.md. Built-in agents (Explore, Plan, general-purpose) are available without setup.
Invoke: Claude does it automatically via the Task tool when delegating work. A skill can also declare context: fork to run inside a subagent.
Note: Claude Code supports user-defined subagents in .claude/agents/. Cowork uses subagents internally but doesn't expose user-defined ones in public docs.
Hooks are deterministic scripts that fire automatically on lifecycle events — before a tool runs, after a file edit, on session start, when you submit a prompt. They run as plain scripts (no LLM), so behaviour is predictable.
Example: run a linter after every edit. Block a commit if the diff contains AWS keys.
Install: write a Python or bash script (e.g. ~/.claude/hooks/pre-commit-quality.py), then register it in ~/.claude/settings.json under the matching event (PreToolUse, PostToolUse, Stop, etc.).
Invoke: you don't — it fires on the lifecycle event automatically. Set it up once, it runs forever (until you remove it).
Used in: Claude CodeA plugin is a bundle that contains skills, MCPs, agents, hooks, and/or commands packaged together. Install once, get a whole package.
Examples:
/quote command./rewrite command.Install: from a plugin marketplace via the marketplace UI (Cowork) or /plugin install <name>@<marketplace> from inside a Claude Code session. Your team can host an internal marketplace for company-specific plugins.
Invoke: nothing extra to do once installed — the contained skills, MCPs, hooks, and agents become available with their own normal invocation methods.
Used in: Cowork, Claude CodeA Project is a scoped conversation space with its own instructions and knowledge files. Every conversation inside the Project uses them; outside the Project, they don't apply.
Example: an "Customer Support" Project with our brand voice and Tier 1 SOP — every chat there knows our tone and policies.
Why Projects matter:
Install: create a Project from the Projects UI in Claude.ai or Cowork. Add Project instructions in the settings panel; upload knowledge files into the Project area.
Invoke: start a new conversation inside the Project. Instructions and knowledge are applied automatically.
→ See a sample project instruction
Used in: Claude.ai chat, CoworkNow that you know the vocabulary, here's the bigger picture: where does all that context come from when you start a conversation, and how do you keep it from getting bloated?
Before you even type your first message, Claude already has a lot of context loaded. It flows from the broadest scope (set by Anthropic, applies to every conversation) down to the most specific (your message, right now). Each level layers on top of the one above it.
What makes Claude.ai chat feel different from Cowork or Claude Code. You don't see it; you can't change it.
~/.claude/CLAUDE.md (Claude Code)./CLAUDE.md and ./CLAUDE.local.md (Claude Code)MEMORY.md — first 200 lines or 25KB (Claude Code)Whatever you just typed.
CLAUDE.md eats into your 200K window before you've said a word. Keep persistent instructions tight./memory to see every CLAUDE.md and auto-memory file in your session. In Claude.ai, check your Project's instructions and knowledge files.Only the first level (the product system prompt) is technically a "system prompt" in the API sense. The other levels arrive as user messages or tool outputs. Functionally they behave the same — they shape Claude's behaviour for the whole conversation — but if you ever read about API design, this is why a CLAUDE.md file isn't strictly equivalent to setting a system prompt.
Habits that pay off the moment your conversation gets non-trivial:
src/api/users.ts and explain the auth flow" is much cheaper than "look through the codebase and explain how auth works." Same for the web — give Claude a specific URL or query rather than asking it to "research X."Within one conversation, the context window does the remembering (Part 1). But what about the next time you talk to Claude? Different products use different mechanisms to persist things across conversations. Knowing which is which saves a lot of confusion.
Both Claude.ai chat and Cowork organise work into Projects. Each Project has:
Outside the Project, none of this applies. Useful for a focused context that shouldn't bleed into your other work — e.g., an "Customer Support" Project with our SOP and tone of voice, kept separate from general chats.
→ Sample project instruction (jump to appendix)
Both Claude.ai chat and Cowork have account-wide instruction fields where rules apply to every conversation, regardless of which Project you're in.
Use either for things you'd otherwise retype every conversation: preferred terminology, communication style, role context, "always do X" rules, typical scenarios you encounter.
→ Sample global instructions — Epistemic rules (jump to appendix)
Related personalization feature in Claude.ai chat: Styles customise how Claude formats responses (tone, structure, length). Styles are about delivery; Instructions are about context. They work independently or together.
Claude Code uses a different mechanism: CLAUDE.md markdown files at multiple scopes that load at the start of every session. More specific scopes win on conflict.
./CLAUDE.md): lives in the project folder, shared with your team via git. "All API handlers live in src/api/handlers/."~/.claude/CLAUDE.md): your personal preferences, applied to every project on your machine. "Always use British English."./CLAUDE.local.md): per-project personal preferences, gitignored — just for you on this project.This is the canonical way to give Claude Code persistent instructions. Cowork and Claude.ai chat use the Project instructions section instead.
Claude can take notes about you and your work without you having to repeat yourself. When you correct it ("no, we use pnpm not npm") or it learns something useful ("the build command is `make ci`"), it can save that for next time. The mechanism and scope differ per product:
~/.claude/projects/<project>/memory/. Per-project (per git repo), machine-local — doesn't sync across devices or cloud.Practical advice: open the Memory area in whichever Claude product you're using and you'll see exactly what it's remembering. Edit or delete entries you don't want.
Triggering a memory write yourself (Claude.ai chat & Cowork): just tell Claude — "remember that we use pnpm not npm" or "save this to memory" — and it'll write the entry. You can also add or edit entries manually in Settings → Capabilities → "View and edit memory."
Search past chats (Claude.ai chat only): a separate feature from Memory. When you reference an earlier chat ("what did we decide about X last week?"), Claude searches your chat history directly via RAG and pulls in the relevant excerpts. Toggle under Settings → Capabilities → Preferences → "Search and reference chats." Scope: searches all your non-project chats when you're outside a project, or just the current Project's chats when you're inside one. Doesn't apply to Cowork tasks.
Skills, MCPs, agents, commands, hooks are the parts. Plugins bundle them. Projects scope a conversation to its own instructions and knowledge (Claude.ai chat, Cowork). Instructions for Claude (Claude.ai) and Global instructions (Cowork) sit at your account level. Styles change how Claude formats responses (Claude.ai). CLAUDE.md is your written rules (Claude Code). Auto memory is what Claude writes for itself, per project, on your machine.
This is the table to bookmark. When someone says "can I use [feature] in [product]?" — this answers it.
| Concept | Claude.ai (chat) | Cowork | Claude Code |
|---|---|---|---|
| Audience | Everyone | Everyone (knowledge work) | Developers |
| Interface | Web / desktop chat | Desktop app | Terminal CLI |
| Persistent instructions | ✓ Instructions for Claude + Project instructions + Styles | ✓ Global instructions (Settings → Cowork) + Project instructions | ✓ Via CLAUDE.md (project + user + local) |
| Skills | ✓ Settings → Capabilities → Skills | ✓ Customize → Skills (plus more via plugins) | ✓ ~/.claude/skills/ |
| MCPs / Connectors | ✓ Many (Notion, Slack, etc.) | ✓ Many (Notion, Slack, etc.) | ✓ Configurable |
| Slash commands (manually-invoked skills) | ✓ via skills | ✓ | ✓ |
| Agents (subagents) | ✗ | ✓ | ✓ |
| Hooks (lifecycle scripts) | ✗ | ✗ | ✓ |
| Plugins | ✗ | ✓ | ✓ |
| Projects | ✓ | ✓ | via working directory + CLAUDE.md |
| File access | Uploads + via connectors (Google Drive, OneDrive, SharePoint) | Selected folders (you grant access) | Working directory + --add-dir (with permission rules) |
| Web browsing | Web search + Research | ✓ | Built-in WebFetch + WebSearch |
| Best for | Quick questions, drafting, summarising | Knowledge work, automation, multi-step tasks | Coding, dev workflows |
You don't have to pick one and stick with it. Most people will use claude.ai daily and reach for Cowork when a task gets bigger.
Friday, May 15, 2026 · Online
"Why your prompts suck and how to fix them." We'll show what makes a prompt great and the difference it creates. Bring a real bad prompt of yours — sales email, customer message, code review, anything. We'll iterate on real ones live.
Drop-in office hour. Bring anything AI-related you're stuck on — prompts that aren't working, workflows you'd like to automate, weird outputs, "where do I even start" questions. No agenda, no judgment, lurking welcome.
DM Dogus, or post in #ai-office-hours on Slack.
Notes, best practices, recaps, the Prompt Standard, the developer Claude Code setup guide — all live in our Notion AI hub: an internal AI hub. Find it under the team workspace → the KnowHow space → an internal AI hub.
Three things. Claude is an LLM. You'll mostly use it through claude.ai chat or Cowork. If you're stuck, come to AI Fridays.
Two ready-to-paste examples showing how layered instructions actually work in practice. The global rules cover how Claude should think — flag uncertainty, don't fabricate, ask before assuming. The project rules cover what's true in this domain — terminology, audience, output format. Inside the project, both apply. Outside, only the global rules do.
These rules apply to every conversation, in every Project, on this account. Paste them into Claude.ai chat → Settings → Instructions for Claude, or Cowork → Settings → Cowork → Global instructions.
## Epistemic rules
- If you are uncertain, say so explicitly. Use phrases like "I'm not sure" or "I'd need to check" rather than guessing.
- Never fabricate facts, citations, file paths, function names, API endpoints, or data. If you don't know, say you don't know.
- Distinguish what you know from what you assume. When you assume, label it: "Assuming X, then…"
- If the request is ambiguous or missing key info, ask one focused clarifying question before doing the work — do not proceed on best-guess assumptions for high-cost actions.
- For low-cost reversible actions, you may proceed and flag your assumption explicitly.
- If you make a mistake, acknowledge it directly and correct it. Do not over-apologize or cover.
- Never claim a task is complete unless you've actually verified the output (ran the code, read the file, checked the result).Project-level rules layer on top of the global ones. Paste this into a Claude.ai or Cowork Project's instructions field. Note how this file says nothing about epistemic hygiene — that's already handled by the global rules above. This file only adds what's specific to the working context: who the audience is, which language to use, and what's off-limits without sign-off.
# Project purpose
Anything customer-facing — emails, FAQ updates, support replies, marketing copy. Drafts, edits, reviews, brainstorming.
# Standing rules
- Audience is mostly fleet operators and dealerships, not battery experts. Default to plain language; only use technical terms if the customer used them first.
- Tone: factual and helpful. No marketing-hype superlatives ("world-leading," "revolutionary").
- Anything involving pricing, warranty terms, or delivery dates — flag for me to confirm before producing a final draft.
- For technical claims about a battery, only use figures I provide. Don't estimate.
# Language selection
- Match the customer's language. If they wrote in German, respond in German. If in English, respond in English.
- For internal-only material (notes to me, drafts I'll edit before sending), default to English.
- If the input is mixed-language or you can't tell which language the customer uses, ask before drafting. Don't default to one or the other.Global instructions stay short and universal — they describe how you want Claude to behave at all times. Project instructions stay focused on a single use case — they describe the world this project lives in. Mixing the two leads to bloated, hard-to-maintain instruction files that eat your context window before you've even typed a message.
The Anthropic docs used to verify the claims in this workshop. Bookmark anything that looks useful.