# Agent skills

> Eleven rd-* skills that teach Claude Code and Codex how to plan, file, build and ship work in Radial.

A skill is a folder with a `SKILL.md` in it. Your agent reads the description,
decides the skill applies, and follows the procedure inside. That is the whole
mechanism: no plugin, no runtime, no code executing on your machine that you
cannot read in a text editor.

The `rd-*` pack is eleven of them, covering the loop from "we should probably do
X" to an open pull request, plus four you run on their own to keep a backlog
honest. They are [MIT and public](https://github.com/BrainGridAI/radial/tree/main/skills):
read them, fork them, send a pull request.

## Install in 60 seconds

```bash
radial skills install
```

That writes the pack into `~/.claude/skills` and `~/.agents/skills`. Restart
your agent, then type `/rd-setup` in Claude Code or `$rd-setup` in Codex.

Working in one repo rather than everywhere?

```bash
radial skills install --project
```

Full detail, including the other two installers and what to do when nothing
shows up: [Install and update](/docs/skills/install).

## The workflow, in order

| Skill | What it does |
| --- | --- |
| `rd-setup` | CLI, sign-in, team, `.radial/config.json`, the agent instructions, the pack |
| `rd-plan` | An idea becomes one parent and two to four children with acceptance criteria |
| `rd-prototype` | One clickable HTML file, attached to the issue with a Preview URL |
| `rd-issues` | Files the tree, wires the `blocked-by` edges, reads every issue back |
| `rd-build` | Works the tree child by child: in progress, build, gate, notes, in review |
| `rd-verify` | Resolves and runs this repo's gate, then reads the summary line |
| `rd-pr` | Branch, base sync, commit, pull request with sibling ids scrubbed |

They chain, but nothing forces you through all seven. `/rd-plan` on its own is
useful. So is `/rd-verify`.

## Hygiene, any time

| Skill | What it does |
| --- | --- |
| `rd-triage` | Ranks open parents Now, Next, Later, Icebox from real signal |
| `rd-cleanup` | Open children under done parents, closed or promoted on evidence |
| `rd-changelog` | Completed issues become Feature, Improvement and Fix entries |
| `rd-retro` | Scores one finished build against the workflow, with evidence |

## Three things worth knowing before you start

### The description is the interface

Your agent picks a skill by reading its `description` frontmatter and nothing
else. That is why each one names Radial, the issue tracker, and the client it
runs in, and why you invoke a skill by describing your situation rather than by
memorising its name.

### They read and write through the `radial` CLI

Which means they respect your session, your scope and your team. A read-scoped
key stops `/rd-issues` at the first create with a clear message, rather than
half-filing a tree.

### A tree ends in review, never done

`/rd-build` moves each child to in review and stops. Closing is a human
decision, and a workflow that closes its own work hides the moment someone
should look at it.

## Change them without forking them

Every skill has named extension points. You write a small wrapper that adds your
rules at those points and keep receiving updates to the skill itself:

```bash
radial skills extend rd-build --name team-build
```

See [Extending a skill](/docs/skills/extending).

## Where the files live

| Path | What it is | Commit it? |
| --- | --- | --- |
| `.radial/config.json` | The team key for this repo | yes |
| `.radial/skills/<name>/` | Your wrappers | yes |
| `.radial/changelog.md` | What `rd-changelog` writes | yes |
| `.radial/plans/` | Plan bodies, scaffolding for `rd-issues` | no |
| `.radial/prototypes/` | Prototype HTML before it is attached | no |

`radial skills update` picks up new versions; `radial skills list` shows what
you have against what is published.