2 Features, 5 Tools, 0 Code From You — turn your chat box into a coworker.

Most people use AI the way they use a vending machine. They walk up, type a request, take what falls out, and walk away. Tomorrow they walk up and type the whole request again: the same instructions, the same context, the same "no, our invoices look like this ," the same explanation of who they are and how their team does things. The machine remembers none of it. Every visit starts from zero.

There is a different way to work, and in 2026 it is no longer reserved for programmers. You can teach AI a task once and have it do that task your way, every time, without re-explaining. That is a Skill . And you can give AI safe access to the apps where your real work lives : your files, your email, your spreadsheets, your project tracker. With that access it stops asking you to copy-paste and starts reaching for things itself. That is a Connector .

This page is the afternoon where those two ideas click. No programming background assumed. If you are an accountant, a doctor, a marketer, an engineer, a teacher, or a student, every example here is built for you. By the end you will know what Skills and Connectors are, when to reach for each, how to use the ones that already exist, how to build your own (the AI builds it for you), and how to do all of this safely, across five different tools.

Where this sits in the book

This is a Foundations crash course; it assumes the mental model from What AI Actually Is , the first Foundations course. It pairs naturally with two others:

AI Prompting in 2026 teaches you how to talk to AI well: context, reasoning, avoiding flattery. If "context window" or "novice vs power user" are new phrases to you, skim that primer first or alongside this one; the two reinforce each other.

How to Think in the AI Era comes after, and trains the deeper skill underneath all of this: asking the right questions in the first place.

This course is the "here is what becomes possible" course. The other two are the "here is how to do it well" courses.

Last verified: June 2026

A few details here are point-in-time and will drift: menu paths, free-plan limits (today, one custom connector on the free tier), and the open-standard timeline (published December 2025). The ideas (teach once, connect your apps, automatic invocation, scope your access) are stable. When a step doesn't match what you see on screen, trust the screen and search the current docs.

📚 Teaching Aid

Open Full Slideshow

View Full Presentation — Skills & Connectors

The one idea under everything

Before the details, hold one sentence in your head, because every section below is a variation on it:

A chat message tells AI what to do this once . A Skill teaches AI how to do something every time . A Connector gives AI hands to reach your real apps and data.

A working kitchen makes this concrete. Picture a professional kitchen.

A one-time chat message is an order shouted across the counter: "make me a sandwich." It gets made once and forgotten the moment it's served. Nothing about how you like it survives to tomorrow.

The Connectors are the kitchen itself: the stove, the knives, the stocked pantry, the fridge full of your actual ingredients. Without them, a cook can describe a meal but cannot make one, having no tools and nothing to cook with.

The Skills are the recipe

The one idea as a diagram. Across the top, three pills: a chat message tells AI what to do this once; a Skill teaches AI how, every time; a Connector gives AI hands to reach your a

cards: step-by-step instructions for making a specific dish your way, the way your restaurant always makes it, so it comes out the same whether you are in the kitchen or your new hire is.

Give a cook a kitchen but no recipes, and every dish is improvised and inconsistent. Give them recipes but no kitchen, and they can read but not cook. Give them both, and they produce your dish, reliably, without you standing over them. That is the whole game. The rest of this page is just learning where the recipes and the kitchen live, how to write a recipe, and how to keep a stranger from slipping a bad one into your card box.

Six words to know before you start

A small glossary so nothing trips you later:

Skill : a saved set of instructions that teaches AI how to do one task your way.

Connector : a safe link that lets AI reach one of your apps (files, email, messages).

Fire / trigger : when AI activates a skill on its own because your request matched it.

Scope : how much access you give: a single folder, or everything. Smaller scope = safer.

Read-only : AI may look but not change. The opposite is write access (it may edit or send).

Progressive disclosure : AI keeps only a short summary of each skill loaded, and opens the full instructions only when needed. This is why many skills can be installed without slowing it down.

Part 1: The two upgrades

1. From chat box to operating layer

Here is the daily friction that Skills and Connectors remove. Read these as "before" pictures.

An accountant opens a fresh chat every month to prepare a client summary. Every month they paste in the same instructions: "Format amounts in our reporting currency

A three-stage pipeline diagram titled 'Together: the connector fetches, the skill formats, you review.' One plain-English sentence enters at the top — prepare this month&#3

with thousands separators, group by expense head, flag anything over the tax-withholding reporting threshold, and format it like the template I'm pasting below." The AI does it well, and forgets all of it the moment the chat ends.

A doctor dictates consultation notes and wants them in SOAP format every time, with allergies always pulled to the top. They re-explain the format daily.

A marketer wants every social caption in the brand voice: no exclamation marks, no "game-changer," always a question as the hook. They paste the brand rules into every single chat.

An engineer wants design review notes structured by severity, with a fixed checklist applied to each finding. Same paste, every review.

Notice the shape: a repeatable task , done your specific way , where the only thing changing is the input. That is exactly the shape a Skill is built for. You write the "how" down once, and AI applies it automatically whenever the task comes up.

Now a second kind of friction:

The accountant's actual numbers live in an Excel file and last quarter's figures are in an email attachment. The AI can't see either until they're uploaded by hand.

The doctor's patient history sits in a Google Drive folder.

The marketer's content calendar is in a project tool; the past posts are in a Drive folder.

The engineer's open issues are in a tracker like Jira or Linear.

The AI can reason brilliantly about all of this, if the information reaches it. Copy-pasting is the price you pay for the AI not having hands. A Connector removes that cost: with your permission, AI reaches into the app, pulls what it needs, and (when you allow it) writes results back.

Put the two together and the chat box stops being a chat box. It becomes something closer to a capable colleague who already knows your standards (Skills) and can get to your files and tools (Connectors). This shift, from "thing I type into" to "thing that acts on my real work," is what people mean when they call AI an operating layer rather than a chatbot.

