Get genuinely good at working with Claude.

01 - Foundations

How Claude actually works L1

You don't need to understand the engine to drive the car. But knowing a few things about the engine explains almost every weird thing Claude does - and turns "why did it do that?" into "ah, of course."

It predicts, it doesn't look up

Claude is a large language model (LLM). During training it read an enormous amount of text and learned the patterns of how language, ideas, and reasoning fit together. When you ask it something, it isn't retrieving an answer from a database - it's generating a response one piece at a time, each piece chosen because it's the most sensible continuation of everything so far.

This one fact explains a lot:

• It's brilliant at anything language-shaped - drafting, summarizing, translating, explaining, reformatting, brainstorming, reasoning through a problem. This is its home turf.
• It can sound completely confident and still be wrong. This is called a hallucination. Because it's generating plausible text, a made-up statistic can look exactly as fluent as a real one. Always verify facts, figures, names, quotes, and citations.
• By default it doesn't know today's news or anything private to you. Its knowledge stops at a training cutoff date, and it can't see your email, your files, or the live web - unless you give it a way to. That "way" is web search, connectors, and uploads, which we cover later.

The context window is its working memory

Everything in your current conversation - your messages, its replies, any files you've attached - sits in what's called the context window. Think of it as the desk Claude is working at. It's large, but not infinite. When a conversation gets extremely long, the earliest things can effectively slide off the desk, and Claude may start to lose the thread.

The practical takeaway: a focused conversation beats a sprawling one. More on when to start fresh in section 03.

It's a mirror for your input

The single biggest lever you control is the quality and specificity of what you put in. A vague question gets a generic answer; a specific, well-framed request with examples gets something genuinely useful. That's not a limitation - it's the whole skill, and it's the next section.

02 - The essentials

Getting started: the core habits L1

If you take nothing else from this guide, take these. They're the difference between a party trick and a tool you rely on.

1. Give it a role, a goal, and the guardrails

The most reliable prompt formula isn't magic words - it's just telling Claude what you'd tell a capable new hire: who to be, what you want, and what "good" looks like.

• Role / context - "You're helping me, a marketing manager, prep for a client meeting."
• The actual task - "Draft a one-page agenda."
• Constraints & format - "Keep it under 200 words, use bullet points, professional but warm tone."

2. Show it an example

If you want output in a particular shape - a certain email style, a table layout, a tone - paste an example of one you like. Claude is exceptional at matching a pattern. One good example is worth a paragraph of description.

3. Treat it like a conversation, not a vending machine

The first answer is a draft, not a verdict. Push back: "shorter," "more skeptical," "you missed the budget angle," "rewrite the third paragraph." Iterating in a thread is where the quality actually comes from - most people quit one turn too early.

4. Ask it to think, or to ask

For anything complex, two phrases do a lot of work: "Think it through step by step before answering," and "Ask me any clarifying questions before you start." The second one is a cheat code - it turns a guessing game into a briefing.

What good and bad prompts actually look like

Same underlying need. Watch what specificity does.

Go beyond "answer my question"

The leap from casual to power user is realizing Claude does whole categories of work, not just Q&A. A starter menu:

• Transform - turn a messy transcript into clean meeting notes; a spreadsheet into a summary; a dense report into three bullet points.
• Draft - first versions of emails, docs, proposals, job descriptions, tricky replies. Getting to a rough draft is the slow part; Claude erases it.
• Think with you - "poke holes in this plan," "argue the opposite side," "what am I not considering?"
• Learn - "explain this like I'm smart but new to it," "quiz me on this material," "walk me through this contract clause by clause."
• Do multi-step work - with the right setup (later sections), it can pull from your tools and complete a whole task, not just talk about it.

03 - A common question

One thread or a new one? L1

Almost everyone gets this slightly wrong at first - either cramming a month of unrelated questions into one endless chat, or starting fresh so often they re-explain themselves constantly. Here's the rule.

Stay in the thread when…

• You're iterating on the same piece of work - refining a draft, going deeper on one analysis.
• The earlier back-and-forth is useful context Claude should keep in mind.
• You're building something up over several steps.

Start a new thread when…

• You've switched to a completely unrelated task. (Old context becomes clutter - and can even bleed into the new answer.)
• The conversation has gotten very long and Claude seems to be "forgetting" or drifting. A fresh start with a quick summary often works better than fighting a bloated thread.
• You want a clean, unbiased take unaffected by everything said above.

