Agent Skills That Install Themselves

There's a neat recursive trick hiding inside the way we ship the ac12dev skill: a skill is a file that tells an agent what it can do — and part of what it describes is how to install itself. Once an agent reads the skill, it knows how to set up the environment, register the CLI, and immediately start using every capability the skill documents. The bootstrapper and the documentation are the same artifact.

## what is an agent skill?

An agent skill is a Markdown file placed in a well-known location inside a project workspace. When an AI agent starts a session, its host environment (Cursor, Claude Code, or any MCP-compatible tool) automatically injects the skill into the agent's context window. The agent reads it the way a developer reads a README — except the agent can act on it immediately.

Skills typically describe:

• what a CLI tool or API can do
• the exact command syntax for every operation
• how to authenticate or configure the tool
• common workflows and patterns

Think of a skill as a pre-loaded cheat sheet. The agent doesn't need to guess how ac12 service deploy works — the skill has already told it.

## the structure: skill + script, side by side

The ac12dev skill lives at a predictable path inside the workspace:

The SKILL.md documents every ac12 subcommand — services, files, domains, cron, databases, email, registry, and the repo API. The scripts/ac12 binary lives right next to it, so the skill can tell agents exactly where to find and install the tool in a single self-contained package.

The skill and the script ship together. When an agent installs the skill, it also gets the binary. When it reads the skill, it learns what the binary does. Everything needed to go from zero to deployed is in one directory.

## the recursive part

Here's where it gets interesting. The skill file itself contains installation instructions: how to copy it into the right directory, how to make the script executable, and how to register it with the agent's host environment. A first-time agent can read the skill before it's installed and learn how to install it.

The loop looks like this:

1. An agent encounters the skill file — perhaps fetched from a URL, found in a repo, or passed directly as context.
2. The skill contains its own installation instructions: where to place the SKILL.md, where to place the binary, how to chmod +x it.
3. The agent executes those instructions. The skill is now registered in .cursor/skills/ac12dev/.
4. On the next session start, the host environment auto-injects the skill. The agent now has full knowledge of every capability without any manual prompting.
5. The agent can use ac12 service deploy, ac12 db query, ac12 file upload — everything the skill documents — immediately.

The skill bootstraps itself into future sessions. It's not magic — it's just a well-placed Markdown file — but the pattern is elegant. You use the skill to install the skill, and once it's installed, it tells you everything it can do.

## installing in different environments

The same skill works across agent environments because the conventions are consistent. The install path differs slightly depending on the host:

In both cases, the binary (when one exists) goes in the scripts/ subdirectory alongside the skill. The skill's installation section tells the agent to copy it to a location on $PATH — typically /usr/local/bin/ on Linux — and mark it executable:

# install the CLI from the skill's own scripts directory
cp .cursor/skills/ac12dev/scripts/ac12 /usr/local/bin/ac12
chmod +x /usr/local/bin/ac12

Once that's done, the CLI is available system-wide for the rest of the session, and the skill's documentation covers every command from that point on.

## once installed: full capability, zero guessing

Before the skill is loaded, an agent working with the ac12 platform would have to guess at command syntax, make trial-and-error API calls, or ask the user for help. After the skill is loaded, the agent has complete, accurate knowledge of:

• Services — deploy, restart, tail logs, inspect deployments
• Files — upload public files, serve them at predictable URLs
• Domains — map subdomains to services or file paths
• Cron jobs — schedule, trigger, and monitor recurring tasks
• Database — query and mutate the project's SQLite instance
• Registry — push Docker images from remote sources or local tarballs
• Email — send, receive, and reply from @ac12.dev addresses
• Repo — read, write, and commit files through the platform's git API

The agent doesn't need documentation, doesn't need to browse the web, and doesn't need to ask. The skill has already answered every question.

## why this pattern matters

The self-installing skill pattern solves a real distribution problem. Getting an AI agent to reliably use a new tool has historically required:

• manually pasting documentation into a system prompt
• hoping the model has memorized the tool from training data
• writing elaborate setup instructions that the agent might misinterpret

Skills short-circuit all of this. Ship the skill file alongside the tool, and the agent arrives pre-briefed. The skill is both the installation guide and the reference manual. It persists across sessions because it lives in the repo. It stays up to date because it ships with the binary. And it works with any agent that knows how to read a Markdown file — which is all of them.

The deepest version of this pattern: the skill for a platform can include a skill for installing skills. One bootstrap file that teaches the agent the conventions, the paths, and the workflow for adding new capabilities. Skills all the way down.

## the ac12dev skill as a live example

Everything described here is exactly how the ac12dev skill works in practice. When an agent starts a session in a project workspace on ac12.dev, it finds .cursor/skills/ac12dev/SKILL.md already present. It reads the skill and immediately knows how to deploy services, manage files, run cron jobs, and query the database — no setup required.

For a new project or a fresh agent session, the skill's own preamble explains where it lives and how to register it. The agent can follow those steps, drop the skill into place, and be fully operational before the user has typed a second message.

That's the bet: if you make skills self-describing and self-installing, agents become useful faster, with less friction, and stay useful across session boundaries without any manual re-prompting. The skill does the work of onboarding the agent so you don't have to.