Skills & Connectors: Teach AI Once, Connect It to Your Apps

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 — so 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 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.

---

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.

• 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 — they have no tools and nothing to cook with.
• The Skills are the recipe 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 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 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 and (if you allow) send mail; 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:

1. 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.
2. 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).
3. 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 — useful, but it's 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 fire at the right moment. (That is also why writing a sharp description is the most important part of building a skill — 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	Settings → 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

The quickest benefit: Anthropic maintains built-in skills that produce polished files. With Code execution and file creation switched on (Settings → Capabilities), these activate automatically:

• 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 PDFs

You don't invoke these. Ask the marketer's "turn this campaign plan into a slide deck" and the PowerPoint skill does the work. Ask the accountant's "build me an Excel model of this cash flow with monthly columns and a total row" and the Excel skill produces a genuine workbook you can download.

Beyond the built-ins, there's a directory (Settings → Customize → Skills → "+" → Browse skills) with skills you can install in one click — including partner skills from companies like Notion, Figma, and Atlassian, designed to work closely with their connectors. Installed skills are view-only: you can use them, and you can toggle them off, but to change one you download a copy, edit it, and re-upload it as your own.

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 — 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, and open the directory; or go to Settings → Customize → Connectors. 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.

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 (Auto vs On demand). Auto is fine for most people; switch to 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: connect Google Drive, enable it, then ask "Find the intake form for patient file 'Okafor-2026-03' in my Drive and summarize the medication history into a SOAP-style note." AI searches your Drive (only what your account can see), pulls the file, and drafts the note — no download, no copy-paste. Read-only access is enough for this; you'd only grant write access if you wanted it to save the note back. One caution for regulated data: for healthcare, legal, finance, or student records, use only accounts and connectors approved by your organization, follow your regulatory obligations, and never practice on real sensitive data — use made-up examples to learn.

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. They build a "client-summary" skill once (Part 3 shows how) that encodes: reporting-currency formatting, grouping by expense head, the tax-withholding flag, and their exact report template. They connect Google Drive and Gmail. Now their monthly request is one sentence:

Prepare the March summary for client Northwind Trading. The ledger is
the Excel file in my "Northwind/2026" Drive folder; last quarter's
figures are in the email from their accountant dated Feb 28.

The connectors pull the ledger and the email; the skill formats everything to the firm's standard and flags the withholding line. What was a two-hour paste-and-format ritual becomes a two-minute review.

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 two questions in order:

1. Is the friction that I keep re-explaining how to do it? → You need a Skill.
2. Is the friction that I keep fetching data from another app? → You need a Connector.
3. Both? → You need 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; send a drafted email; 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 produce the SKILL.md.

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:

1. Format every amount in the reporting currency above, with thousands
   separators (e.g., "1,250,000").
2. Group all line items by expense head. Sort heads by total,
   largest first.
3. Flag any single payment above the withholding threshold above
   with a "⚑ WITHHOLDING" note.
4. Produce the report in exactly four sections, in this order:
   Overview, Income, Expenses by Head, Flags & Notes.

## Example

User: "Prepare the March summary for Northwind Trading."
Result: A four-section report, currency-formatted, withholding lines flagged.

Two parts, that's 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 must stay under ~1024 characters.
• 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:

1. Describe the skill and let AI generate the first version.
2. Read it and fix anything obviously wrong before testing.
3. 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.
4. 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?
5. 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.
6. 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.

14. Installing and sharing your skill

Once your SKILL.md (and any folder of extras) is ready:

• In Claude.ai: zip the skill folder, then Settings → Customize → Skills → "+" → Create skill → Upload a skill → drop the zip. It appears in your list, toggled on, ready. Custom skills you upload are private to your account.
• On Team/Enterprise plans: you can 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. (Separately, also in December 2025, the Linux Foundation formed the Agentic AI Foundation to give neutral, cross-vendor governance to core agentic-AI infrastructure; its founding projects are MCP — the standard your connectors run on — along with Block's goose and OpenAI's AGENTS.md.) So the recipe you wrote hangs in many kitchens, even if each kitchen arranges its shelves a little differently.

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; saves to your account
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 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)

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

1. 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.

2. Over-broad connector access. A connector can only reach what you can reach — but if you grant write access carelessly, AI can change or send things on your behalf. The risk is usually not dramatic; it's a wrong edit, an email sent too early, or a deleted record with no 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 — no programming, 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.

1. 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.

2. 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.

3. 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 produce the SKILL.md.

4. 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.

5. 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.

6. 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 six prompts above each exercised one idea in isolation. The projects chain the whole chapter into something real: a working skill you own, a connected workflow you trust, or a teammate you've unblocked. Each fits a free account. They're sequenced — do Project 1 this week, on a task you actually repeat.

🛠️ Project 1 · 30–45 min · Build your first real skill

Turn your most-repeated "I keep re-explaining how" task into a skill.

Pick the task you re-type instructions for most often: a report format, a brand voice, a note structure, a review checklist. Then run the full build loop from Part 3: ask skill-creator to build it (give it your exact rules), read the draft, fix what's wrong, and add a "Settings (edit these to make it yours)" block for the values that change. Pressure-test the description both ways — try three natural phrasings that should trigger it, and one unrelated request that should not. Run it on one real input and check the output against what you'd have produced by hand.

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 from your own data with zero copy-paste.

Connect one app you actually use — Google Drive or Gmail is the easiest start — and keep it read-only. Ask a real question that needs something inside it: "Find [a specific document] in my Drive and pull the three numbers that matter most" or "Summarize the thread from [sender] about [topic]." Watch AI reach in and answer without you uploading anything. Then do the reflective half: name 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.

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 payoff: the monthly-close / weekly-batch pattern from §8, on your own data.

Combine Projects 1 and 2. Point your skill at data a connector fetches: the connector pulls the real input, the skill shapes the output your way. The accountant's version: "Prepare this month's summary for [client] — the ledger is the file in my [folder] in Drive." The marketer's: "Draft this week's captions from the calendar in Notion, in our voice." The connector reads; the skill formats; you review. Verify the result against one slice you can check by hand before trusting the whole thing.

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 skill outlives the chat — and the tool.

Take Project 1's skill and do one of two things. Hand it off: share it with a colleague (or publish it to your organization's directory if you're on a Team/Enterprise plan), then have them run it cold, from nothing but the skill itself. Or travel it: recreate or load the same SKILL.md on a second surface — Cowork, or Claude Code — and run it there, feeling the open standard in action. Either path teaches the same lesson: a skill is an asset that survives past one conversation and one product.

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.

🛟 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 — 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 The Agent Factory 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