# AI Coding Playbook

> [View this product on lib-pro](https://lib-pro-3f8437.gitlab.io/libs/ai-coding-playbook) · The playbook we use to ship with AI agents.

**Outcome:** Turn a capable LLM into an orchestrator that ships.

5 battle-tested AI-agent skills — planner, sdd, worker, team, create — packaged as a methodology bundle. Includes drop-in adapters for Claude Code, Cursor, Cline, and Aider. Used to ship every library in this store.

**Price:** £10 — lifetime · **Category:** AI Skills Bundle · **Tech:** pi-agent, Claude Code, Cursor, Cline, Markdown

| Metric | Value |
|--------|-------|
| Skills | 5 |
| Adapters | 4 |
| Cost to author | £10 once |

## Quick start

```bash
tar -xzf ai-coding-playbook-0.1.0.tgz -C ./.pi
```

- # Skills live under .pi/skills/<name>/SKILL.md
- # Adapters under adapters/<tool>/
- # Pick your agent, drop in, restart session

## Code preview

```
# sdd — Spec-Driven Development

Four phases. Use them as vocabulary, not gates.

## explore
Read enough to know what you don't know.
Stop when you can name the unknowns.

## design
Name the shape before you write the code.
A short paragraph beats a long debate.

## apply
Make the change. Test it. Move on.
Don't revisit design mid-apply.

## verify
Did it actually do what you said?
If not, the design was wrong — go back.

A task can skip phases. A task can revisit a
phase. The phases are vocabulary, not gates —
but the order is the default.
```

## Use cases

### 1. Non-trivial feature work

Build a settings page, a billing flow, an admin tool. The planner writes the brief, the worker executes the easy parts, the team debates the hard parts.

**Outcome:** Stop getting half-thoughts back from the model.

### 2. Refactors & migrations

Move from Pages Router to App Router. Swap an auth lib. Rename a core type. Plan, phase, apply, verify.

**Outcome:** Big refactors that don't blow up the codebase.

### 3. Multi-repo orchestration

Update a shared package, regenerate consumers, run tests across repos. The team skill runs the cross-checks.

**Outcome:** One prompt, five repos updated in lockstep.

### 4. Building your own skills

The create skill teaches you when to capture a pattern as a reusable skill vs. a one-off command.

**Outcome:** A library of patterns that compounds over time.

## Built for

- Engineers using Claude Code or Cursor daily
- AI-heavy teams who want a shared vocabulary
- Solo founders shipping with AI agents
- Anyone tired of rewriting the same prompt

## Highlights

### Vocabulary, not a workflow

These skills name the moves: explore, design, apply, verify. Once you have the words, you stop arguing about steps and start shipping.

### Delegation as a first-class move

worker / team / planner — the playbook knows when to stop and dispatch. The model that's good at the wrong task isn't a model you use.

### Used to ship this store

Every product on this page — including the page you're reading — was built with these skills. Receipts not included; the site is.

## What's in the box

- `planner` — plan-then-execute discipline
- `sdd` — phase vocabulary + delegation
- `worker` — delegate to cheaper models
- `team` — multi-agent debate
- `create` — when to author a skill
- `Claude Code adapter` — drop-in
- `Cursor / Cline / Aider adapters` — drop-in
- `Worked example` — real usage

## Adapters included

These skills were authored for pi-agent, but we include drop-in adapters for the major AI coding tools.

| Tool | Adapter location | What you get |
|------|------------------|--------------|
| Claude Code | `adapters/claude-code/` | .claude/commands/*.md + CLAUDE.md fragments |
| Cursor | `adapters/cursor/` | .cursorrules rule sets |
| Cline / Continue | `adapters/cline/` | System-prompt rules |
| Aider / generic | `adapters/generic/` | INSTRUCTIONS.md snippets |

**Same playbook, different packaging.** The adapters translate the methodology into the format each tool expects. Install once, swap agents without re-learning the method.

## Features

- planner skill — plan-then-execute discipline with brief/context/next-action handoffs
- sdd skill — explore/design/apply/verify phase vocabulary + delegation contract
- worker skill — delegate to cheaper models with a live feedback loop
- team skill — multi-agent debate for hard decisions
- create skill — when to author a skill, agent, or command
- Drop-in adapters for Claude Code, Cursor, Cline, Aider
- Tested in production on this very storefront
- Personal-use commercial license

## FAQ

### What agents does this work with?

Claude Code, Cursor, Cline, and Aider ship with first-class adapters. The skills are plain Markdown so any agent that reads a system-prompt file can use them.

### Is this just prompts?

No. Each skill is a SKILL.md with a trigger pattern, a methodology, and a delegation contract. They're designed to be loaded by the agent at the right moment, not pasted in.

### Do I need a specific model?

No. The skills are model-agnostic. Pair the planner/team skills with a strong model and the worker skill with a cheap one — that's the whole point.

### What's the difference vs an agent template?

Templates tell the agent what to do. Skills teach the agent a discipline it can apply to new problems. You don't outgrow a skill.