AI Skills Plugin

A portable Agent Plugins 1.0.0 package containing reusable Agent Skills for AI-harness diagnosis, prompt design, IDE-native agent, hook, and slash-command creation, Skill authoring, and Agent Plugin creation.

Included Skills

Skill	Purpose
`agent-plugin-builder`	Create, migrate, validate, package, and release Agent Plugins 1.0.0.
`improve-my-ai-harness`	Diagnose an AI-IDE problem, select the smallest suitable harness mechanism or combination, and produce a builder-routed implementation prompt.
`new-agent`	Create least-privilege, IDE-native agents for Antigravity, Codex, ChatGPT, Zed, OpenCode, Qoder, or Orca.
`new-agents-md`	Create concise, target-aware `AGENTS.md` repository instructions for Antigravity, Codex, ChatGPT, Zed, OpenCode, Qoder, or Orca.
`new-hook`	Decide whether an event hook is appropriate and create a target-native hook or supported alternative.
`new-prompt`	Create and improve ready-to-use LLM prompts.
`new-skill`	Create, validate, evaluate, and package portable Agent Skills.
`new-slash-command`	Decide whether a reusable task should be a slash command and create the target-native command or supported alternative.
`new-workflow`	Decide whether a workflow is appropriate and create a target-native workflow or supported alternative.

Compatible clients discover each immediate child of skills/ that contains a valid SKILL.md. This package has no MCP servers, so it intentionally omits mcp.json.

Install in supported IDEs and agents

This repository is a portable Agent Plugins 1.0.0 package. Its portable payload is the root plugin.json plus the nine directories directly below skills/; each of those directories contains the required SKILL.md and any supporting files. Keep an entire skill directory together when installing it—do not copy only its SKILL.md, because some skills use scripts, templates, and references.

The clients below fall into two groups:

Bundle-aware clients can consume this repository as a plugin directory.
Skill-aware clients consume the directories in skills/ individually. A client-native extension named “plugin” may use a different manifest and is not interchangeable with this portable package.

Before installing, clone or download a trusted copy of this repository and set PLUGIN_DIR to its absolute path. The examples use POSIX shells; on Windows, copy the same directories using Explorer or PowerShell.

git clone <repository-url> ai-skills-plugin
cd ai-skills-plugin
export PLUGIN_DIR="$PWD"

The following command is the manual-install pattern used throughout this guide. It copies all nine skill directories and preserves their bundled resources:

