All products
AI Skills Bundle

AI Coding Playbook

The playbook we use to ship with AI agents.

Turn a capable LLM into an orchestrator that ships.
See use cases ↓
One-time paymentLifetime updatesCommercial license

.pi/skills/

planner/plan-then-execute
sdd/explore → design → apply → verify
worker/delegate to cheap models
team/multi-agent debate
create/when to author a skill

adapters

Claude CodeCursorClineAider

5

Skills

4

Adapters

£10 once

Cost to author

What you'll be able to do

Concrete outcomes, not vague promises.

01

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.

Stop getting half-thoughts back from the model.
02

Refactors & migrations

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

Big refactors that don't blow up the codebase.
03

Multi-repo orchestration

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

One prompt, five repos updated in lockstep.
04

Building your own skills

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

A library of patterns that compounds over time.

Built for

If any of these are you, this is for you.

Engineers using Claude Code or Cursor dailyAI-heavy teams who want a shared vocabularySolo founders shipping with AI agentsAnyone tired of rewriting the same prompt
Built withpi-agentClaude CodeCursorClineMarkdown

Why this playbook works

Three things that make this different from a wall of prompts.

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.

Quick start

Drop the package into your project and start using the commands.

terminal
$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

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

Everything in the pack

What you get the moment your payment clears.

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

Adapters included

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

ToolAdapter locationWhat you get
Claude Codeadapters/claude-code/.claude/commands/*.md + CLAUDE.md fragments
Cursoradapters/cursor/.cursorrules rule sets
Cline / Continueadapters/cline/System-prompt rules
Aider / genericadapters/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.

Full documentation

Everything in the package, every prop, every pattern.

AI Coding Playbook

Five skills that turn a capable LLM into an orchestrator that ships.

The Problem

You have a smart AI coding assistant. It can write code, answer questions, and follow instructions. But when you give it a non-trivial task — build a feature, refactor a module, design a system — it:

  • Drifts into half-thoughts instead of finishing
  • Grinds through boilerplate in the main thread
  • Picks the first plausible approach instead of exploring
  • Doesn't know when to stop and ask you for help
  • Repeats the same mistakes across sessions

You spend more time correcting it than it saves.

The Fix

The skills in this pack are the operating system we layer on top of the raw model. Each one captures a discipline that's hard to maintain in the moment but easy to forget when you're heads-down:

  • Plan first — write down what you're about to do, with a Brief and a Next Action
  • Phase the work — name what kind of step this is (explore / design / apply / verify)
  • Delegate execution — dispatch well-defined tasks to a cheaper model, watch the loop
  • Debate the hard parts — when the answer is open-ended, run multiple agents and synthesize
  • Author the patterns — when something recurs, capture it as a reusable skill

What's In The Pack

planner — The discipline of writing it down

  • Triggers on any 3+ step task, multi-file edit, or "let's tackle X" phrase
  • Writes a persistent plan to .pi/plans/<date>-<slug>.md
  • Format: Brief / Status / Last touched / Next action header + free-form body
  • One plan per block of work — never merge unrelated work

sdd — Spec-Driven Development as a vocabulary

  • Defines four phases: exploredesignapplyverify
  • "A task can skip phases. A task can revisit a phase. The phases are vocabulary, not gates — but the order is the default."
  • Includes a delegation trigger table — when to stop and dispatch to a worker

worker — The organizer pattern

  • "The worker is not a fire-and-forget subprocess. It's a loop."
  • Worker writes checkpoint → Organizer reads → Organizer feedback → Worker continues
  • Default for execution — if it involves more than a couple of tool calls, dispatch a worker
  • Includes stopping rules (max attempts, explicit abort)

team — Multi-agent debate for hard decisions

  • Runs multiple models in parallel for structured debate
  • Falls back to simulated personas if only one model is available
  • "Architecture, design, API, or data-model decisions" all qualify
  • Triggers: "compare A vs B", "decide between", "help me choose", "trade-offs between"

create — When to author your own extensions

  • Decision tree: skill vs. agent vs. command vs. rule vs. hook
  • Skill anatomy (the markdown + scripts format)
  • Anti-patterns to avoid

Adapters Included

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

ToolAdapter locationWhat you get
Claude Codeadapters/claude-code/.claude/commands/*.md + CLAUDE.md fragments
Cursoradapters/cursor/.cursorrules rule sets
Cline / Continueadapters/cline/System-prompt rules
Aider / genericadapters/generic/INSTRUCTIONS.md snippets

The adapters translate the methodology into the format each tool expects. Same playbook, different packaging.

Real Usage

This is the playbook we used to build every library in this storefront:

  • 3 React/TypeScript libraries, scaffolded and shipped
  • The Stripe product/pricing/payment-link setup automation
  • The source repository + automated build pipeline
  • The storefront itself (Next.js, Tailwind, static export)

It works. It's not magic — it's discipline.

License

Personal-use commercial. One purchase = one seat. Install in your dev environment, modify freely, use in client work. Do not resell the pack or the unmodified skills as a competing product.

What's in the download

A .tgz containing:

ai-coding-playbook-0.1.0/
├── README.md              ← this overview
├── INSTALL.md             ← per-tool setup walkthrough
├── METHODOLOGY.md         ← the longer write-up
├── skills/                ← the 5 skill files (SKILL.md)
│   ├── planner/
│   ├── sdd/
│   ├── worker/
│   ├── team/
│   └── create/
├── adapters/              ← drop-in for other tools
│   ├── claude-code/
│   ├── cursor/
│   ├── cline/
│   └── generic/
└── examples/              ← worked examples from real projects

Updates

Free for life — re-download any time.

Common questions

Things people ask before buying.

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.

£10 — lifetime

One purchase. Yours forever.

Pay once via Stripe. Get the complete package instantly. Free updates for the same major version. Commercial license included.

Secure payment via Stripe · Instant download · 30-day money-back if it doesn't save you time