Skills and Commands: Reusable Patterns

Rules give agents your project's persistent ground rules. But not every piece of context belongs in every conversation. Skills and commands are the tools you reach for when you want to package reusable knowledge or prompt templates that get loaded on demand, exactly when you need them, and nowhere else.

The problem: context bloat

If you put everything into your rules file, you end up with a wall of text the agent has to parse on every single interaction. A rule about how to write database migrations doesn't need to be in context when you're asking for help with a CSS layout issue. Too much irrelevant context dilutes attention and slows things down. Skills and commands solve this: they let you keep the default context lean and pull in specialized knowledge exactly when the task calls for it.

Skills: reusable capability descriptions

A skill is a Markdown file that describes how to perform a specific type of task, following your team's patterns and conventions. The agent loads it when the task matches, either automatically (based on the description) or explicitly (when you tell it to use a skill).

Think of a skill as a senior engineer's knowledge for a specific domain, written down so any agent can use it. Good candidates for skills:

• How to add a new API endpoint in your service (including validation, error handling, and test conventions)
• How to create a database migration in your stack
• How to write a new React component following your team's pattern
• How to add a new CLI command with the right argument parsing conventions

In VS Code and Copilot, skills are .skill.md files stored in .github/skills/. In Claude Code they're referenced in CLAUDE.md. In Cursor, the equivalent is a rules file with a narrow applyTo scope.

The key thing that makes a skill different from a rule: a rule states a constraint ("always use functional components"). A skill describes a workflow ("here's the full process for adding a new component, step by step").

---
name: Add an API endpoint
description: Step-by-step guide for adding a new REST endpoint
---

## When to use this skill
Use this when you need to add a new endpoint to the Express API.

## Steps
1. Define the route in `src/routes/`
2. Create the handler in `src/handlers/` following the existing error handling pattern
3. Add input validation using Zod
4. Write a unit test and an integration test
5. Update the OpenAPI spec in `docs/openapi.yaml`

Commands: reusable prompt templates

A command is a saved prompt you can invoke quickly, often with variables that get filled in at runtime. Instead of rewriting the same prompt every time you want to do a code review, write it once as a command and invoke it with a keyboard shortcut or slash command.

In VS Code and Copilot, commands are .prompt.md files stored in .github/prompts/. Cursor has a built-in commands system. Both support variables like ${file}, ${selection}, and ${input:description}.

---
name: PR review
description: Review a pull request diff for bugs, missing tests, and security issues
---

Review the following diff:

${selection}

Focus on:
- Logic errors and off-by-one bugs
- Missing error handling
- Security issues (injection, insecure defaults)
- Missing test coverage for new branches

Format your response as a numbered list of findings. If nothing stands out, say so.

When you invoke this command with a diff selected, the variable gets filled in automatically and the agent gets the fully-formed prompt.

Skills vs. Rules vs. Commands: when to use each

Building a library over time

The most effective teams treat skills and commands as a shared asset. When someone on the team writes a good migration skill or a sharp code review command, they commit it to the repo. Over time you build a library of reusable patterns that works with any model, survives tool changes, and onboards new engineers faster than any wiki ever could.