Agent Skills

Command Code supports Agent Skills — a lightweight, open standard for extending AI agents with specialized knowledge and workflows.

What are Agent Skills?

Agent Skills are modular, self-contained instruction sets that teach Command Code how to perform specific tasks. Each skill is a folder containing a skill.md file with metadata and step-by-step guidance.

Think of skills as expert playbooks that Command Code can reference when needed. Instead of explaining the same process repeatedly, you define it once in a skill, and Command Code automatically applies it when needed.

How Command Code implements skills?

Command Code fully implements the Agent Skills open standard with two storage locations:

User-level skills (global)

Stored in ~/.commandcode/skills/ and available across all your projects.

Perfect for:

General development workflows
Exploratory workflows
Cross-project best practices

Project-level skills (local)

Stored in .commandcode/skills/ within your project and only available in that project.

Perfect for:

Project-specific patterns
Team conventions
Architecture guidelines
Domain-specific workflows

Note

Learn more about how to create user-level and project-level skills in the Create Skills docs.

`.agents/skills/` compatibility

Command Code also discovers skills from .agents/skills/ (project) and ~/.agents/skills/ (user). If another tool already stores your skills under .agents/, they load automatically and show a [.agents] badge in the /skills menu.

Priority: .commandcode/skills/ wins on name conflicts. If the same skill exists in both, the .commandcode/ version is used and the .agents/ version is skipped. See Selection priority for the full four-way order.

Discovery: Command Code walks up to 10 directory levels from your working directory to find .agents/skills/, stopping at your home directory. This keeps ~/.agents/skills/ from being picked up as a project-level source.

Browse and use skills

Use the /skills slash command to view all the available skills:

Open skills menu

# In Command Code session
/skills

This shows:

All user-level skills with (user) label
All project-level skills with (project) label
Use arrow keys to navigate
Press Enter to open any skill in your editor
Press Esc to close and return to your session

Every installed skill is also surfaced as a first-class slash command in the / menu. If you install a skill named pr-desc, you will see /pr-desc, sorted after built-ins and any custom commands in the slash menu.

If a skill name collides with a built-in or a custom command, the skill still appears in the / menu with a [skill] badge and a — shadowed by /<owner> note. Typing /<name> always resolves to the higher-precedence owner, not the skill. See Selection priority below for the full order.

Invoking a skill

Command Code supports three ways to use a skill in a conversation. Pick whichever matches the task at hand.

1. Exact slash invocation

Type /skill-name at the start of your prompt to run that skill for the current turn:

# In Command Code session
/pr-desc update the description based on new changes

2. Inline slash reference

Drop /skill-name anywhere inside a longer prompt to pin that skill without losing your natural phrasing. You can mix multiple skills in a single prompt:

# In Command Code session
Please follow /code-conv when writing the new module and /pr when opening the review PR.

3. Inferred suggestion

Command Code scans your prompt and suggests a matching skill when one clearly fits. Ordinary prompts keep working exactly like before — inferred suggestions just help you discover what is available.

Selection priority

Skills, custom commands, and built-ins all share the same / menu. Skills from any of these four locations are checked in this order:

.commandcode/skills/ (project)
.agents/skills/ (project)
~/.commandcode/skills/ (user)
~/.agents/skills/ (user)

Put simply: project-level always trumps user-level, and within the same level .commandcode/ is favored over .agents/.

What happens on a collision

When a skill name matches a built-in or a custom command:

Typing /<name> always resolves to the higher-precedence owner — the skill is not invoked.
The skill still appears in the / menu with a [skill] badge and a — shadowed by /<owner> note, so you can see it exists and understand why /<name> runs the built-in command instead. Command Code prefers visibility with a marker over silently dropping the row.

How skills work

Skills use progressive disclosure to manage context efficiently:

Discovery: Command Code loads only the name, description, and file path of each skill at startup.
Activation: When a task matches a skill or invoked directly with /skill-name, Command Code reads its full SKILL.md instructions.
Execution: Command Code follows the instructions, optionally loading referenced files as needed

This keeps Command Code fast while giving access to more context on demand.

Skills Specification

Every SKILL.md file should start with the frontmatter block followed by the markdown instructions in the body.

Frontmatter (required)

---
name: skill-name
description: A description of what this skill does and when to use it.
---

You can add the following optional fields to the frontmatter as needed:

---
name: pdf-processing
description: Extract text and tables from PDF files, fill forms, merge documents.
license: Apache-2.0
compatibility: Requires pdfplumber and PyPDF2 packages
metadata:
  author: example-org
  version: "1.0"
allowed-tools: Read Bash(python:*)
---

Field	Required	Constraints
`name`	Yes	Max 64 characters. Lowercase letters, numbers, and hyphens-separated only. Should not start or end with a hyphen.
`description`	Yes	Max 1024 characters. Describes what the skill does and when to use it.
`license`	No	License name or reference to a bundled license file.
`compatibility`	No	Max 500 characters. Describes environment requirements (packages, system tools, network access, etc.).
`metadata`	No	Arbitrary key-value mapping for additional metadata (author, version, etc.).
`allowed-tools`	No	Space-delimited list of pre-approved tools the skill may use. (Experimental)

Body content

The markdown body followed by the frontmatter contains the skill instructions. There are no format restrictions. Write whatever helps Command Code perform the task effectively.

Recommended sections:

When to use this skill: Clear triggers for activation
Step-by-step instructions: Detailed guidance
Examples: Input/output examples
Common edge cases: Known pitfalls and solutions

Note

Keep your main SKILL.md under 500 lines. Move detailed reference material to separate files in references/.

Optional directories

Your skill folder can also include these optional subdirectories to organize related files:

`scripts/`

Contains executable code that agents can run. Scripts should:

Be self-contained or clearly document dependencies
Include helpful error messages
Handle edge cases gracefully

my-skill/
├── SKILL.md
└── scripts/
    ├── extract.py
    └── process.sh

references/

Contains additional documentation that agents can read when needed:

my-skill/
├── SKILL.md
└── references/
    ├── API_REFERENCE.md
    ├── FORMS.md
    └── TROUBLESHOOTING.md

Keep individual reference files focused. Command Code loads these on demand, so smaller files mean less context usage.

assets/

Contains static resources:

my-skill/
├── SKILL.md
└── assets/
    ├── template.json
    ├── diagram.png
    └── schema.sql

Standard compliance

Command Code fully implements the Agent Skills open standard. Skills you create are:

Portable: Work with any agent that supports the standard
Versionable: Track changes with Git
Shareable: Publish for your team or community
Auditable: Plain text files anyone can read

Next steps

Manage your skills with the /skills command
Join our Discord community for support

Skills