Skills & Recipes

A compiled skill is app operating knowledge written for a coding agent. The board holds the convention, and the code plugin writes it into the repo as IDE-native files.

Compiled skills, not insight skills

Note

Compiled skills are the operating knowledge an app board writes into a repo. Insight skills are analysis definitions: what a run looks for.

Compiled skills are an outbound part of an app board, alongside intents.

The Skills facet

Every app board has a Skills screen. The header shows progress, the activation list shows what is on, and Add skills opens the picker.

The "What this app receives" preview shows the resolved set the repo will receive.

Two ways in

A new app starts with no skills. Add them two ways:

• Start from a recipe. A recipe is a named, ordered set of related skills. It applies a capability as a set, with a short index explaining what each member is and why it is there. The screen offers recipes matched to your app's type first, and one click applies the set.
• Browse the skill library. Pick skills one at a time. A category rail with live counts lets you work area by area. Search covers names and descriptions. A relevance filter leads with what suits your app's type, and each skill previews in full before you add it.

Some skills take parameters or allow multiple instances. Set those as you add the skill. A recipe fills gaps; it does not override deliberate choices.

What a compiled skill contains

A skill can ship more than SKILL.md:

• Reference files: supporting documents under the skill's own folder that the agent loads on demand, so the core SKILL.md stays focused.
• Executable scripts: a scripts/ directory for deterministic steps a skill defines, such as a check, scaffold, or transform. Scripts are written with the executable bit set and delivered verbatim. They read inputs from argv/env, so their contents are not rewritten.
• Sources and further reading: links to the external documentation the skill draws on.

How they reach the repo

Developers pull the bundle with /skills in the code plugin or the connect plugin:

/skills            # compile the bundle into the repo
/skills --status   # read-only: up to date? changed upstream? locally edited?

The command preserves local edits. A committed lock manifest (pmap-skills.lock.json) hashes managed files. If you edited a SKILL.md, reference, or script, the command leaves it alone and reports it. Your edit wins.

One boundary matters: the command writes the files, and the agent never edits them. Skill files are the instructions it works from.

Commit the compiled skills and the lock so the whole team shares them across sessions and hosts.

Tip

Skill scripts need a current plugin build. If /skills reports that some files "need a newer plugin", run /update and re-run it. Prose and references sync regardless; only scripts wait.

The org-level Skills Library

Settings has a read-only Skills library: everything published to your org, with the same category rail, search, and preview as the board picker.

It is a browser, not an editor.

Overrides

A skill resolves from two layers, with the more specific winning:

Editing a library skill creates a copy for this app. Revert to default drops the copy and returns to the shared version.

Authoring or overriding is included from the Pro plan; Save carries the plan that unlocks it on Free. Turning library skills on and off, setting their parameters, and reverting an override are on every plan, so a downgrade never leaves an app stuck on a copy.

The repo receives the resolved result, not the layering behind it.

What's next