agents by wshobson

# agents by wshobson

Offers a catalog of plugins that bundle agents, skills and commands for AI coding tools including Claude Code, Codex CLI, Cursor and GitHub Copilot, kept as one Markdown source. It suits developers who code with AI.

Made by wshobson on GitHub. These notes are Mindket's, written from its README; the project's own files and license are in its repository.

## About

What it is: This project is a catalog of 94 plugins that bundle agents, skills and commands for AI coding tools. The authors keep a single Markdown source for every piece, laid out like a Claude Code plugin, and adapters then produce what each other tool reads. The plugins span Python and JavaScript work, review, testing, infrastructure and security. This kit holds notes on the project and points to its code.

Who it suits: Developers who use AI coding tools and want ready-made helpers for their daily work, and teams that use more than one such tool and want the same components in each.

```table
Title: Who uses agents
Industry | Who uses it | How they use it | Example
Software development | Python developers | Add the Python plugin for Django, FastAPI, testing and packaging help | Installing python-development in Claude Code
Web development | JavaScript and TypeScript developers | Use the plugin for development and project setup | Installing javascript-typescript before starting a project
Engineering teams | Tech leads | Share code review, debugging, Git and testing patterns | Adding the shared review and debugging plugin for the whole team
Security | Security engineers | Run security review, dependency checks and code scanning | Installing security-scanning on a repository
```

You can skip it if your tool is not on the supported list, or if you only want a single skill, since the README points those users to a skills-only installer.

Where to use it:

- Claude Code, through its plugin marketplace
- OpenAI Codex CLI, through its native marketplace or generated files
- Cursor, through its plugin marketplace
- OpenCode, Antigravity CLI, GitHub Copilot and Pi, installed from a clone of the repository

```table
Title: Jobs it does
Use case | Who | What they get back
Python work | Python developers | Agents, skills and a scaffolding command for Python, Django, FastAPI, testing and packaging
Frontend and Node work | JavaScript developers | Help with writing JavaScript and TypeScript and setting up projects
Review and debugging | Developers | Code review, debugging, Git and testing patterns
Security checks | Security engineers | Security review, dependency checks and code scanning
```

How to set it up: You need these first.

- One of the supported coding tools
- A current Codex CLI, if you use Codex
- A clone of the repository and make, for OpenCode, Antigravity CLI, GitHub Copilot or Pi

1. Pick your tool in the README's table, since what you get depends on the install route and the tool's abilities.
2. In Claude Code, register the marketplace and then install a plugin, using the two commands below.
3. In Codex CLI, run the two codex commands below in a terminal.
4. For OpenCode, Antigravity CLI, GitHub Copilot or Pi, run that tool's make target from the clone.

```text
/plugin marketplace add wshobson/agents
/plugin install python-development@claude-code-workflows
```

```bash
codex plugin marketplace add wshobson/agents
codex plugin add python-development@claude-code-workflows
```

```bash
make install-opencode
make install-antigravity
make install-copilot
make install-pi
```

How to use it: Once a plugin is installed, describe the work to your tool and tell it to call the plugin's agents. Alternatively, type the plugin's own scaffolding command.

```text
/python-development:python-scaffold Create a FastAPI service with tests
```

```table
Title: Starter plugins
Tool | What it does
python-development | Python work with Django and FastAPI, plus testing and packaging
javascript-typescript | Writing JavaScript and TypeScript and setting up projects
security-scanning | Reviewing security, checking dependencies and scanning code
```

Contributors can check their work from the repository root with these commands.

```bash
make generate-all
make validate STRICT=1
make garden
```

Example: You install the python-development plugin in Claude Code and run its scaffolding command with a request to create a FastAPI service with tests. The command starts the service from that request, using the plugin's Python agents and skills.

For newcomers and experts: A plugin here is a bundle of ready-made helpers for your coding tool: agents that take on a kind of task, skills that carry know-how, and commands you type. Start with one plugin that matches your work, such as python-development, and install it with the commands for your tool.

If you know the field, each component lives once as Markdown. Small adapter scripts generate the format each tool reads, turn the model names set in each source agent into that tool's own models, and convert tool permissions when the tool allows it. Each CI run rebuilds and validates the generated files, and Pi, OpenCode and Antigravity CLI output is run through each installed CLI. The trade-off is that the tools do not all support the same things, so a command can turn into a skill on one tool and a prompt template on another.

```flow
Authors write plugins once in Markdown
Adapters generate each tool's own format
CI rebuilds and validates every output
You install through your tool's route
Your tool loads agents, skills and commands
```

Good to know:

- License: MIT.
- Catalog: 94 plugins, of which 92 are local and 2 are external entries.
- Support differs by tool: Pi needs a subagent extension before agents work. On Codex, the native manifests give you the source skills, and the generated agents and command skills come by another route.
- Generated Codex copies split oversized skill bodies into reference files, to fit an 8 KB budget.
- Static skill checks in plugin-eval run without model calls.
- The experimental judge layers, one using an LLM and one running repeated simulations, have not been checked against human ratings. Their scores show model opinions, not proof that a task works in your project.
- The optional llm packages must be installed first. If ANTHROPIC_API_KEY is set, model calls go through it and are charged to that API account. Without it, they run on your Claude Code login.

```chart
Title: What the local source contains
Agents: 202 agents
Skills: 185 skills
Commands: 105 commands
```

## On GitHub, 15 November 2026

- Stars: 42,515
- Forks: 4,493
- Watching: 314
- Open issues and pull requests: 14
- Language: Python
- License: MIT
- Topics: agent-skills, agentic-ai, ai-agents, anthropic, antigravity, claude, claude-code, claude-code-marketplace, claude-code-plugin, claude-skills, codex, coding-agents

## Links

- Code: https://github.com/wshobson/agents
- Website: https://sethhobson.com/
- Releases: https://github.com/wshobson/agents/releases
- Issues: https://github.com/wshobson/agents/issues
- Star history: https://www.star-history.com/#wshobson/agents&Date

## Get the code

```
git clone https://github.com/wshobson/agents.git
```

Then follow the setup in its README. Nothing in this kit runs by itself.

README.md  7 KB