Portable engineering workflows for AI coding agents
One process for every task — implement, then verify independently.
41 playbooks that give Claude Code, Cursor, Codex, GitHub Copilot, Antigravity, and 10 other AI coding tools a shared engineering process — reproduce before fixing, test before building, verify independently before calling anything done. Built on the open AGENTS.md standard.
Windows, in PowerShell (the commands above are bash and fail there):
Needs Git for Windows (it provides bash). Other options: Git Bash or WSL.
No account, no token. MIT licensed, installer and content both. Every release is Ed25519-signed and hash-verified before anything touches your project — see how.
There's no command to memorize. Describe the task normally — the router classifies it and sends it to the matching playbook, which always ends in independent verification, not a self-reported "done."
Every tool wants its own file. Claude Code, Cursor, Codex, and Copilot each expect instructions in their own format and location. agent-playbooks is one generic instruction set instead — write the rules once, point every tool at the same source of truth.
An agent left to its own judgment fails in the same few ways, every time. It guesses at an ambiguous spec instead of asking. It grades its own work instead of checking it independently. It forgets a project's own conventions the moment a new session starts. It occasionally runs something destructive because nothing stopped it.
This is that process, written down once, usable everywhere. Every playbook has been run against a real, throwaway test case at least once — not just written and published.
The installer fetches content from a backend on every run — which matters, because that content becomes literal instructions for an agent with shell access. Here's exactly what stands between a compromised backend and your project.
Every release is signed. An Ed25519 key that never leaves the
maintainer's machine signs a manifest of every file's sha256 hash.
install.sh verifies the signature and re-hashes every
fetched file before writing anything — a spoofed backend can no
longer silently swap in different content.
A real, enforced block on destructive commands. Not a markdown instruction hoping the agent listens — a deterministic script wired into the tool's own pre-execution hook where supported, with its exact coverage and gaps documented, not assumed.
Nothing hidden about what gets sent. The installer sends one
random local ID, nothing else. No account, no telemetry beyond that,
no email. Read supabase/functions/check-in/index.ts
yourself — it's the whole mechanism.
Grouped by kind of concern. Full detail, a flowchart per playbook, and a worked example for every one live in the README, FLOWS.md, and EXAMPLES.md.
engineering-loop — router + verification rulebug-fix — reproduce before fixingfeature-development — test-firstclarify-before-buildingissue-triagefinish-work — check, document, commit, push, ask at each stepcode-review / receiving-code-reviewsecurity-reviewarchitecture-reviewfrontend-testing / backend-testingdocs-sync, observability, writing-stylerefactoringdependency-upgradesdatabase-migrationincident-responserelease, performancesafety-guardrail — real, enforcedsecret-scan — real, enforcedmemory-hygienesensitive-datamission-modestanding-permissionroles — six reusable personasproject-bootstrap, project-auditcodebase-mapping, database-mappingthird-party-api-integrationdemo-video, video-review, doc-reviewClaude Code, Cursor, Antigravity, GitHub Copilot, and Gemini
CLI each get a real generated file; Codex CLI and most others read
AGENTS.md natively with nothing extra to generate.
A ~95-second tour of the engineering-loop discipline: one AGENTS.md, classify-route-verify, bug-fix, feature-development, code review, independent verification, the safety guardrail, blind build/verify, and codebase mapping.
Want the longer version? 36 of the 41 playbooks, narrated, each with a real terminal run — not a slideshow.
A portable, tool-agnostic instruction set for AI coding agents, built on the AGENTS.md standard. 41 playbooks covering bug fixes, feature development, code review, security review, testing, and autonomous operation, so you write the rules once instead of configuring every AI coding tool separately.
15 tools: Claude Code, Antigravity, Cursor, GitHub Copilot, GitHub Copilot CLI, OpenAI Codex CLI, Codex App, Gemini CLI, Devin CLI, Factory Droid, Grok Build, Kimi Code, OpenCode, Pi, and Hermes Agent. Most read AGENTS.md automatically; the README documents the exact mechanism for each.
curl -fsSL https://raw.githubusercontent.com/chiragmangaldev3112/agent-playbooks/main/install.sh
-o install.sh && chmod +x install.sh && ./install.sh /path/to/your/project
— no account or token required. The installer fetches the current
release from a small backend each run; every release is signed and
verified before anything is written to your project (see
Verifying a release).
Yes. Both the installer and the playbook content are MIT-licensed — free to use, fork, modify, and redistribute, commercially or otherwise.
A cross-vendor open standard for giving AI coding agents project-level instructions in a single, tool-agnostic file, read automatically by most major AI coding tools. agent-playbooks builds its entire instruction set on top of this standard rather than inventing a proprietary format.