Why this works differently in Chat vs. Code

The principle is the same, but the stakes differ, and it's worth knowing why.

04 - Know your tools

Chat vs. Cowork vs. Code L1L2

These are three different ways to work with the same underlying Claude. Picking the right one for the task is one of the most useful things you'll learn here.

Desktop app vs. web browser L1

Chat and Cowork both run in a web browser and in a downloadable desktop app. Same account, same conversations synced between them - so which should you use?

05 - Stop repeating yourself

Projects L2

A Project is a dedicated workspace in Claude Chat that remembers your context so you never have to re-explain it. If you find yourself pasting the same background into chat after chat, this is the fix.

What a Project actually is

Two things bundled together, shared across every conversation you start inside that Project:

• Custom instructions - standing directions for how Claude should behave here. ("You're my brand's copy assistant. Always use British spelling. Never use exclamation marks. Our tone is dry and understated.")
• Knowledge / files - reference material you upload once: style guides, product docs, past examples, a spreadsheet of facts. Claude can draw on all of it in any chat within the Project.

Why they're worth it

• No more re-briefing. Every chat starts already knowing your context.
• Consistency. Outputs stay on-tone and on-brand because the rules live in one place.
• Organization. All the chats for one client, initiative, or area of your life live together instead of scattered across your history.

When to create one

Make a Project whenever a topic is recurring and carries reusable context. Good candidates: a specific client, an ongoing initiative, "my writing," a course you're taking, a product you own. Skip it for genuine one-offs - a normal chat is fine for those.

1. Create the Project

   In Claude Chat, create a new Project and give it a clear name.

2. Write custom instructions

   Describe the role, the rules, the tone, and anything Claude should always keep in mind. This is where you encode "how we do things here."

3. Add knowledge

   Upload the reference files and examples Claude should rely on. Add to this over time as you find yourself wishing it "just knew" something.

4. Work inside it

   Start your chats from within the Project. Each one inherits the instructions and knowledge automatically - you just get to work.

06 - Teach it once, reuse forever

Skills L2L3

A Skill is a saved set of instructions that teaches Claude how to do a specific, repeatable task your way. Where a Project holds context, a Skill holds a procedure - and Claude pulls it up automatically when it's relevant.

First: what's an "MD file"?

Skills are written in a file format called Markdown - the file ends in .md. Don't let the tech-y name put you off. A Markdown file is just a plain text file with a few simple formatting rules:

• # Heading makes a heading.
• **bold** makes text bold.
• A line starting with - makes a bullet point.

That's basically it. You can open, read, and edit an .md file in any text editor - the free Notes-style apps that come with your computer, or a code editor. It's the same plain writing you already do; Markdown is just the lightweight way of marking what's a heading and what's a bullet. Claude reads and writes Markdown fluently, which is why Skills use it.

Anatomy of a Skill

A Skill is a Markdown file (conventionally named SKILL.md) with two parts: a short label at the very top, then the instructions below it.

---
name: weekly-report
description: Turn my raw notes into our team's weekly
  status format. Use when I paste notes and ask for a
  weekly update.
---

# Weekly Report

When I give you raw notes, produce an update with:

1. **Shipped** - what got done, one line each
2. **In progress** - with a status
3. **Blockers** - what's stuck and who can help

Keep it under 200 words. Plain language, no jargon.

The label is the bit between the two rows of dashes. The dashes do nothing clever; they just mark where the label starts and stops. Inside it you write two lines:

• name - what you're calling the skill.
• description - a one-line summary of what it does and when to use it. This part matters enormously: it's how Claude decides, on its own, when to reach for this Skill. Write it the way you'd describe the task to a coworker.

Everything below the label is the actual instruction manual - as detailed as you like.

If you go looking for more on Skills elsewhere, you'll see this label called frontmatter. Same thing, and you never have to use the word.

How to create one with Claude

You've now seen what a Skill looks like, which is useful for reading one. Don't write one by hand. Have Claude write it, and spend your effort on telling it what good looks like.

That last sentence is the one that does the work. Without it you get a Skill built from whatever Claude assumed. With it, Claude interviews you first, and the questions are usually the ones you'd have forgotten to answer: what format do you want, who reads this, what should it never do, what does a good one look like versus a bad one.

