dev-playbook

Writing code got cheap. Writing good code didn't. More code is the expensive part.

Your agent writes a thousand lines before lunch. None of them to your team's conventions. dev-playbook serves those rules over MCP, so the agent reads them before it writes.

Get startedRead the docs

Run the server with Docker, then two commands in Claude Code. Cursor, Windsurf, Zed and any MCP client connect over SSE.

A repo with no standards
@app.get("/orders")def get_orders(page: int = 1, size: int = 20):    rows = db.execute(        f"SELECT * FROM orders LIMIT {size} OFFSET {(page-1)*size}"    ).fetchall()    return rows
  • size has no ceiling, so ?size=100000 is a full table scan.
  • The query is an f-string. Every other query in this repo is parameterised.
  • Rows go out as they come back, so adding a column changes the public API.
  • No test. "Done" here means the endpoint returned 200 once, by hand.
The same prompt, with dev-playbook
@app.get("/orders", response_model=Page[OrderOut])def list_orders(page: PageParams = Depends()) -> Page[OrderOut]:    return orders.paginate(page)

Nothing to mark. It read the guardrails, the pagination pattern and the definition of done before it wrote a line, so the ceiling, the parameterised query, the response model and the test were never up for negotiation.

In the box

Run it with Docker

one Compose file, one command, on port 8420

Claude Code plugin

install it, run /dev-playbook-init, and it wires everything up

Reads before it writes

guardrails and the task workflow arrive before the first edit

Six language packs

go, java, kotlin, python, rust, typescript

What gets generated

guardrails, definition of done, architecture, git rules, task workflows

Dashboard

authoring wizard, four-tab editor, adoption and latency

Blog

The rest is on the blog.

The problem it solves, how the agent asks before it writes, the tool surface, the template packs, the dashboard and how it runs, the enforcement model, and the design decisions behind each, all live on the blog and in the docs.

Read the blog or browse the docs.

Install

Put it in front of your agent this afternoon.

1. Run the server - download the Compose file and start it with Docker.

curl -O https://raw.githubusercontent.com/arockiaraj1994/dev-playbook/main/docker-compose.ymldocker compose up -d

2. Connect Claude Code - install the plugin and run the setup command.

/plugin marketplace add arockiaraj1994/dev-playbook/plugin install dev-playbook@dev-playbook/dev-playbook-init

/dev-playbook-init connects to the server, sets your standards up for the repo, and turns on the guardrails. Full walk-through in Get started.

Other editors - any MCP client connects to the same server over SSE.

Codex - one command in the terminal:

codex mcp add dev-playbook --url http://localhost:8420/sse

Cursor - add to ~/.cursor/mcp.json:

{ "mcpServers": { "dev-playbook": { "url": "http://localhost:8420/sse" } } }

These give Cursor and Codex the playbook tools. The guardrails hooks and /dev-playbook-init are Claude Code only - elsewhere, ask the agent to read the standards and it calls the tools. More in the plugin docs.