[ PACK LIBRARY / PACK 03 ]
Build and ship software with review and test steps.
46 PLAYBOOKS — 3 OPEN AS FREE SAMPLES
The sample playbooks below are open in full. Unlock the pack once and every playbook here becomes readable, updates included.
Theo, Idris, Root, Jason, Jerry, and Torque take a product from empty repo to a running, authenticated, billed, deployed, tested, and security-reviewed skeleton, with auth handed to a named specialist and a review step.
Root, Satchmo, Jason, and Kayle wire an unattended build-verify-ship loop scoped to a defined blast radius, with a stop condition and cost tracking for each run.
Kayle, Jerry, Jason, and Root map a brownfield repo with systematic debugging and differential review, then produce a prioritized, staged detangling plan that sequences the risky changes behind the safe ones.
Theo, Kira, Idris, and Jason build synchronized Next.js and React Native surfaces against one backend and one Playwright suite, so both clients share the same backend and test plan.
Orbit, Theo, Root, and Jason ship a product usable both as a normal web app and as a tool inside Claude Desktop, ChatGPT, Cursor, and VS Code from day one, published and CI-gated so the MCP surface ships and stays tested alongside the web app.
Satchmo, Kayle, Root, and Zack set up a main-seat/worker-lane split with a second-opinion advisor gate, so cheaper and specialized executors each run under an explicit spec while the main seat keeps planning, review, verification, and git.
Theo and Jerry add wallet and passkey sign-in with Siggy's Sigma Identity patterns and reviewed session and token handling before merge.
Jerry and Theo add tested step-up auth and a device-authorization flow for CLI and desktop, then security-review the change before merge.
Orbit makes the product callable by any MCP host — Claude Desktop, ChatGPT, Cursor, VS Code — with a tool contract designed to be safe and discoverable.
Paul produces a go/no-go release gate that reports known CVEs and leaked secrets for review before ship.
Torque audits scripts, bundles, images, and render-blocking CSS, then returns a scored, prioritized fix list for review.
Jerry runs a severity-rated Semgrep and CodeQL scan of one diff and reports any injection, auth, and data-flow findings for review before merge.
Kayle plans the architecture, Theo builds, Jason tests, and Jerry security-audits — one feature carried end to end through four named specialists with a handoff at each stage. The canonical Kayle-to-Theo-to-Jason-to-Jerry chain.
Theo builds, Torque runs a perf audit, Jason tests, and Root deploys, with each handoff blocking the next, so a feature is measured for speed and covered by tests before it ever reaches a user.
Paul sweeps for exposure, Jerry audits the affected code, Kayle makes the risk call, and Root ships the patch, so an incident moves through one ordered path with a single owner at each step.
A machine-readable manifest of the buyer's stack so every other playbook in this pack starts from documented facts about the languages, frameworks, infra, and ownership in play — the AGENTS.md-style onboarding doc used by the other playbooks.
Root documents the pipeline provider, required checks, deploy targets, and secrets policy, so deploy and CI playbooks plug into the buyer's actual pipeline on their first run.
A fill-in-the-blank doc capturing lint rules, commit style, PR size limits, and merge blockers, so review and test playbooks enforce the buyer's actual bar on every change they touch.
Theo and Orbit build a generative-UI surface that renders from model output via json-render without raw HTML injection, so users get dashboards and forms that recompose around whatever data the model returns.
Jason and Root add Playwright end-to-end coverage and wire it as a CI gate that blocks merges.
Theo runs a codemod-driven migration to Turbopack and async APIs, with a react-doctor pass to catch re-render and hook regressions, so a feature keeps working across the platform major.
Theo builds subscription billing with idempotent, signature-verified webhook handling, Jason covers the event matrix with test cards, and Jerry security-reviews it, so retries and out-of-order events resolve to exactly one fulfillment.
Idris and Theo add live-updating UI with presence and shared state on Convex, without hand-rolling WebSocket plumbing.
Idris, Theo, and Torque add size-limited, validated file handling on Convex storage with images optimized on the way in, so uploads stay bounded and every stored image is already compressed for delivery.
Idris and Root add scheduled, monitored work with job status and failure reporting on Convex cron, replacing fire-and-forget setTimeout calls.
Satchmo and Root instrument an agent workflow with per-request cost tracking and a budget ceiling, so each run records its spend and applies the configured limit.
Zack and Root add enforced pre-commit checks — lint, secret scans, format, type-check — that run automatically on every commit.
Kayle runs a structured before/after risk read on a large change and returns a focused review of its highest-risk differences.
Jerry, Kayle, and Jason run a Hunter-Skeptic-Referee pass that produces reproducible bug reports through separate discovery, challenge, and referee steps.
Jason adds property-based tests for the happy path, edge cases, error conditions, and invariants, giving the module coverage for a later refactor.
Jason explores staging outside the scripted test paths and returns a reproducible list of findings.
Root checks CI status and blocks the next step until the pipeline is green.
Root and Orbit run a clean, reproducible release with the version bumped, changelog written, and tag pushed in one pass, so the published package matches exactly what's in the repo.
Orbit runs the MCP publish checklist — npx compatibility, package.json fields, discovery metadata, install docs — so the server has the files and instructions needed for installation.
Kayle produces a map of the codebase — module boundaries, data flow, entry points, external dependencies — so the next audit or refactor starts from a shared reference every reviewer can read.
Torque compresses images and trims the largest bundle contributors, cutting page weight and JavaScript payload without a redesign or any change to how the product behaves.
Zack and Root configure repo hooks so lint, secret, and format checks run automatically on every change.
Paul enumerates externally reachable inputs for a service before a pentest, so the review starts from a documented surface map of endpoints, headers, parameters, and upload paths.
Zack scaffolds a plugin with the directory layout that auto-discovery expects for skills, agents, hooks, and commands.
Paul assembles and structures the technical-control evidence an auditor will ask for, so the audit opens with an organized evidence set mapped to each control in scope.
Kayle assesses impact, Theo runs the codemod, Jason regression-tests, and Root verifies CI before deploy.
Satoshi measures and compresses the catalog, Jason proves routing survived it, Satoshi splits the plugin into a core plus optional modules, and Zack publishes and sweeps every downstream reference — reducing startup context for capabilities users do not invoke.
Orbit builds the MCP server, Zack shapes the command surface, Jason tests the tool contract, and Root publishes — turning an internal tool into an installable, tested, published MCP server.
Satchmo architects the agent, Zack authors it, Kayle reviews, and Jason benchmarks — so a new agent is designed, built, reviewed, and measured before it is used in a workflow.
Paul maps the sensitive data, applicable controls, sign-off owner, and residual risk via a gap analysis, so security tasks scope to the buyer's documented risk profile.
Satchmo and Root document which staff are installed, their budget and model tier, and the escalation path, so blueprint and chain playbooks know which agents exist in this org and when to escalate to a human.