1. Answer the questions properly

   This is where the quality comes from. Vague answers make a vague Skill. If you have a past example of the task done well, paste it in.

2. Let Claude write the file

   It produces the whole SKILL.md, label and all. Read it once and check it sounds like how you'd explain the task to a new hire. Anything that reads wrong, say so and have it revise.

3. Put it where Claude can reach it

   Chat and Code each have their own spot for this. Both are covered just below.

4. Run it on a real task, then fix it

   The first version is rarely right. Use it on actual work, tell Claude what was off, and have it update the Skill. A Skill you've corrected three times is worth more than one you wrote perfectly in theory.

Using Skills in Chat

1. Upload it

   In Claude Chat's settings, find the Skills section and add your Skill (or its folder). This makes it available to your conversations.

2. Let it fire automatically

   Because you wrote a good description, Claude recognizes when a task matches and applies the Skill on its own. Paste your notes and say "weekly update," and it follows your recipe.

3. Or invoke it directly

   You can also call a Skill by name to be explicit - for example, many surfaces let you type a slash command like /weekly-report. Either way, Claude runs your saved procedure instead of improvising.

Using Skills in Code L3

Claude Code uses the same Skills, just stored in a specific place. You put each skill in a folder inside a .claude/skills/ directory - either in your project (so it's specific to that project) or in your home folder (so it's available everywhere).

.claude/
  skills/
    weekly-report/
      SKILL.md       # the skill itself
    release-notes/
      SKILL.md

Once a Skill lives there, Claude Code discovers it automatically and - just like in Chat - either applies it when the task matches the description, or runs it when you invoke it by name (e.g. /weekly-report). The .claude/skills/ folder is the only new idea; the Skill file is identical to the one you'd use in Chat.

07 - Personalization

Make Claude sound like you L1L2

The best part of using Claude over time: it stops feeling generic. You can teach it your voice, your standards, and your preferences once - so you stop re-explaining "keep it brief, non-technical, no em-dashes" every single time.

Out of the box, Claude writes in a competent but neutral, faintly corporate voice - the "AI voice" everyone can spot. Getting past that isn't about a magic prompt. It's about giving Claude a durable sense of who you are and how you like things, and storing that in the right place.

Show, don't tell - the fastest lever

Whatever method you use, the single most effective way to teach your voice is examples. Paste two or three things you've actually written and say "match this voice." Claude is far better at copying a real sample than interpreting adjectives like "professional but warm." Even better, turn your samples into reusable rules:

Match the preference to the right home

There are a few places to store "how I like things," and the trick is matching the scope of a preference to the right one. A universal rule shouldn't live inside one Skill; a niche deliverable's format shouldn't clog your global settings.

1. Profile preferences - the global baseline L1

In Claude's settings there's a place for standing instructions that apply to every conversation. This is home for your always-true rules - tone, formatting, pet peeves. Set "keep it brief, non-technical, no em-dashes" once here and it follows you everywhere, no Project or Skill required. If you do one thing from this section, do this.

2. Memory - and its two different flavors

"Memory" means two different things depending on where you're working, and it's worth not mixing them up:

• In Claude Chat (the browser, the mobile app, or the desktop app): Claude can build up a memory of you across conversations, so useful facts and preferences carry forward without you repeating them. You can nudge it directly: "remember that I prefer bullet points over paragraphs." This is the automatic, no-setup kind. (Exactly how it works varies by product and plan, so where you have it, lean on it.)
• In Claude Code: memory is a set of plain files you control, not something it learns on its own. Claude Code reads a project memory file and a global one in your home folder every time it starts (often a memory.md, alongside a CLAUDE.md that holds project instructions), so your standing facts and rules are always in front of it. Same goal, but here you write and edit the memory yourself.

3. Projects - personalization scoped to an area

A Project (§05) shapes every chat inside it with its own instructions and knowledge. Perfect when your voice or rules change by context - one client wants formal, another wants breezy, your personal writing is different again.

4. Skills - bottle a specific deliverable's voice

When a particular thing you produce has its own exact standard, a Skill (§06) captures not just the steps but the voice and the rules. This is the most precise form of "sound like me," and it travels - you can share the Skill so a whole team's output matches.

Keep teaching it