2. What a Skill actually is

Once you remove the mystery, a Skill is almost embarrassingly simple: it is a folder with a text file in it.

The required text file is named SKILL.md (exactly that, capital letters and all). It holds two things at the top, a name and a description , and below that, the instructions you want AI to follow. That's the minimum. A skill can be nothing but a name, a description, and a paragraph of plain-English instructions, and it will work.

Optionally, the folder can hold more: example files, a template document, reference notes, even small scripts. But none of that is required to start. The accountant's first skill could be five sentences of formatting rules. The marketer's could be their brand voice guide, pasted in. And those optional scripts? They are real code, but you never write a line of it; AI writes any code a skill needs when you build

Claude's Customize then Skills list after saving. Under Personal skills, monthly-client-summary now appears, expanded to show its SKILL.md, references, and scripts, and it is t

it (Part 3).

Anthropic's own description: skills are "folders of instructions, scripts, and resources that Claude loads dynamically to improve performance on specialized tasks." The key word is dynamically : AI doesn't carry every skill in its head at all times. It keeps a short list of what each skill is for (that's the description), and only opens the full instructions when your request actually matches one. Engineers call this progressive disclosure , and it is why you can have dozens of skills installed without slowing anything down or confusing the AI. We'll come back to it when you build one.

The mental model

A Skill is a recipe card you write once and pin to the kitchen wall. Every time that dish is ordered, the cook follows the card: same result, no reminding. You are not in the kitchen, but your standards are.

3. What a Connector actually is

A Connector is how AI safely reaches your apps and data. Connect Claude to Google Drive and it can search your files; connect it to Gmail and it can read your mail and draft replies for you to send; connect it to Slack, Linear, Asana, Notion, and it can pull from and act in those tools.

Under the hood, connectors run on an open standard called MCP (Model Context Protocol). A connector is a small piece of software (an "MCP server") that a company, or increasingly an AI, built with code. You never build it or read it; you click Connect . That's the same bargain the rest of this book calls code you never write : the code is real and working for you, but writing it was never your job. You don't need to understand MCP to use a connector, any more than you need to understand how email is delivered to send one. What matters are three facts:

AI inherits your permissions. A connector can never reach something you yourself can't reach. If you don't have access to a file, channel, or record in the original app, the connector can't get to it either. Connecting Google Drive does not hand AI your whole company's drive, only what your own account can already open.

You choose read-only or read-and-write. "Search and summarize my email" is read-only and low-risk. "Send this email" or "create this issue" is a write action. Good practice is to start read-only and grant write access only once you trust how the tool behaves (more in the safety section).

You turn them on per conversation. Connecting an app once makes it available ; you still decide which connectors a given chat may use.

There is a directory of ready-made connectors (Google Drive, Gmail, Slack, Notion, Figma, Linear, Atlassian, and many more), and you can also add a custom connector to any service that speaks MCP. Some connectors are interactive : they render a live dashboard, task board, or design surface right inside the conversation rather than just returning text.

The mental model

A Connector is the kitchen: the tools and the stocked pantry. It is what lets AI actually do something with your real ingredients instead of just describing a meal it cannot cook.

4. Skills vs Connectors vs Projects vs Custom Instructions

Four features sound similar and beginners mix them up constantly. Here is the clean separation. Skills and Connectors are the two stars of this course; the other two are their close cousins, included so you stop confusing them.

Feature What it is Best for The one-line test Skill Reusable how-to instructions AI loads only when relevant A repeatable task done your specific way (formatting, voice, methodology, checklists) "I keep re-explaining how to do this." Connector Safe access to an external app or data source Reaching files, email, messages, tickets — reading them or acting in them "I keep copy-pasting from another app." Project A workspace with files and instructions always loaded for every chat inside it A body of work with standing context (a client, a course, a book) "These same files and rules apply to everything in this area." Custom instructions Preferences applied broadly to all your chats Global style ("be concise," "use metric units," "spell out acronyms the first time you use them") "I want this to be true everywhere, always."

The distinctions people find confusing:

Skill vs Project. A Project always loads its context the moment you open a chat in it, which is useful but always on . A Skill stays dormant until a request matches it, then activates anywhere, even outside any project. Standing background knowledge → Project. A procedure that fires on demand → Skill.

Skill vs Connector. This is the most important pair and the one you will use most. A Connector is access (what AI can reach); a Skill is expertise (how AI should behave). They are not alternatives; they are partners, which is the whole point of section 8.

Skill vs Custom instructions. Custom instructions touch everything you do. A Skill touches one kind of task. "Always reply in the same language I write to you in" is a custom instruction. "When I ask for a board paper, use this eight-section structure" is a skill.

5. The question everyone asks: do I type a slash command, or does AI just know?

This is the single most common point of confusion, and the YouTube tutorials get it half-right, so let's settle it cleanly.

In Claude.ai (the web and mobile app, your main tool), Skills fire automatically. ("Fire" here just means activate ; the term repeats throughout this page.) You do not type a slash command. You describe your task in plain language, AI reads your request, checks it against the short description of every skill you have switched on, and loads the matching one on its own. Ask "create a PowerPoint about Q3 results" and the PowerPoint skill activates without you naming it. Ask the accountant's "prepare this month's client summary" and, if their summary skill is on, it just happens, formatted their way.

This is by design. Remember progressive disclosure from section 2: AI is always quietly scanning your request against the descriptions of your installed skills. A good description is what makes the right skill

A diagram titled 'How a skill gets used — automatic by default.' A left-to-right flow shows three boxes: you describe your task in plain language; AI scans the short descri

fire at the right moment. (That is also why writing a sharp description is the most important part of building a skill, covered in section 12.)

So when do you see slash commands? In the more hands-on surfaces:

In Cowork and the Microsoft 365 add-ins (Claude inside Excel, Word, PowerPoint, Outlook), you can type / to browse your skills and pick one explicitly, handy when you want to force a specific skill rather than trust auto-detection. You can also just describe the task naturally; both work.

In Claude Code and OpenCode (the developer tools, covered in Part 4), skills also load automatically when relevant, and you can invoke them deliberately too.

And there's a third option that works everywhere , including Claude.ai: just name the skill in plain English. If auto-detection misses, write "use my brand-voice skill to draft this caption." That's the simplest way to force a skill without learning any special syntax.

You want to… In Claude.ai (web/app) In Cowork / Excel-Word-PPT add-ins In Claude Code / OpenCode Let AI decide Just describe the task — automatic Just describe the task — automatic Just describe the task — automatic Force a specific skill Name it: "use my X skill" Type / and pick it, or name it Name it, or invoke it directly Browse what's available Customize → Skills Type / in the sidebar List your skills directory

The takeaway

Default behavior is automatic : AI picks the right skill by reading your prompt. Slash commands and naming the skill are override tools for when you want to be explicit. You will spend 90% of your time letting it decide, which is exactly why the skill's description matters so much.

The same is true of Connectors : once you've connected an app and enabled it for the conversation, AI brings it in on its own when your request calls for it: "summarize the contract in my Drive" pulls from Drive without you clicking anything. You don't invoke a connector by command; you just ask for the thing that needs it.

Part 2: Using what already exists (no building required)

You can get enormous value before you ever build anything. Anthropic and its partners have already made skills and connectors you can switch on in two minutes.

6. The skills that come built in

Anthropic maintains a set of skills that turn out finished files, and they all ride on a single switch: Code execution and file creation (Settings → Capabilities). Flip it on and these just work:

Word : professionally formatted .docx documents

PowerPoint : full slide decks from a description

Excel : real spreadsheets with formulas and formatting, not just a table pasted into chat

PDF : creating and filling

Claude Settings, Capabilities tab. The "Code execution and file creation" toggle is switched on, described as: Claude can execute code and create and edit docs, spreadshe

PDFs

Settings → Capabilities. This one switch is the engine . Flip it on and the file skills work. Notice the label "Required for skills," and that the Skills panel itself now just says "moved to Customize."

You just ask. Tell Claude "prepare a slide deck introducing agentfactory.panaversity.org to a general audience" and a finished deck comes back, ready to download.

When you open Customize → Skills (it's its own item in the left sidebar, next to Connectors), do not be thrown to find just one skill sitting there on a fresh account: skill-creator

Claude's Customize panel, the Skills tab. The left rail shows Skills and Connectors. The personal skills list holds a single entry, skill-creator, expanded to show its files: S

, an Anthropic skill whose whole job is to help you build skills of your own (you'll do exactly that later). That is correct, not a bug. The document skills are not missing; they live in the engine, not on this shelf.

Customize → Skills. The shelf . One skill today, skill-creator, plus the "+" to browse or create more. The Word, PowerPoint, Excel, and PDF skills are deliberately not listed here.

Click that "+" and choose Browse skills to open the directory : skills you can install in one click, including partner skills from companies like Notion, Figma, and Atlassian, built to work hand in hand

![The Skills Directory in Claude, open

![Claude's Customize then Connectors

The Connectors Directory in Claude, opened from the Browse connectors menu. Tabs for Skills, Connectors, and Plugins, an "Anthropic & Partners" filter, and a search b

page. The left rail shows Skills and Connectors. A "Not connected" list shows a GitHub Integration entry. The "+" menu ne](https://bgflncyhkwanvcinmqdc.supabase.co/storage/v1/object/public/assets/content-assets/assets/images/customize-connectors-browse-c2a3e9b09637ec0af1db643108ec3a72.png)

ed from the Browse skills menu. Tabs across the top for Skills, Connectors, and Plugins, an "Anthropic & Partners" filter, and a s](https://bgflncyhkwanvcinmqdc.supabase.co/storage/v1/object/public/assets/content-assets/assets/images/browse-skills-directory-a5fadfdc764656735c005d5cd3be3f20.png)

with their connectors. Anything you install drops onto the same shelf. Installed skills are view-only : you can use them and toggle them off, but to change one you download a copy, edit it, and re-upload it as your own.

The directory behind "+ → Browse skills": one-click installs from Anthropic and partners. Whatever you add lands on the shelf.

There is also a wider ecosystem worth knowing exists. Because skills became an open standard in late 2025 (more in Part 4), public marketplaces appeared quickly, and community sites now list tens of thousands of skills you can download. That's a gift and a hazard: a free skill from a stranger is a text file you are about to let AI follow. We'll handle that in the safety section. For now: the built-in skills and the official directory are the safe place to start.

7. Connecting your apps

Connecting an app takes about a minute. From a chat, click the "+" in the lower-left (or type / ), hover Connectors , choose Manage connectors , then click the "+" beside Connectors to open the directory; or open Customize → Connectors from the left sidebar. Pick a service, click Connect , and complete the sign-in/authorization prompts; this is the same "allow this app to access your account" flow you've done a hundred times.

Customize → Connectors. The "+" opens Browse connectors (the ready-made directory) or Add custom connector for any app that speaks MCP.

The directory: search or browse, pick an app, click the "+", and complete the sign-in. These are the ready-made Anthropic and partner connectors.

A few practical notes that save you trouble:

After connecting, enable the connector for a conversation by opening the same "+" → Connectors menu and toggling on the ones you want this chat to use.

Free plans include one custom connector; the ready-made directory connectors are broadly available.

If you connect many apps, there's a Tool access setting that can load tools only when they're needed. Letting it load automatically is fine for most people; switch to load-on-demand if you have ten or more connectors active and want to keep conversations focused.

Watch for the Interactive badge: those connectors render live interfaces (a task board, a design canvas) inside the chat.

Worked example, the doctor, using made-up data so there is nothing real to mishandle. First, have Claude create the practice file: "Make a one-page Word doc of a fake patient intake form (call it DEMO-Okafor-2026-03, with three invented medications and one allergy) and save it to my Google Drive." That is the file engine from section 6 writing a document straight into your Drive. Now read it back: "Find DEMO-Okafor-2026-03 in my Drive and summarize the medications into a SOAP-style note." Claude searches your Drive (only what your account can see), pulls the file, and drafts the note, with no download or copy-paste. In one connector you just saw both directions: Claude wrote a file into your Drive, then searched and read it.

Two honest notes. The Drive connector reads your documents but cannot edit them in place, so the "write" step here means saving a new file, which needs Code execution and file creation switched on (from section 6) plus Drive's write permission. And because you invented every detail, you ran the full read-and-write loop without touching one real record. Keep that habit for any regulated data (healthcare, legal, finance, student records): practice on made-up examples, and when the data is real, use only the accounts and connectors your organization has approved.

8. The real magic: Skills + Connectors together

Each is useful alone. Together they're the kitchen-with-recipes, and this is where work actually gets delegated rather than assisted.

The pattern: the Connector fetches the real data; the Skill shapes the output your way. Two worked examples.

The accountant's monthly close. With a "client-summary" skill built (Part 3 shows how) and Google Drive connected, the monthly ritual collapses to two short messages, both runnable on invented data. First, make a ledger to work against:

Create a sample ledger spreadsheet for a made-up client called DEMO Trading:

a dozen March transactions across a few expense heads, two or three of them

deliberately above a typical withholding threshold. Save it to my Google

Drive as DEMO-ledger-March.

Then the monthly request is one sentence:

Prepare the March client summary for DEMO Trading from DEMO-ledger-March

in my Drive.

The Drive connector fetches the ledger; the client-summary skill formats every amount in the reporting currency, groups by expense head, flags the payments above the withholding line, and lays it out in the firm's four-section template. A two-hour paste-and-format ritual becomes a two-minute review, on data you can re-run any time.

The marketer's weekly content batch. A "brand-voice" skill encodes the rules (no exclamation marks, question-hook openings, banned buzzwords, the call-to-action format). A connector reaches the content calendar in Notion. Request: "Draft captions for this week's three scheduled posts in Notion, in our voice." Connector reads the calendar; skill writes the captions on-brand. They edit instead of compose.

The same template fits the engineer (a "design-review" skill + a Linear connector → "review the three open issues tagged arch and write findings by severity") and the teacher (a "lesson-plan" skill + a Drive connector → "build next week's plan from the syllabus and last week's graded worksheets in my Drive").

9. Which problems need a Skill, which need a Connector, which need both?

This is the simple test to keep handy. When a task feels repetitive or tedious, ask yourself, in order:

Is the friction that I keep re-explaining how to do it? → You need a Skill .

Is the friction that I keep fetching data from another app ? → You need a Connector .

Both? → You need

A decision diagram titled 'Which do I need? Diagnose by the friction you feel.' It starts from a repetitive, tedious task and asks two questions in turn: do I keep re-expla

both. (This is more common than you'd think.)

The friction you feel What it needs Example "I paste the same formatting/voice/method rules every time." Skill Brand voice; report template; SOAP notes; review checklist "The output should always look a certain way." Skill Board-paper structure; invoice layout "I keep copying data out of Drive / Gmail / Slack / a tracker." Connector Pulling a ledger, an email thread, last week's tickets "I want AI to do something in another app." Connector (write access) Create a Linear issue; draft an email reply; update a Notion page "I fetch real data and it must come out my specific way." Both Monthly client close; weekly content batch; design review "I just want a one-off answer right now." Neither A single question; a quick draft you'll never repeat

Two honest cautions. First, not everything deserves a skill. A task you do once is just a good prompt; a skill is only worth making when the task repeats. Second, a connector you don't need is a door you've left open. Connect the apps a workflow actually requires, not every app you own. Scope is safety.

Part 3: Building your own Skill (the AI builds it for you)

Here is the part that sounds like it needs programming and doesn't. You will describe what you want in plain English, and AI will write the SKILL.md for you. Then you test it, fix it, and you're done. No code. Let's build the accountant's client-summary skill as the running example.

10. The fastest path: let AI write it

Anthropic provides a skill for making skills , called skill-creator , and there's a community of similar helpers. You simply ask. In Claude.ai:

Use the skill-creator skill to help me build a skill.

The skill prepares a monthly client financial summary for my

accounting firm. Whenever I ask for a "client summary"

or "monthly close," it should:

Format all amounts in our reporting currency with thousands separators.
Group line items by expense head.
Flag any payment above the tax-withholding reporting threshold.
Output using my standard four-section report layout

(Overview, Income, Expenses by Head, Flags & Notes).

Ask me anything you need, then build it.

AI will ask a few clarifying questions (what's the threshold figure? what does the template look like?), then generate a complete, correctly formatted skill. This is the brainstorm-iterate loop from the prompting primer, pointed at building a tool instead of writing a draft: give context, let it draft, read it, give feedback, repeat.

This is your first "code you never write"

Notice what just happened: you described an outcome, and AI produced the artifact, the SKILL.md and any code the skill needs, without you writing or reading a line of it. That is the exact move the previous Foundations crash course, Code You Never Write , turned into a full discipline: you are the client, not the contractor. A good client doesn't lay bricks; they write a clear brief, check the result against things they can measure, and keep what they paid for. A skill is simply that idea made permanent: commissioned once, reused forever. You already practiced commissioning in that course; here you make it durable by saving the commission as a skill.

You can do the same thing on the other surfaces (describe the skill, let the agent write the file), and the shape of what it produces is identical everywhere, because skills are an open standard. (Part 4 lays out where each surface saves it, and how the ChatGPT and Gemini equivalents differ.) So it's worth understanding that shape.

11. Anatomy of a SKILL.md

Every skill is the same simple structure. Here's a minimal version of our accountant skill; read it once and the mystery is gone:

name : client - monthly - summary

description : Prepares a monthly client financial summary for an

accounting firm. Use when the user asks for a "client summary" ,

"monthly close" , or "month - end report". Formats amounts in the

firm's reporting currency , groups by expense head , and flags

tax - withholding items.

Client Monthly Summary

Settings (edit these to make it yours)

Reporting currency: your currency (e.g., USD, EUR, NGN)
Withholding threshold: the amount above which to flag a payment (e.g., 50,000)

Instructions

When asked to prepare a client summary or monthly close:

Format every amount in the reporting currency above, with thousands

separators (e.g., "1,250,000").

Group all line items by expense head. Sort heads by total,

largest first.

Flag any single payment above the withholding threshold above

with a "⚑ WITHHOLDING" note.

Produce the report in exactly four sections, in this order:

Overview, Income, Expenses by Head, Flags & Notes.

Example

User: "Prepare the March summary for DEMO Trading."

Result: A four-section report, currency-formatted, withholding lines flagged.

Two parts, that's

A diagram titled 'What is inside a SKILL.md — and when AI loads each part,' illustrating progressive disclosure. On the left, the skill folder shows a SKILL.md file split i

all:

The frontmatter (between the --- lines): the name and the description . This is the only thing AI keeps loaded at all times. It's how AI decides whether this skill is relevant: progressive disclosure, level one.

The body (everything after): the actual instructions, loaded only when the description matches your request: level two.

For more complex skills you can add a references/ folder (detailed docs AI reads when needed, level three), an assets/ folder (a template file to fill in), and scripts/ (small programs for steps that must be exact). You won't need those to start. A few rules that prevent the common upload errors:

The file must be named exactly SKILL.md .

The folder name uses kebab-case : client-monthly-summary ✅, not Client Monthly Summary ❌ or client_monthly_summary ❌.

The name and the description must contain no XML-style tags (anything inside angle brackets, like <note> ), and the description should stay short and specific, comfortably within the platform's length limit (a sentence or two is ideal).

Don't name a skill with "claude" or "anthropic" in it; those are reserved.

12. The description field is the whole game

If you remember one thing about building skills, remember this: the description decides whether your skill ever fires. AI doesn't read your instructions to decide relevance; it reads only the description. A vague description means a skill that never triggers; a sharp one means it activates exactly when it should.

The formula: what it does + when to use it + the exact phrases you'd actually say.

Bad description Why it fails Better description "Helps with reports." Too vague — fires for everything or nothing. "Prepares a monthly client financial summary. Use when the user asks for a 'client summary', 'monthly close', or 'month-end report'." "Handles patient documentation." No trigger words a user would say. "Converts consultation notes into SOAP-format clinical notes. Use when the user asks for a 'SOAP note', 'clinical note', or to 'write up' a consultation." "Brand stuff for marketing." No idea what or when. "Writes social captions in our brand voice (no exclamation marks, question-hook openings). Use when drafting Instagram, LinkedIn, or X captions."

A handy debugging trick once a skill is installed: ask AI, "When would you use my client-summary skill?" It will paraphrase the description back to you. If its answer is narrower or wider than you intended, you've found exactly what to fix in the description.

You can also add negative triggers when a skill fires too eagerly: "Do NOT use for one-off calculations or quick questions — only for full month-end reports."

13. Test, then iterate

A skill is never "done" on the first draft. The reliable build loop, adapted from how experienced skill-builders actually work:

Describe the skill and let AI generate the first version.

Read it and fix anything obviously wrong before testing.

Test triggering. Try the phrases that should activate it ("prepare the client summary," "do the monthly close," "write up the month-end report") and confirm it loads. Try unrelated requests and confirm it does not take over ones it shouldn't.

Test the output. Run the skill on a real (or realistic) input. Does it format in the right currency? Group by head? Flag withholding? Hit all four sections?

Test it with hard cases. A client with no income that month. A payment exactly on the threshold. A messy ledger. Where it fails, make the instructions more precise, and consider whether a tricky calculation should be a small script instead of a prose instruction, because code is exact and prose is interpreted.

Bring failures back to skill-creator: "This skill double-counted reversed entries. Update it to net out reversals before grouping."

Two failure patterns and their fixes:

It never triggers → the description is too vague or missing the words you actually use. Add them.

It triggers on the wrong things → the description is too broad. Narrow it, or add a negative trigger.

A modest amount of testing is very effective. You don't need fifty test runs for a personal formatting skill; you do want a few, including one deliberately awkward case, before you trust it with real client work.

Once the skill is ready, saving it takes one click. When skill-creator finishes, it shows

Claude after skill-creator finishes building a skill. On the right, a panel titled "monthly-client-summary / SKILL.md" shows the skill's files (SKILL.md, a references

your skill in a panel beside the chat with a Save skill button. Click it, and the skill drops straight into your Personal skills (Customize → Skills), toggled on, ready, and private to your account. No zip, no upload.

When the build is done, one Save skill click puts it on your shelf. Have a skill folder from somewhere else? You can still add it by hand: Customize → Skills → "+" → Create skill → upload the folder.

The same shelf that held only skill-creator back in section 6 now holds your own skill, "Added by You", ready to fire whenever you say "client summary" or "monthly close."

On Team or Enterprise plans, you can go further: share a skill with specific colleagues or publish it to your organization's directory so everyone can install it. Shared skills are view-only and auto-update when you change the original, handy for standardizing how a whole accounting firm or clinic produces its documents. (Sharing is off by default; an owner enables it first.)

Part 4: The same skill, five places

You'll hear about five tools for this work, and the good news is real: a skill you write once is portable . In December 2025 Anthropic published the Agent Skills open standard (at agentskills.io), and adoption was fast. Within months, tools from other vendors, including OpenAI's Codex CLI and Google's Gemini CLI, agreed to read the same SKILL.md files. The honest caveat: a basic SKILL.md skill travels across skills-compatible tools, but each product adds its own install path, invocation syntax, permissions, and extra features on top, so the core is portable while the edges differ. The recipe you wrote hangs in many kitchens, even if each kitchen arranges its shelves a little differently.

For the curious: who keeps the standard honest

The same month, the Linux Foundation formed the Agentic AI Foundation to give this kind of infrastructure neutral, cross-vendor governance. One of its founding projects is MCP , the standard your connectors run on, so the plumbing under both Skills and Connectors is now steered in the open rather than by any single company. You don't need any of this to use a skill; it's just why "portable" is a safe bet and not one vendor's promise.

Here is each surface, who it's for, and how the three core moves (installing a skill, connecting an app, and building your own) actually happen there:

Surface Who it's for Install a skill Connect an app Build your own Claude.ai (web/mobile) Everyone — your main tool Click Install in the directory, or upload a zip "+" → Connectors → pick → sign in skill-creator writes it; click Save skill Cowork / OpenWork (desktop) Knowledge workers, non-coders Same directory; enabled skills appear automatically Same flow, plus reaches files already on your computer Describe it; the agent can save it straight to a folder Claude Code / OpenCode (terminal) People who work with code Drop the skill folder into the skills directory Set up once in a config file, then ask in plain language Ask the agent to "create a skill for…"; it writes the files

Within each

A diagram titled 'Five tools, one skill — start in Claude.ai, graduate when you need to,' noting the same SKILL.md travels across skills-compatible tools, each of which add

pair, the first tool is the commercial one and the second is the open-source alternative; both read the same SKILL.md .

For non-programmers, the honest guidance is: start and stay in Claude.ai. Everything in Parts 1–3 happens there with buttons and toggles, no files to manage. Cowork (and its open cousin OpenWork ) is the natural next step when you want AI working directly on the files and folders on your computer rather than things you upload one at a time: same skills, applied to your real desktop. Claude Code and OpenCode live in a terminal and are aimed at people who write or work with code; the open standard means a skill you built in Claude.ai carries over too, with that tool's own setup.

What about ChatGPT and Gemini?

Two things are true at once, and it's worth being precise because the marketing blurs them.

On Skills, the picture is genuinely cross-vendor. Because Agent Skills is an open standard, the command-line tools from OpenAI (Codex CLI) and Google (Gemini CLI), along with VS Code, Cursor, and others, read the same SKILL.md files. A skill is the one piece of this course that is not locked to Claude. Write it once; run it across tools.

On "teach it once" inside the consumer chat apps, each vendor has its own, non-portable version:

ChatGPT has Custom GPTs : a saved version of ChatGPT with your instructions and optional knowledge files, distributed through the GPT Store. Powerful, but it lives only inside ChatGPT.

Gemini has Gems : a saved Gemini persona with instructions and knowledge files, living only inside Google's apps.

The difference that matters: a Skill is portable (open standard, many tools); a GPT or Gem is a vendor-specific custom assistant you can't take elsewhere. If you only ever use one tool, a GPT or a Gem is perfectly fine. If your strategy spans more than one model, which this book argues it should, Skills are the future-proof choice.

On Connectors, all three have an equivalent: ChatGPT and Gemini both connect to apps and data (ChatGPT through its connectors/apps; Gemini through its Workspace integration and extensions). The underlying MCP technology is increasingly shared. The principle is identical everywhere: you grant access, AI inherits your permissions, you start read-only.

For this course

Learn it in Claude.ai. The concepts (teach-once, connect-your-apps, automatic invocation, scope-your-access) transfer to every tool. Where a feature is Claude-specific, we've said so.

Part 5: Use this safely (the part most tutorials rush)

Same principle as What AI Actually Is (Idea 3): nothing inside the model checks whether an action is safe or correct; you are that check. Read a skill before enabling it; scope a connector before trusting it.

Skills and connectors are powerful, which means they are worth a moment of care. The single most important sentence in this section:

A skill is a set of instructions you are letting AI follow, and a connector is a door into your real data. Treat a skill from a stranger like a contract you're about to sign, and a connector like a key you're about to hand over.

The two real risks

Malicious skills. Because a skill is just a text file (and possibly scripts), a malicious person can write one whose hidden instructions tell AI to do something you didn't intend: leak data, contact a suspicious server, or quietly misbehave. The two named dangers are prompt injection (the skill manipulates AI into unintended actions) and data exfiltration (the skill's code or instructions secretly send your information out). This is not hypothetical; it's the reason "I downloaded a free skill from social media" is a sentence that should make you pause and think.

Over-broad connector access. A connector can only reach what you can reach, but if you grant write access carelessly, AI can change things on your behalf. The risk is usually not dramatic; it's a wrong edit, a record created in the wrong place, or a deleted file with no easy way to undo it.

The safe-use checklist

Install skills from trusted sources. The built-in Anthropic skills and the official directory are the safe default. A random zip from a forum is not.

Read a skill before enabling it. Open the SKILL.md and any bundled files. You can even ask AI to do it for you: "Read this skill and tell me exactly what it instructs you to do. Flag anything that contacts external servers, handles credentials, or could leak my data." Pay special attention to scripts and to any instruction that reaches out to the internet.

Start connectors read-only. Grant "search and summarize" before "send" or "create" or "delete." Move up to write access only after you have watched the tool behave well.

Scope to the smallest folder or app the task needs. Don't connect everything; don't grant whole-drive access for a one-folder job.

Before allowing AI to edit, move, or delete files, confirm how that specific connector handles recovery, version history, and undo. Some write actions may overwrite or bypass the recovery path you expect, so keep your own backups of anything you can't afford to lose.

On a team, route shared skills through your organization's directory , where an owner has reviewed them, rather than passing zips around.

None of this should scare you off; the built-in tools are safe and the everyday workflow is low-risk. The point is simply that as you move from "use what comes built in" to "install community skills and grant write access," your caution should rise to match. Capability and care go up together.

Recap

The whole page in a handful of lines:

A chat tells AI what to do once; a Skill teaches it how every time; a Connector gives it hands to reach your apps. (The kitchen: connectors are the kitchen, skills are the recipes.)

A Skill is a folder with a SKILL.md text file : a name, a description, and plain-English instructions. No code required to start.

A Connector is safe, permission-scoped access to an app (Drive, Gmail, Slack, a tracker), running on the MCP standard. AI inherits your permissions.

In Claude.ai, skills fire automatically when your prompt matches their description. Slash commands and naming the skill are override tools, used more in Cowork and the developer apps. So the description is the most important thing you write.

Diagnose by friction: re-explaining how → Skill; copy-pasting from an app → Connector; both → both.

You build skills by describing them to AI (skill-creator does the writing); then you test triggering and output and iterate.

A skill written once runs across many tools thanks to the Agent Skills open standard, unlike ChatGPT's GPTs or Gemini's Gems, which are vendor-locked. Learn it in Claude.ai; the concepts carry to Claude Code, OpenCode, Cowork, OpenWork, and beyond.

Care scales with capability: read skills before enabling, install from trusted sources, start connectors read-only, scope access tightly.

Underneath all of it is the shift this book keeps returning to: AI stops being a box you type into and becomes a layer that knows your standards and reaches your tools. Skills and Connectors are how an ordinary professional, with no programming and no setup beyond a few toggles, makes that shift this week.

Try this now

Reading is no substitute for doing. Open Claude.ai (the free tier is enough) and run these in order. Budget about thirty minutes.

Trigger a built-in skill. Confirm file-creation is on (Settings → Capabilities), then:

Turn this into a one-slide PowerPoint with a title and three

bullet points: [paste any three facts about your work].

You didn't name a skill; watch the PowerPoint skill fire on its own.

Connect one app, read-only. Connect Google Drive (or Gmail), enable it for the chat, then:

Find [a specific document] in my Drive and give me a three-sentence

summary plus the three numbers that matter most.

Notice you never downloaded or pasted anything.

Build your first skill, by talking. Pick the most repetitive "I keep re-explaining how" task in your week. Then:

Use the skill-creator skill to help me build a skill for [your task].

Here's exactly how I want it done every time: [list your rules,

your format, your must-dos and must-nots]. Ask me anything you

need, then build it.

Pressure-test the description. After it's built and installed:

When would you use the skill we just made? And when would you

NOT use it?

If the answer is too wide or too narrow, tell it the fix and have it update the description.

Audit a skill for safety. Take any skill you didn't write yourself and:

Read this skill and tell me, in plain language, exactly what it

instructs you to do. Flag anything that contacts an external

server, handles credentials, or could send my data anywhere.

Diagnose three of your own tasks. Write down three recurring annoyances from your work. For each, answer: is the friction re-explaining how (a Skill), fetching from an app (a Connector), or both ? You now have your first three projects.

🚀 Projects

The exercises above each isolated one idea. These projects chain the whole chapter into something you keep: a real asset you own and can hand to someone else, plus the habit of vetting a skill before you trust it. Not a screen to show off, not a link to publish. What you walk away with is a private skill (a SKILL.md plus the connected workflow around it) and a sentence you can say to a real person about what it now does for you.

One filter decides whether a task is worth a skill at all: the market-of-one test. A skill earns its place when it encodes your specific repeated way, the thing no app does for you. Nobody sells an app that writes your class notes in your format, or your firm's report in your firm's four sections; that gap is exactly where a skill beats every tool in the store. A task an app already does for everybody is just a good prompt, not a skill.

They're sequenced. Do Project 1 this week, on a task you actually repeat, and each one fits a free account.

🛠️ Project 1 30-45 min Build your first real skill Turn your most re-explained task into a skill that just knows your way.

The whole build loop from Part 3 is just three messages. Open Claude.ai and paste this one, word for word , to build a real skill by talking:

Use the skill-creator skill to build me a weekly study-notes skill.

Whenever I ask for "study notes" or "weekly notes", take my raw class

notes and format them as a heading per topic, a short bold key-terms

list, and exactly three review questions at the end. Ask me anything

you need, then build it.

skill-creator asks you a couple of quick questions, writes the SKILL.md , and test-runs it on a sample so you see the output. Click Save skill and it lands on your shelf (Customize → Skills), private to you. (That builds the study-notes skill. To make it about YOUR task instead, keep the same shape and swap in the thing you keep re-typing, your report format, your brand voice, your review checklist, and your exact rules.)

Next, check the description, the part that decides whether it fires on its own. Paste:

When would you use the weekly-study-notes skill, and when would you NOT use it?

If the answer is too wide or too narrow, tell it the fix. Then prove it works: open a brand-new chat and, without naming the skill, paste a real week of your notes right after this line:

Make study notes from this:

You will watch it reach for your skill on its own and hand back your exact format, every time: a heading per topic, your key terms in bold, three review questions. No app writes notes your way, which is the whole reason it is worth a skill.

The win you can say out loud: 'I taught AI how I do my weekly notes once, and now it does it in one sentence, every time.'

Done when: the skill fires on its own from a natural request (no slash command, no naming it), produces your format without reminders, and doesn't hijack an unrelated request.

🔗 Project 2 20-30 min Connect one app, read-only, and use it Get a real answer straight from your own data, with zero copy-paste.

Connect one app you actually use, Google Drive or Gmail is the easiest, and keep it read-only . Then ask a real question that needs something inside it. For Drive, paste:

Find my most recent document in my Drive, pull the three facts or

numbers that matter most, and give me a one-line summary of what it is.

Or for Gmail:

Summarize my most recent email thread, and list anything it is waiting

on me to do.

AI reaches into the app and answers, with nothing uploaded and nothing pasted. Then do the reflective half: say out loud exactly what access you granted, and decide whether this task will ever need write access, and if so, what you'd want to see before allowing it.

The win you can say out loud: 'I asked one question and AI pulled the answer out of my own files; I never copied or pasted a thing.'

Done when: you've pulled real data through a connector, and you can state in one sentence what the connector can and cannot do with your account.

⚙️ Project 3 45-60 min Wire a skill and a connector together The monthly-close / weekly-batch machine, running on your own data.

Combine Projects 1 and 2: the connector fetches your real data, your skill shapes it your way. With the study-notes skill on your shelf and Drive connected, the whole weekly ritual becomes one sentence. Paste:

Find this week's class notes in my Drive and make study notes from them.

The connector reads the file, the skill formats it, you just review, no pasting and no re-explaining the format. The accountant's version is the exact same shape:

Prepare this month's summary for DEMO Trading; the ledger is the file

called DEMO-ledger-March in my Drive.

Verify the result against one slice you can check by hand before you trust the whole thing. The connector brings the live data, the skill brings your format, and the two together are a thing no single app sells you.

The win you can say out loud: 'I taught AI my monthly report once and pointed it at my files; now the whole thing runs from one sentence and I just review it.'

Done when: one plain-English sentence produces a finished, correctly-formatted result built from live data you never copied or pasted.

🤝 Project 4 30 min Make it portable, or hand it off Capstone: prove the asset outlives the chat AND the tool.

Take Project 1's skill and do one of two things.

Hand it off. Share it with a friend or colleague (or publish it to your organization's directory if you're on a Team or Enterprise plan), then have them run it cold, from nothing but the skill itself, no explanation from you.

Or travel it. Open a second surface, Cowork or Claude Code, load the same SKILL.md , and run it there. Paste a real week of notes right after this line:

Use this skill to make study notes from:

Feel the open standard in action: the recipe you wrote in one kitchen, cooking in another. Either path teaches the same lesson, that a skill is an asset that survives past one conversation and one product.

The win you can say out loud: 'I handed my skill to a friend and it just worked, without me in the room.'

Done when: someone who wasn't in the original conversation, or a second tool, produces a correct result from your skill, with no help from you.

🕵️ Project 5 15-20 min Audit a skill before you trust it Install one skill from a stranger, then prove to yourself it's safe before you let it run.

Part 5 said it plainly: a skill is a set of instructions you are about to let AI follow, so one from the internet is a contract you should read before you sign. This is the habit that keeps you safe the moment you start installing community skills. Install one skill you did not write (start from the official directory, "+" → Browse skills ), then, before you rely on it, make AI read it back to you:

Read the skill I just installed and tell me, in plain language, exactly

what it instructs you to do. Then flag anything in it that contacts an

external server, handles passwords or credentials, or could send my data

somewhere I didn't intend. If it's clean, say so plainly.

AI opens the skill, explains in one paragraph what it actually does, and gives you a straight verdict: clean, or "here is the line that reaches the internet." Most of the time it comes back clean, and that is exactly the point: you spent twenty seconds and now you know , instead of hoping. The one time it doesn't, you just caught something before it ever touched your data.

The win you can say out loud: 'I read a skill before trusting it, in plain English, without understanding a single line of code.'

Done when: you can say in one sentence what a skill you didn't write actually does, and whether it reaches anything outside your own account.

🛟 If you get stuck mid-project

Every stall we've seen lands in one of these. None requires understanding why it broke; describing the stuckness to AI is itself the fix.

The skill never triggers. The description is too vague or missing the words you'd actually say. Ask AI: 'When would you use my [name] skill, and when would you not?' , then tighten the description to match what you meant.

The skill triggers on the wrong things. The description is too broad. Narrow it, or add a negative trigger: 'Do NOT use for quick one-off questions.'

The connector "can't find" a file. Usually permissions or scope: confirm the connector is enabled for this chat, and that your own account can open the file (AI inherits your access, so it can't reach what you can't).

AI answered from a glance instead of using the connected data. Name it explicitly: 'Use my [app] connector to fetch the actual file before answering, and tell me which file you used.'

You're nervous about write access or sensitive data. Stay read-only and strip what isn't needed first; grant write access only to a tool that has behaved well, scoped to the smallest folder the task needs.

The chat has gotten long and confused. Start a fresh one, restate the task in two lines, and continue. A tangled chat is cheaper to abandon than to rescue.

Where to next

How to Think in the AI Era : your next Foundations course, and the deeper discipline underneath everything here: asking the right questions in the first place, which is what separates a useful skill from a transformative one.

Code You Never Write : the previous course, worth a second look now: skills can contain code, and connectors are code. It turns "commission code you never read, then verify it" into a discipline, and a skill is simply that discipline made permanent.

AI Prompting in 2026 : the prompting fundamentals that make every skill you build get great inputs; revisit it if any prompt here felt unfamiliar.

The rest of Agentic Engineer builds directly on this foundation. Once you're comfortable teaching AI a task and connecting it to your tools, you're ready to think about agents that do this work on their own, which is where the book goes next.

Flashcards Study Aid

Test Your Understanding

One sentence holds this whole course: a chat tells AI what to do once, a Skill teaches it how every time, a Connector gives it hands to reach your apps. These scenarios put that idea to work in other people's offices, clinics, and studios. Each rewards knowing what to actually do, not reciting a definition; answer from the reasoning, not the longest option.

Checking access...

Code You Never Write

How to Think in the AI Era