Category
Reusable skills for AI coding agents
A skill is a named procedure an AI coding agent can invoke instead of re-deriving the steps every time. Memories say what is true. Rules say what must not happen. Skills say how a specific job is done, in order, so the agent stops missing the fourth step and you stop describing it in every prompt.
A named, reusable procedure an AI coding agent can invoke on demand: replay a Stripe webhook locally, regenerate the seed fixtures, open a draft PR with the right labels and reviewers, run the pre-release checklist. The body is the procedure itself, written once and stored where the whole team gets it.
A skill is not a longer memory. The unit is a sequence with an order that matters. If the knowledge is one or two lines, or if the agent only needs to know it rather than perform it, that is a memory.
The signal that you want a skill
It is not "this is complicated". It is the agent keeps walking through the same set of steps and sometimes misses one. The tell is repetition in your own prompts: if you find yourself re-explaining the same procedure, the procedure is a thing, and it should exist somewhere other than your memory of how you described it last time.
Reach for a skill when the procedure has more than three steps, or when any part of it carries a "do this in this order" requirement. Below that, a memory holds it fine and costs less.
What tends to be worth writing down
Operational procedures. Replay a webhook locally. Regenerate the seed fixtures. Run the pre-release checklist. Jobs with a fixed sequence and a step that is easy to skip.
Custom workflows. Open a draft PR with the right labels and the right reviewers. Bump the version, tag and push. The parts of shipping that are team convention rather than tooling.
Domain-specific guidance. Build a new analytics event end to end: column, type, dashboard. Work that touches several places in a required order.
Not: anything with a real decision in the middle. If the third step is "figure out whether this is the right approach", the procedure is not settled yet. Write down what you know as a memory and let the skill wait until the sequence stops changing.
Memory, rule or skill
What is true here
A fact the agent should hold while it works, weighed against the situation. "Tests live next to the file they test." Persistent memory for coding agents.
What must not happen
A constraint with a scope, a priority and an enforcement level. Not negotiable, and a strict one can block a violating change. Rules for coding agents.
How this job is done
A named sequence invoked on demand. The agent performs it rather than merely knowing it.
Situation, absolute, sequence
It depends on the situation: memory. It is absolute: rule. It is a sequence someone keeps repeating: skill. Long read: three kinds of team knowledge.
What a skill looks like
A skill is a small markdown file: frontmatter with a name and a description, then the procedure body. The full file is the source of truth, frontmatter included, and the description is what the agent matches against when deciding whether this is the skill for the job.
--- name: replay-stripe-webhook description: Replay a Stripe webhook against the local server with the right signing secret and the right idempotency key handling. --- # Replay a Stripe webhook Use this when a payment event from production needs to be reproduced locally.
Where the body lives
`manual`. Authored directly in Pathrule and stored as is. The default, and the right choice when the procedure should be fully owned by the workspace.
`template`. A Pathrule-provided starter, copied into the workspace and editable from there.
`github_ref`. The skill points at an external GitHub URL and the runtime fetches and caches the body. For skills published by an ecosystem you trust. The cached body is the last snapshot served, and the workspace picks up upstream changes on the next refresh.
Scope, sharing and review
Skills are workspace-level and attached to nodes through a join, so one skill can be reused across many paths without being copied. That is what makes a skill a team artifact rather than a personal snippet: it is written once, attached wherever the procedure applies, and the teammate who joins next month gets it without being told it exists.
It also makes a skill reviewable. Pathrule treats rules and skills as artifacts rather than as text: the self-audit surfaces stale or conflicting entries as suggestions, your assistant drafts the fix, and you approve the change. Pathrule never edits your knowledge on its own. Authoring detail: writing skills.
Skills and Patterns
A real convention is rarely one skill. Security work is rule-heavy, architecture work is memory-heavy, review work is skill-heavy, and a topic usually needs some of each. That bundle is what a Pathrule Pattern is: a small, opinionated set of memories, rules and skills for one topic, each piece already scoped to the path it belongs to, so importing it lands the pieces at their target paths instead of dumping everything into one root file.
If you are looking for a skill to start from, start there. Long read: what a Pathrule Pattern is, and why it is not a skill.
Which agents can invoke them
Frequently asked questions
What is an AI agent skill?
A named, reusable procedure an AI coding agent can invoke instead of re-deriving the steps: replay a Stripe webhook locally, regenerate the seed fixtures, run the pre-release checklist. The body is a small markdown file whose frontmatter names the skill and describes what it is for.
When should something be a skill rather than a memory?
When it is a sequence and the order matters. Reach for a skill past three steps, or whenever any part carries a "do this in this order" requirement. One or two lines, or a fact the agent only needs to know rather than perform, is a memory.
Why does my agent not use the skill I wrote?
Most often the description does not say what the skill is for. Skills are selected by description, so a vague one loses to the agent's own default plan: name the trigger rather than the topic. The other common causes are a scope that never matches the paths where the job happens, and a procedure that still has a real decision in the middle. Long read: why Claude Code skills do not activate.
Can a skill be shared across a team?
Yes, and that is the point of storing it outside a prompt. Skills are workspace-level and attached to nodes through a join, so one skill is reused across many paths and every teammate's agent can invoke it. Membership and per-node overrides are enforced server-side. See roles and permissions.
Can I use skills published by someone else?
Yes. A skill can point at an external GitHub URL as its source, and the runtime fetches and caches the body. The cached copy is the last snapshot served, and the workspace picks up upstream changes on the next refresh. Use it for skills published by an ecosystem you trust.
What is the difference between a skill and a Pathrule Pattern?
A skill is one procedure. A Pattern is a small bundle of memories, rules and skills for one topic, each piece pre-scoped to the path it belongs to, because a real convention is rarely one file. Long read: what a Pathrule Pattern is, and why it is not a skill.
Do skills replace my prompts?
No, they remove the repetition from them. A skill is worth writing when you notice yourself re-explaining the same procedure. The prompt then names the job instead of describing it, and the steps stop drifting between one telling and the next.