Personalization compounds. Every time Claude gets something wrong, don't just fix it in the moment - decide where the correction belongs. A one-off? Just say it. A forever rule? Add it to your profile. Specific to one deliverable? Update the Skill. Treat those corrections as deposits: a little effort now, paid back every future time.

08 - Give Claude hands

Connectors & MCPs L2L3

By default Claude can't see your Slack, your email, your files, or your company's data. Connectors change that. They're the bridges that let Claude read from - and sometimes act in - the tools you already use.

Connector, MCP - what's the difference?

Mostly just vocabulary. MCP (Model Context Protocol) is the open standard - the shared "language" that lets Claude plug into an outside tool. A connector is a friendly, ready-made MCP connection you can turn on with a click. So: all connectors are MCPs under the hood; "connector" is just the polished, no-setup version. When someone says "add the Slack MCP," they mean "connect Slack."

Kind 1 - Connectors already in Claude's directory L2

Claude ships with a built-in directory of popular connectors - the likes of Slack, Gmail, Google Drive, Google Calendar, and more. These are the easy ones: no technical setup, just sign in and approve.

1. Open the connectors directory

   In Claude's settings, go to Connectors and browse what's available.

2. Pick one and connect

   Click Connect on, say, Gmail. You'll be taken to a familiar sign-in screen for that service.

3. Approve the access

   The service asks whether to let Claude in, and shows what it'll be able to do. Review it, approve, and you're bounced back to Claude. This standard "sign in and approve" handshake is called OAuth - the same thing that happens when one app asks to use your Google login.

4. Use it in conversation

   Now you can say "search my inbox for the contract from Acme" or "what's on my calendar Thursday?" and Claude actually goes and looks.

Kind 2 - Connecting a vendor's own MCP L3

Not every tool is in the directory. Many software vendors now offer their own MCP server that you connect to manually. A content-management platform like Hygraph, for example, exposes an MCP so Claude can query your CMS data directly. Connecting one is a little more hands-on, but it's the same idea, and it's very doable.

You'll typically need two things from the vendor:

1. The server address (URL)

   The vendor publishes an MCP endpoint - a web address, usually in their docs, that looks something like https://api.your-vendor.com/mcp. That's where Claude will connect.

2. An access token

   Because this is your private data, the vendor needs to know it's really you. You generate a token in that tool's settings - often called an API key or a Personal Access Token (PAT). Think of it as a long, secret password made specifically for apps to use on your behalf.

3. Add a custom connector in Claude

   In Claude's Connectors settings, choose to add a custom connector, then paste in the server URL and the token where prompted.

4. Test it

   Ask Claude something only that tool would know - "list the last five entries in my CMS." A real answer means you're connected.

09 - Right tool, right job

Choosing a model L1L2

Claude comes in a few models. They trade off speed and cost against raw capability. The names change as new versions ship - but the tiers have stayed remarkably stable, so learn the tiers and you'll never be lost.

A few practical notes

• You can switch mid-conversation. Draft with a fast model, then switch to the top tier for the one hard question.
• Better prompting often beats a bigger model. A clear prompt to Sonnet frequently outperforms a lazy prompt to Opus. Section 02 is cheaper than an upgrade.
• For agents doing long, multi-step work (Cowork, Code), the top tier's judgment usually pays for itself - a small mistake early can cascade through many steps.

10 - Keep this bit

The one-page recap

Everything above, compressed to what you'll actually remember.

• It predicts, it doesn't look up. Great with language, can be confidently wrong, and only knows what you or its tools give it. Verify facts.
• Specificity is the whole game. Role + goal + constraints + an example. If a smart stranger couldn't do the task from your prompt, add more.
• Iterate - don't accept the first draft. And ask it to think step by step, or to ask you questions first.
• One thread per train of thought. New topic → new chat. This matters even more in Code, where sessions carry real work.
• Pick the right surface. Chat to think and write · Cowork to delegate multi-step work without code · Code for technical, hands-on power. Install the desktop app if you're using it daily.
• Projects save your context so you stop re-explaining. Skills save your procedures so you stop re-teaching. Connectors give Claude access to your real tools and data.
• Teach it your voice once. Global rules (no jargon, no em-dashes) go in your profile preferences; a specific deliverable's style goes in a Skill. Stop re-explaining how you like things.
• Models: default to balanced (Sonnet), go fast (Haiku) for speed, go top (Opus) for hard problems.