mkdir -p <skills-root>
cp -R "$PLUGIN_DIR"/skills/* <skills-root>/

Antigravity

Antigravity IDE is bundle-aware. It requires a plugin.json at the plugin root and discovers skills/<skill-name>/SKILL.md; this repository already has that layout. See Antigravity’s plugin documentation.

Open the target workspace in Antigravity.

Copy or symlink the whole ai-skills-plugin directory to one of these locations (the directory name is the plugin name):

<workspace>/.agents/plugins/ai-skills-plugin/   # workspace-only
<workspace>/_agents/plugins/ai-skills-plugin/   # workspace-only alternative
~/.gemini/config/plugins/ai-skills-plugin/      # all workspaces

For example:

mkdir -p .agents/plugins
ln -s "$PLUGIN_DIR" .agents/plugins/ai-skills-plugin

Confirm that the installed directory contains plugin.json and skills/<skill-name>/SKILL.md. No Antigravity-specific configuration is needed because this package has no MCP servers, hooks, or rules.
Antigravity scans these locations automatically. Reopen the workspace or start a new agent conversation if the skills list was already open; a full IDE restart is not documented as required.
Describe a matching task, or ask the agent to use one of the installed skills to verify discovery.

Codex

Codex supports reusable plugins through the shared Plugin Directory, but the reliable local-development route is to install this package’s skills. The required file for each installed skill is SKILL.md with name and description; the optional agents/openai.yaml is not needed here. Official OpenAI documentation describes the supported local locations and invocation syntax in Build skills.

Copy or symlink each immediate child of skills/ to one of these skill roots:

<repository>/.agents/skills/<skill-name>/  # shared with this repository
~/.agents/skills/<skill-name>/             # personal, all repositories
/etc/codex/skills/<skill-name>/             # administrator-managed, all users

For a project-local install from this repository’s parent directory:

mkdir -p ../your-project/.agents/skills
cp -R "$PLUGIN_DIR"/skills/* ../your-project/.agents/skills/

Start Codex from that project (or reopen the project in the Codex IDE extension). Codex searches .agents/skills from the current directory up to the repository root.
Run /skills to confirm the nine skills are visible, then invoke one with $improve-my-ai-harness, $new-agent, $new-agents-md, $new-hook, $new-prompt, $new-skill, $new-slash-command, $new-workflow, or $agent-plugin-builder. Matching requests can also activate a skill automatically.
Codex normally detects skill changes automatically. Restart Codex only when a newly added skill fails to appear. If an administrator disables a local skill in ~/.codex/config.toml, re-enable it there and restart Codex.

ChatGPT Desktop App

The ChatGPT Desktop App (on macOS and Windows) installs standalone Agent Skills rather than loading local filesystem Agent Plugins 1.0.0 package directories directly. Because the desktop app does not support importing raw local plugin bundles containing plugin.json, install this package according to the individual Skill installation workflow: upload each of the nine skill directories separately. Each upload must include its required SKILL.md and all supporting files, references, templates, and scripts. The root plugin.json is for portable package distribution and is not a replacement for a skill upload. See Skills in ChatGPT.

Create one archive per skill directory (or select the directory and all its files in the upload picker):

(
  cd "$PLUGIN_DIR/skills"
  zip -r /tmp/agent-plugin-builder.zip agent-plugin-builder
  zip -r /tmp/improve-my-ai-harness.zip improve-my-ai-harness
  zip -r /tmp/new-agent.zip new-agent
  zip -r /tmp/new-agents-md.zip new-agents-md
  zip -r /tmp/new-hook.zip new-hook
  zip -r /tmp/new-prompt.zip new-prompt
  zip -r /tmp/new-skill.zip new-skill
  zip -r /tmp/new-slash-command.zip new-slash-command
  zip -r /tmp/new-workflow.zip new-workflow
)

In the ChatGPT Desktop App, select Plugins in the sidebar (or navigate via Settings → Plugins), open the Skills tab, then choose Create → Upload from your computer.
Upload each skill archive or directory and complete the safety review if the desktop app marks it Needs Review. A blocked upload cannot be used.
Use @ in a desktop chat session to select an installed skill, or send a request that matches its description. There is no client restart; the skill is available when the ChatGPT Desktop App finishes scanning it. Note that skills installed in the desktop app do not automatically sync across web or mobile surfaces and are managed locally within the desktop application.

Zed

Zed consumes Agent Skills rather than portable plugin bundles. The required unit is SKILL.md in one direct child directory of the skills root; copy all nine complete directories from this repository. Zed’s official Skills documentation covers the paths, Skills Manager, and trust model.

Install globally or for one project:

~/.agents/skills/<skill-name>/                 # global
<worktree>/.agents/skills/<skill-name>/        # project-local

mkdir -p .agents/skills
cp -R "$PLUGIN_DIR"/skills/* .agents/skills/

If this is a project-local install, open the worktree in Zed and grant workspace trust; Zed deliberately excludes skills in untrusted worktrees.
Open AI > Skills (or the Agent panel’s Skills Manager) to confirm the skills appear. Type / or @skill in an agent message to invoke one.
Zed live-reloads additions and edits to skills, so no restart is required.

OpenCode

OpenCode has two different extension systems. Its native in-process plugins are JavaScript/TypeScript modules with a default export containing id and setup; this repository is not that kind of plugin. Install its Agent Skills instead. The needed files are the complete <skill-name>/SKILL.md directories. See the OpenCode Agent Skills guide and, for the distinct native plugin format, OpenCode plugins.

Copy the skills to a native or compatible discovery location:

<project>/.opencode/skills/<skill-name>/        # OpenCode-native project scope
~/.config/opencode/skills/<skill-name>/         # OpenCode-native global scope
<project>/.agents/skills/<skill-name>/          # compatible project scope
~/.agents/skills/<skill-name>/                  # compatible global scope

mkdir -p .opencode/skills
cp -R "$PLUGIN_DIR"/skills/* .opencode/skills/

Alternatively, keep this checkout in place and add it as an explicit skills source in opencode.json or opencode.jsonc:
```
{
  "$schema": "https://opencode.ai/config.json",
  "skills": ["/absolute/path/to/ai-skills-plugin/skills"]
}
```
Ensure opencode.json does not deny the skill permission. A minimal configuration is:
```
{ "permission": { "skill": "allow" } }
```
Start a new OpenCode session and check its available skills or invoke the matching skill. Files in watched configuration directories reload when they change; restart OpenCode after changing the configuration or if discovery does not refresh.

Note: Do not place this package's root plugin.json in .opencode/plugins/ — that directory expects a JavaScript or TypeScript OpenCode plugin entrypoint, not an Agent Plugins 1.0.0 package.

Qoder

Qoder IDE supports both marketplace plugins and standalone skills. This repository’s portable plugin.json is not Qoder’s optional .qoder-plugin/plugin.json manifest, so the portable and lowest-risk route is to install its skills. Each complete skill directory, including SKILL.md, is required. Refer to Qoder Skills and Qoder Plugins.

Copy the nine skill directories to a user or project scope:

~/.qoder/skills/<skill-name>/                 # all Qoder projects for this user
<project>/.qoder/skills/<skill-name>/         # one project

mkdir -p .qoder/skills
cp -R "$PLUGIN_DIR"/skills/* .qoder/skills/

Restart Qoder IDE, then type / in Chat or Quest to verify the skills are loaded. A project-level skill with the same name takes precedence over a user-level skill.
Invoke a skill with /improve-my-ai-harness, /new-agent, /new-agents-md, /new-hook, /new-prompt, /new-skill, /new-slash-command, /new-workflow, or /agent-plugin-builder, or let Qoder match it automatically from its description.

Cursor

Cursor is bundle-aware and loads this repository as a complete Agent Plugins 1.0.0 package. It distinguishes between portable Agent Plugins (root plugin.json) and Cursor-native plugins (.cursor-plugin/plugin.json); this repository is a portable package. See Cursor Plugins documentation.

Copy or symlink the whole ai-skills-plugin directory to the local plugins folder:

~/.cursor/plugins/local/ai-skills-plugin/   # macOS / Linux
%USERPROFILE%\.cursor\plugins\local\ai-skills-plugin\   # Windows

mkdir -p ~/.cursor/plugins/local
ln -s "$PLUGIN_DIR" ~/.cursor/plugins/local/ai-skills-plugin

Reload the window to trigger discovery: open the Command Palette (Cmd+Shift+P / Ctrl+Shift+P) and run Developer: Reload Window, or restart Cursor. Hot-reload is not supported for local plugins.
Open Customize in the sidebar (or Settings → Plugins) and confirm that ai-skills-plugin appears under Installed.

GitHub Copilot and VS Code

GitHub Copilot and VS Code share the same plugin loading mechanism. The reliable local-development route registers the plugin directory in VS Code's settings.json. See GitHub Copilot Agent Plugins documentation and VS Code chat plugin settings.

Open VS Code's settings.json (Command Palette → Preferences: Open User Settings (JSON)) and add the plugin path:
```
"chat.plugins.enabled": true,
"chat.pluginLocations": {
  "/absolute/path/to/ai-skills-plugin": true
}
```
Replace /absolute/path/to/ai-skills-plugin with $PLUGIN_DIR's value.
Reload VS Code (Developer: Reload Window). Copilot reads chat.pluginLocations on startup; changes require a reload.
Verify in the Chat view: click the gear icon → Configure Skills and confirm the nine skills appear. Any mcp.json servers (this package has none) would appear in the MCP server list.

Enterprise note: Workspace and enterprise administrators can restrict available plugins with the chat.plugins.paths policy or via enabledPlugins / strictKnownMarketplaces managed settings. Confirm that local plugin paths are allowed in managed environments before using this route.

Windsurf

Windsurf's Cascade agent discovers skills from standard .agents/skills/ paths and from explicit entries in the project-level .windsurf/skills.json. MCP servers are managed separately via ~/.codeium/windsurf/mcp_config.json (this package has none). See Windsurf documentation.

Option A — Standard discovery path (recommended):

Copy the nine skill directories to the project or global discovery path:

<project>/.agents/skills/<skill-name>/          # project-local
~/.agents/skills/<skill-name>/                  # global

mkdir -p .agents/skills
cp -R "$PLUGIN_DIR"/skills/* .agents/skills/

Open or reopen the project in Windsurf. Cascade picks up new skills from watched directories without an IDE restart.

Option B — Explicit skills.json reference:

Add the plugin's skills directory to .windsurf/skills.json so the path travels with the repository:

{
  "skills": ["/absolute/path/to/ai-skills-plugin/skills"]
}

Windsurf reloads this file when it changes; a full restart is not required.

Kiro

Kiro calls Agent Plugins "Powers" and supports importing a local folder containing a plugin.json directly through its Powers panel. Manual skill directory placement also works. See Kiro Powers documentation.

GUI route (recommended):

Open the Powers panel in Kiro (click the ghost-with-lightning-bolt icon in the activity bar).
Select Add Custom Power → Import power from a folder.
Choose the ai-skills-plugin root directory (the folder that contains plugin.json).
Click Install. Kiro reads the plugin.json, discovers all skills under skills/, and activates them immediately.

Manual skill route:

<workspace>/.kiro/skills/<skill-name>/   # workspace-specific
~/.kiro/skills/<skill-name>/             # global

mkdir -p .kiro/skills
cp -R "$PLUGIN_DIR"/skills/* .kiro/skills/

Note: Kiro also supports a legacy POWER.md format; the plugin.json route is recommended for new installations.

Google Agents CLI

The Google Agents CLI (agents-cli) consumes Agent Plugins 1.0.0 packages as skill bundles that teach the CLI's built-in coding assistant how to perform ADK (Agent Development Kit) lifecycle tasks. This package's skills are independent of the ADK but load through the same mechanism.

Prerequisites: Python 3.11+, Node.js, and uv.

Install and set up the CLI (one-time):
```
uvx google-agents-cli setup
```
Register this package's skills globally via the npx skills add command:
```
npx skills add /absolute/path/to/ai-skills-plugin --global
```
Or, for a project-local install, run from the project directory without --global:
```
npx skills add /absolute/path/to/ai-skills-plugin
```
Confirm that the skills are visible inside the agents CLI's coding-assistant context. No CLI restart is required; skills are discovered at session start.

Note: The agents-cli does not provide a universal agents-cli install command for arbitrary Agent Plugins packages. Discovery is handled by the npx skills add pathway above, which registers the skills/ directory from the package.

Orca

Orca installs and manages Agent Skills for its coding-agent workflows. This package needs no Orca-specific manifest: install the complete skill directories in a standard Agent Skills location. Orca’s skills registry documentation describes the npx skills add workflow used for published repositories.

For a workspace, copy or symlink the skills into the workspace’s shared Agent Skills location; for a personal installation use the user location:

<workspace>/.agents/skills/<skill-name>/       # workspace
~/.agents/skills/<skill-name>/                 # user-wide

mkdir -p .agents/skills
cp -R "$PLUGIN_DIR"/skills/* .agents/skills/

Open the workspace in Orca and start a fresh Codex/agent task. The agent should advertise the installed skills and load a matching one on demand.
Orca documents background skill updates but does not require an IDE restart after a manual skill copy. Reopen the workspace or begin a new task if the current agent session does not refresh its catalog.

Verify the portable package before sharing

Run the strict validator before distributing the repository or creating the archives used above:

python3 skills/agent-plugin-builder/scripts/validate_agent_plugin.py . --strict

Validation

From the plugin root, run:

python3 skills/agent-plugin-builder/scripts/validate_agent_plugin.py . --strict

Validate individual Skills with the Agent Skills reference validator or their own bundled validation commands.

Create a deterministic portable archive and validate the extracted copy with:

python3 skills/agent-plugin-builder/scripts/package_agent_plugin.py . \
  --output /tmp/ai-skills-plugin.zip

Standard boundary

Agent Plugins 1.0.0 standardizes the root manifest, Agent Skills, and optional MCP configuration. Client installation, permissions, enablement, and UI remain client-managed.

License

This project and all contained Agent Skills are licensed under the Creative Commons Attribution 4.0 International License (CC BY 4.0).