Thousands of ready-made add-ons now exist for AI assistants and agents: instruction packs that teach them specific jobs, connectors that plug them into your other tools, and bundles that install both in one click. Most are free, and every major AI platform now has its own ecosystem of them. Used well, they are the fastest way to turn a general AI tool into one that is genuinely good at your work. Used carelessly, they are instructions from a stranger that you chose to run.
This guide explains the three types of add-on, how MCP (the standard behind most connectors) actually works and how it compares to the alternatives, where to find vetted add-ons for each platform, how to install them safely, and when to build your own instead.
The three types of add-on
- Skills change what the AI knows how to do: a skill is a reusable instruction pack (usually a small folder with an instructions file plus reference files) that teaches the AI a specific job so it does it the same way every time.
- Connectors change what the AI can reach: your drive, calendar, CRM, a database, a website.
- Plugins are boxes containing both: a bundle of skills and connectors installed in one click, so you get a working setup for a role or workflow rather than assembling the pieces yourself.
The names vary a little by platform, but all the major ones now use some version of this skills-plus-connectors-plus-bundles model, and skills written for one agent often work in others, because the main platforms have converged on very similar formats.
Skills: teach the AI a repeatable job
A skill is worth creating or installing whenever you have pasted the same long instructions twice. What is actually inside one is unglamorous and that is the point: a plain-text instruction file (what the job is, when to use it, the steps, the output format) plus any reference files the job needs (a template, a checklist, an example of good output). When you give the agent a task, it checks whether an installed skill matches and follows it.
What skills look like in practice:
- Document skills: produce a real spreadsheet with working formulas, a formatted slide deck, or a house-style report, rather than a wall of text to copy by hand.
- Process skills: run your pre-publish review checklist, your grant-budget sanity check, or your data-cleaning routine, identically every time and for every colleague.
- Domain skills: encode how your organization does something (your donor-letter structure, your program-report format) so a new volunteer with an agent produces work like your best staff member’s.
To see real examples, skim Anthropic’s open example skills or browse any directory in the “Where to find them” section below: every good directory shows a skill’s full instructions before you install.
✅ Example
A small nonprofit’s operations lead installs a spreadsheet skill and a drive connector. Before: “make me a budget template” produced a text table to copy by hand. After: the same request produces a real spreadsheet file, with working formulas, saved in the right folder, formatted the way the skill specifies, every time and for every colleague who uses the same setup.
Connectors and MCP: give the AI safe access to your tools
A connector is what lets an agent read your drive, check your calendar, query your CRM, or post to your project board. Most new connectors are built on MCP (the Model Context Protocol), an open standard that most major AI platforms now support.
How it works, in plain terms:
- Each tool you connect runs a small piece of software called an MCP server, which exposes that tool’s actions (“search my files”, “create an event”, “look up a contact”) in a standard format.
- Your AI assistant or agent is the client: it discovers what actions each connected server offers and uses them when a task needs to.
- Because the format is standard, one connector can work across many AI tools: the same CRM connector can serve Claude, ChatGPT, and other MCP-compatible agents, instead of each vendor building its own version.
Two variants matter when you install one:
- Remote MCP servers run in the cloud, usually hosted by the tool’s own vendor. You connect with a normal account login. Easiest and usually safest for non-technical teams: prefer these.
- Local MCP servers run on your own computer. More flexible and private, but they are software you are installing and running, so they need the same caution as any downloaded program, and usually some technical comfort.
MCP is not the only way to connect an AI to your tools. The realistic options, with trade-offs:
- Native connectors (the integrations a vendor builds into its own product): the easiest and best-supported option when one exists for your tool. Limitation: you are restricted to the vendor’s catalog, and the same connection may need redoing on each AI platform you use.
- MCP connectors: the widest and fastest-growing catalog, portable across AI platforms, one-click for many popular tools. Limitation: quality varies (anyone can publish a server), so stick to official or well-reviewed ones for anything touching real data.
- CLIs (command-line tools): many services offer one, and coding agents use them fluently, often more reliably than a young MCP server. Limitation: this path assumes a coding agent and some technical comfort.
- Custom API integrations: maximum control, and the right answer for something truly bespoke. Limitation: needs a developer to build and maintain; rarely a first choice for a small team.
The practical rule: use the native connector if your platform has one for that tool, use a reputable MCP connector when it does not or when you work across several AI platforms, and leave CLIs and custom APIs for technical teams and coding-agent workflows.
Where to browse MCP connectors:
- MCP.Directory: thousands of servers with one-click installs for many AI clients, an “Official” badge for vendor-published servers, and category browsing.
- mcp.so: a large community-driven directory, useful for breadth and comparing alternatives.
- The official MCP Registry: the standard’s own metadata registry (what it is), backed by major contributors to the ecosystem. More technical, but the closest thing to a source of truth.
⚠️ Warning
A connector sees whatever you give it access to. Before connecting anything to real organizational data, check who publishes the server (prefer the tool vendor’s own official one), what permissions it asks for, and whether your data rule allows that tool to hold the data in question. When in doubt, connect a test account first.
Plugins: one-click bundles, one directory per platform
A plugin bundles skills and connectors (and sometimes scheduled-task templates and other extras) into a single install, so a working setup for a role or workflow arrives in one click. Each major platform runs its own plugin system and directory:
- Claude: the official Plugins for Claude directory, with an “Anthropic verified” badge on entries that received extra review. Plugins install across Claude’s products, including Claude Cowork and Claude Code.
- ChatGPT and Codex: OpenAI’s plugin system works in ChatGPT Work and Codex, with a built-in directory of OpenAI-built, workspace, and personal plugins, including role-specific plugins for non-developers (sales, data, research, and more). Third-party indexes such as the Codex plugin marketplace (not affiliated with OpenAI) catalog community plugins and skills beyond the official directory.
- Other platforms: Google Antigravity supports skills and MCP servers with curated Google bundles, and more platforms are adding equivalents. If you use a different AI platform or agent, check whether it offers plugins, skills, or MCP support before assuming it does not: this has become a standard feature, and the vendor’s own directory is usually the safest source.
Official, first-party directories are the best starting point on every platform: they are reviewed (to varying degrees), they install cleanly, and they are the most likely to keep working after updates.
Where to find skills across platforms
Beyond each platform’s own directory, cross-platform directories index skills that work in several agents at once:
- findskills.co: a hand-picked directory (hundreds of skills, not thousands) organized by profession, with plain-English descriptions and the full instructions visible before you install. The friendliest browse for a non-technical reader; covers several agent platforms.
- Skills Directory: a much larger index (tens of thousands of skills) that runs security scans on what it lists, including a content and marketing category.
- claude-plugins.dev: a community-maintained index that auto-catalogs public skills for several coding agents; useful for breadth once you know what you are looking for.
These directories are examples of a fast-moving category, not endorsements: new ones appear and existing ones change focus, so judge each by the same safety test below. Most skills are still written by and for technical users, but the share aimed at writing, research, data, and administrative work is growing quickly, and those are the ones most nonprofit teams want.
How to choose and install an add-on safely
⚠️ Warning
A skill is instructions someone else wrote, and your AI will follow them. A malicious or sloppy skill can quietly tell the agent to do things you did not intend, and hidden instructions are not hypothetical: Skills Directory reports from its own scanning that roughly a third of skills in the wild contain security flaws. That is their figure, not an independent audit, but the direction is clear: treat installing a skill or plugin like installing software, not like bookmarking a page.
- Prefer official or verified sources. A verified plugin from a platform’s own directory, or a connector published by the tool’s vendor, beats an anonymous upload of the same name.
- Read what it does before installing. Good directories show a skill’s full instructions up front. If you cannot see the instructions, or they are too technical to follow, do not install; or ask your AI assistant to review the skill and explain in plain terms what it does and what could go wrong.
- Check what access it asks for. A formatting skill needs no access to anything. An add-on that wants your drive, email, or a website login needs a reason, and your data rule applies to it in full.
- Match the caution to the type. A pure skill (instructions only) is lower-risk than a connector (real data access) or a plugin containing local software; give connectors and bundled software the most scrutiny.
- Test on non-sensitive work first. Run it on public or dummy content, check the result and the agent’s activity log, and only then let it near real work.
- Keep a short list of what is installed, and prune it. Add each installed skill, plugin, or connector to wherever you track your AI tools, with an owner. Uninstall what you stopped using: every add-on is standing instructions in your setup.
Build your own (often easier and safer than installing)
For anything specific to your organization (your voice, your review checklist, your report format), building a skill usually beats installing a stranger’s version, and it is easier than it sounds:
- Describe the job in plain language. A skill is mostly a clear written procedure: when to use it, the steps, the output format, what never to do. If you can brief a volunteer, you can draft a skill.
- Let the AI write the skill file. Most agent platforms can now turn a plain description (or a recorded example: OpenAI’s plugin docs describe showing ChatGPT a workflow once to turn it into a reusable skill) into a properly formatted skill for you.
- Reuse the custom-assistant discipline. The structure from our custom GPTs guide (clear role, rules, examples, and a never-do list) transfers directly to skills.
- Share it with the team. A skill only pays off when everyone who does the job uses the same one; put it wherever you track approved tools, with an owner and a review date.
Keep sensitive and confidential data out of skill files. Use public or generic content only, and treat a skill you share externally as public.
Useful resources
- Plugins for Claude and OpenAI’s plugin docs: the two big official plugin ecosystems; start at your own platform’s directory.
- findskills.co: the most readable cross-platform skills directory, organized by profession, with instructions visible before install.
- Skills Directory: the widest skills index, with security scanning and a content and marketing category.
- MCP.Directory: the easiest place to browse MCP connectors, with one-click installs and official badges.
- Anthropic’s example skills: official, open examples worth skimming once, to understand what a skill actually is.
- AI agents for nonprofits: our companion guide to the agents these add-ons extend, including the five agent guardrails.
📋 Summary
- Skills teach an AI a repeatable job, connectors give it access to your other tools, and plugins bundle both into one-click installs; every major AI platform now has some version of all three.
- A skill is mostly a plain-language procedure file, which is why writing your own for organization-specific jobs is often easier and safer than installing a stranger’s.
- MCP is an open standard where each tool runs a small “server” exposing its actions, so one connector can work across many AI platforms instead of being rebuilt per vendor.
- Prefer remote, vendor-published MCP servers over local ones unless you have technical support; a local server is software you are choosing to run.
- Native connectors beat MCP when your platform has one for the tool; CLIs and custom APIs are the technical team’s options.
- Each platform’s own directory (with its verified or official badges) is the safest source of plugins; cross-platform directories add breadth.
- A skill is instructions someone else wrote and your AI will follow, so treat installing one like installing software.
- Give connectors and bundled software more scrutiny than pure instruction skills: data access is where the real risk sits.
- Test every add-on on non-sensitive work first, check the agent’s activity log afterward, and keep an owned, pruned list of what is installed.