{
  "markdown": "# Production Grade Plugin\n\n<p align=\"center\">\n  <img src=\"assets/banner.png\" alt=\"Meet the Production Grade crew — 14 AI agents\" width=\"700\">\n</p>\n\n<p align=\"center\">\n  <a href=\"https://github.com/nagisanzenin/production-grade\"><img src=\"https://img.shields.io/github/stars/nagisanzenin/production-grade?style=social\" alt=\"GitHub stars\"></a>\n  <a href=\"https://discord.gg/3ux2c5xz\"><img src=\"https://img.shields.io/badge/Discord-Join%20Community-5865F2?logo=discord&logoColor=white\" alt=\"Discord\"></a>\n  <img src=\"https://img.shields.io/badge/License-MIT-yellow.svg\" alt=\"MIT License\">\n  <img src=\"https://img.shields.io/badge/version-5.6.1-blue.svg\" alt=\"Version\">\n  <img src=\"https://img.shields.io/badge/platforms-4-orange.svg\" alt=\"4 platforms\">\n  <img src=\"https://img.shields.io/badge/agents-14-green.svg\" alt=\"14 agents\">\n  <img src=\"https://img.shields.io/badge/protocols-9-red.svg\" alt=\"9 protocols\">\n  <img src=\"https://img.shields.io/badge/execution%20modes-10-purple.svg\" alt=\"10 modes\">\n</p>\n\n<h3 align=\"center\">14 AI agents, one install, idea to production.</h3>\n\n```bash\n/plugin marketplace add nagisanzenin/claude-code-plugins\n/plugin install production-grade@nagisanzenin\n```\n\n> **New in v5.6 — one repo, four platforms.** The same 14 skills now install natively on **Claude Code, OpenAI Codex, OpenCode, and Pi** — one shared core, thin per-platform glue, honest per-platform status. [Support matrix below.](#platforms)\n\n> **New in v5.5 — The Loop Engine.** Agents stop claiming \"done\" and start proving it. Every stage now loops against a check it can't argue with — typecheck, tests, or the running app clicking its own buttons — until it converges. [How it works.](#the-loop-engine)\n\n<br>\n\n## Built With This Plugin\n\n**Built something with this plugin? [Open a PR](https://github.com/nagisanzenin/production-grade/pulls) to add your project here.**\n\n| Project | Live | Description |\n|---------|------|-------------|\n| **PingBase** | [pingbasez.vercel.app](https://pingbasez.vercel.app/) | Free uptime monitoring — get emailed when your website goes down. GitHub OAuth, Stripe billing, Turso DB. |\n| **LLM Matrix Arena** | [llm-matrix.vercel.app](https://llm-matrix.vercel.app/) | Browse and compare LLM models across N dimensions. Community-driven voting from real developers — not benchmarks, real opinions. |\n| **SkyClaw** | [github.com/nagisanzenin/skyclaw](https://github.com/nagisanzenin/skyclaw) | Cloud-native Rust AI agent runtime. Telegram-native — deploy one binary, paste your API key, and control your server through chat. |\n\n---\n\n## Release Timeline\n\n```\n2026-08-19  v5.6  ●━━━ Omni-platform — native installs on Codex, OpenCode, Pi; platform-adaptation contract; pi payload-harness 14/14\n                  │\n2026-07-02  v5.5.2 ●━━━ Loop-engine robustness — resilient report-artifact writes + orchestrator recovery; deep-smoke requires an adversarial input\n                  │\n2026-07-02  v5.5.1 ●━━━ Loop-engine hardening — trustworthy BUILD-exit deep-smoke gate, worktree-safe scoped oracle-gate, brownfield toolchain adoption\n                  │\n2026-07-02  v5.5  ●━━━ The Loop Engine — oracle-driven iteration: edit-gate hook, TDD pair, functional drive replaces hand-testing\n                  │\n2026-03-07  v5.4  ●━━━ Harmonization — mode-aware autonomy, cross-session enforcement, agent skill loading\n                  │\n2026-03-07  v5.3  ●━━━ Worktree isolation, self-healing gates, cost dashboard\n                  │\n2026-03-07  v5.2  ●━━━ Frontend overhaul — functional-first, design polish, 4 visual style presets\n                  │\n2026-03-07  v5.1  ●━━━ Boundary Safety — 6 patterns for system boundary bugs, from real deployment\n                  │\n2026-03-06  v5.0  ●━━━ Verified & Resilient — receipt enforcement, re-anchoring, adversarial review\n                  │\n2026-03-06  v4.4  ●━━━ Freshness protocol — agents WebSearch to verify volatile data before implementing\n                  │\n2026-03-06  v4.3  ●━━━ Visual identity, pipeline dashboard, gate ceremonies\n                  │\n2026-03-06  v4.2  ●━━━ Adaptive routing, 10 execution modes, everyday SWE work\n                  │\n2026-03-05  v4.1  ●━━━ Engagement modes, scale-driven architecture, adaptive interviews\n                  │\n2026-03-04  v4.0  ●━━━ Two-wave parallelism, internal skill agents, dynamic task generation\n                  │\n2026-03-04  v3.3  ●━━━ Brownfield-safe — works on existing codebases\n                  │\n2026-03-03  v3.2  ●━━━ Auto-update, MECE intent routing, protocol crash fix\n                  │\n2026-03-02  v3.1  ●━━━ Polymath co-pilot — the 14th skill\n                  │\n2026-03-01  v3.0  ●━━━ Full rewrite — Teams/TaskList, 7 parallel points, shared protocols\n                  │\n2026-02-28  v2.0  ●━━━ 13 bundled skills, unified workspace, prescriptive UX\n                  │\n2026-02-24  v1.0  ●━━━ Initial release — autonomous DEFINE>BUILD>HARDEN>SHIP>SUSTAIN\n```\n\n---\n\n## The Pipeline\n\n```\n  YOU ──→ \"Build a SaaS for ...\"\n           │\n           ▼\n  ┌─────────────────────────────────────────────────────────────────┐\n  │                    DEFINE                                       │\n  │  T1  Product Manager ─── BRD, user stories, acceptance criteria│\n  │  T2  Solution Architect ─ ADRs, API contracts, data models     │\n  │                                                                 │\n  │  ┌─────────────┐  ┌──────────────┐                             │\n  │  │ GATE 1      │  │ GATE 2       │                             │\n  │  │ Requirements│  │ Architecture │                             │\n  │  └─────────────┘  └──────────────┘                             │\n  └─────────────────────────────────────────────────────────────────┘\n           │\n           ▼\n  ┌─────────────────────────────────────────────────────────────────┐\n  │               BUILD + ANALYZE  (Wave A — parallel)             │\n  │                                                                 │\n  │  Backend ──── N agents (1 per service)    QA ──── test plan    │\n  │  Frontend ─── N agents (1 per page)       Security ── STRIDE   │\n  │  DevOps ──── Dockerfiles + CI skeleton    Review ── checklist  │\n  │                                           SRE ───── SLOs       │\n  └─────────────────────────────────────────────────────────────────┘\n           │\n           ▼\n  ┌─────────────────────────────────────────────────────────────────┐\n  │               HARDEN  (Wave B — parallel against code)         │\n  │                                                                 │\n  │  QA ─────── unit / integration / e2e / performance tests       │\n  │  Security ── code audit + dependency scan (4 parallel phases)  │\n  │  Review ──── arch / quality / performance (adversarial)        │\n  │  DevOps ──── build + push containers                           │\n  └─────────────────────────────────────────────────────────────────┘\n           │\n           ▼\n  ┌─────────────────────────────────────────────────────────────────┐\n  │                          SHIP                                   │\n  │                                                                 │\n  │  DevOps ── IaC + CI/CD  ┐                                      │\n  │  Remediation ───────────┘ parallel    ┌──────────────┐         │\n  │  SRE ── chaos + capacity ┐            │ GATE 3       │         │\n  │  Data Scientist ─────────┘ parallel   │ Production   │         │\n  │                                       │ Readiness    │         │\n  │                                       └──────────────┘         │\n  └─────────────────────────────────────────────────────────────────┘\n           │\n           ▼\n  ┌─────────────────────────────────────────────────────────────────┐\n  │                        SUSTAIN                                  │\n  │                                                                 │\n  │  Technical Writer ── API ref + dev guides (parallel)           │\n  │  Skill Maker ─────── 3-5 project-specific reusable skills     │\n  │  Compound Learning ── pipeline insights for next run           │\n  └─────────────────────────────────────────────────────────────────┘\n           │\n           ▼\n        DONE ── receipts verified, agents cleaned up\n```\n\n> **3 gates. 2 waves. 10+ parallel execution points. ~3x faster than sequential.**\n> **Every stage loops against an executable oracle until it converges — [The Loop Engine](#the-loop-engine).**\n\n---\n\n## The Loop Engine\n\n*New in v5.5 — the reason the agents stop lying about \"done.\"*\n\nSoftware is never one pass. It's write, run, fail, fix, run again, until a check passes. Through v5.4 the pipeline was mostly feed-forward: each agent did its job, handed the artifact down, and correctness leaned on human review at the gates. v5.5 makes iteration the main path, on a single rule:\n\n> **A task is done when a check it cannot argue with says so — not when the agent claims it.**\n\nThat check is an *oracle*: a compiler, a type checker, a test suite, or the running app clicking its own buttons. No oracle, no loop.\n\n```\n        ┌──────────────┐\n        │   PRODUCE    │   agent writes / fixes\n        └──────┬───────┘\n               ▼\n        ┌──────────────┐   red    ┌────────────────┐\n        │    ORACLE    │ ───────▶ │  DELTA BACK    │\n        │ test·type·app│          │ failing output │\n        └──────┬───────┘          │ only → re-loop │\n          green │                 └────────┬───────┘\n               ▼                           │\n        ┌──────────────┐  no progress ×2   │\n        │  CONVERGED   │ ◀─────────────────┘\n        └──────────────┘  plateau → escalate strategy, not effort\n```\n\nWhat it adds, concretely:\n\n- **Oracle bootstrap.** Before any parallel wave, the pipeline writes two check scripts for your project: a fast one (typecheck + lint, under 15s) and a full one (tests + build + boot smoke).\n- **Enforced by a hook, not a prompt.** A `PostToolUse` hook runs the fast oracle after *every* file edit. Break something and the error lands back in the agent's lap immediately, not at the end.\n- **Separated duties.** QA writes failing tests first and owns the `tests/` folder. A coding agent that weakens a test to go green gets flagged with a Critical finding. No grading their own homework.\n- **Functional drive.** Before the final gate, an agent boots the real app and drives it — every button, every form, every link. A control that renders but does nothing is a Critical bug. This is the hand-testing replacement.\n- **Convergence, not retries.** Each loop tracks a number (failing tests, open findings) and stops when it hits zero or stops improving, shows the trend, then escalates. No retrying the same fix five times.\n\nFully backward compatible: a pipeline that never needs to loop runs exactly as before. Full design rationale in [docs/LOOPS.md](docs/LOOPS.md).\n\n---\n\n## 10 Execution Modes\n\nNot just full builds. The orchestrator reads your request and routes automatically.\n\n```\n┌──────────────────────────────────────────────────────────────┐\n│                                                              │\n│   Full Build ████████████████████████  all 14 agents         │\n│   Feature    █████████████            PM+Arch+Eng+QA        │\n│   Harden     ████████                 Sec+QA+Review         │\n│   Ship       ██████                   DevOps+SRE+DS         │\n│   Architect  ████                     Solution Architect     │\n│   Test       ███                      QA Engineer            │\n│   Review     ███                      Code Reviewer          │\n│   Document   ███                      Technical Writer       │\n│   Optimize   █████                    SWE+Data Scientist     │\n│   Explore    ███                      Polymath               │\n│                                                              │\n└──────────────────────────────────────────────────────────────┘\n```\n\n```\n\"Build a SaaS for e-commerce\"           → Full Build\n\"Add Stripe billing to my API\"          → Feature\n\"Audit this codebase before launch\"     → Harden\n\"Set up CI/CD and monitoring\"           → Ship\n\"Review this PR for quality\"            → Review\n\"Help me think about a fintech app\"     → Explore\n```\n\n---\n\n## The Crew\n\n```\n                    ┌─────────────────┐\n                    │  ORCHESTRATOR   │\n                    │  routes, gates, │\n                    │  receipts       │\n                    └────────┬────────┘\n                             │\n        ┌────────────────────┼────────────────────┐\n        │                    │                     │\n   ┌────▼─────┐     ┌───────▼────────┐    ┌──────▼───────┐\n   │  DEFINE  │     │     BUILD      │    │   HARDEN     │\n   │          │     │                │    │              │\n   │ PM       │     │ Software Eng   │    │ QA Engineer  │\n   │ Architect│     │ Frontend Eng   │    │ Security Eng │\n   │          │     │ DevOps         │    │ Code Review  │\n   └──────────┘     └────────────────┘    └──────────────┘\n                             │\n        ┌────────────────────┼────────────────────┐\n        │                    │                     │\n   ┌────▼─────┐     ┌───────▼────────┐    ┌──────▼───────┐\n   │   SHIP   │     │    SUSTAIN     │    │   ANYTIME    │\n   │          │     │                │    │              │\n   │ DevOps   │     │ Tech Writer    │    │ Polymath     │\n   │ SRE      │     │ Skill Maker    │    │ Data Sci     │\n   └──────────┘     └────────────────┘    └──────────────┘\n```\n\n| # | Agent | Domain | Sole Authority |\n|---|-------|--------|:-:|\n| 1 | **Orchestrator** | Routes, gates, receipts, re-anchoring | |\n| 2 | **Polymath** | Research, ideation, onboarding, translation | |\n| 3 | **Product Manager** | BRD, user stories, acceptance criteria | Requirements |\n| 4 | **Solution Architect** | ADRs, tech stack, API contracts, data models | Architecture |\n| 5 | **Software Engineer** | Handlers, services, repositories, business logic | |\n| 6 | **Frontend Engineer** | Design system, components, pages, accessibility | |\n| 7 | **QA Engineer** | Unit, integration, e2e, performance tests | |\n| 8 | **Security Engineer** | STRIDE, OWASP, PII, dependency scanning | Security |\n| 9 | **Code Reviewer** | Architecture conformance, anti-patterns (adversarial) | Code Quality |\n| 10 | **DevOps** | Docker, Terraform, CI/CD, containers | Infrastructure |\n| 11 | **SRE** | SLOs, chaos engineering, runbooks, capacity | Reliability |\n| 12 | **Data Scientist** | LLM optimization, prompt engineering, cost modeling | |\n| 13 | **Technical Writer** | API reference, dev guides, architecture docs | |\n| 14 | **Skill Maker** | Generates project-specific reusable agent skills | |\n\n---\n\n## What Makes It Different\n\n```\n  ┌──────────────────────────────────────────────────────────────┐\n  │                                                              │\n  │  ORACLE-DRIVEN LOOPS          FUNCTIONAL DRIVE               │\n  │  ──────────────────           ────────────────               │\n  │  No oracle, no loop. A loop   A separate agent boots the     │\n  │  exits on an executable       running app and drives it:     │\n  │  check: tests, typecheck,     every button, every form,      │\n  │  the running app. Never on    every link. A dead element     │\n  │  \"looks done.\" Converge or    is a Critical bug — this is    │\n  │  escalate, never blind-retry. the hand-testing killer.       │\n  │                                                              │\n  │  RECEIPT ENFORCEMENT          RE-ANCHORING                   │\n  │  ─────────────────            ────────────                   │\n  │  Every agent writes a         Orchestrator re-reads specs    │\n  │  JSON receipt as proof.       FROM DISK at every phase       │\n  │  No receipt = not done.       transition. No context drift   │\n  │  Gate won't open without      in multi-hour runs.            │\n  │  verified artifacts.                                         │\n  │                                                              │\n  │  ADVERSARIAL REVIEW           FRESHNESS PROTOCOL             │\n  │  ──────────────────           ──────────────────             │\n  │  Code reviewer assumes        Agents detect volatile data    │\n  │  code is WRONG until          (model IDs, pricing, CVEs)     │\n  │  proven right. Scales         and WebSearch to verify        │\n  │  from critical-only to        BEFORE implementing.           │\n  │  hostile break scenarios.                                    │\n  │                                                              │\n  │  CONSTRAINT-DRIVEN ARCH       ZERO OPEN-ENDED QUESTIONS      │\n  │  ─────────────────────        ─────────────────────────      │\n  │  Architecture derived from    Every interaction is arrow     │\n  │  YOUR scale, budget, team,    keys + Enter. Polymath         │\n  │  compliance — not templates.  translates at every gate.      │\n  │  100 users → monolith.                                       │\n  │  10M users → microservices.                                  │\n  │                                                              │\n  │  MODE-AWARE AUTONOMY          CROSS-SESSION PERSISTENCE      │\n  │  ───────────────────          ─────────────────────────      │\n  │  Express: zero questions,     SessionStart hook detects      │\n  │  auto-resolve everything.     production-grade projects.     │\n  │  Meticulous: every decision   New sessions get a courteous   │\n  │  surfaced. Agent questions    prompt: use plugin, work       │\n  │  scale independently of       directly, or chat about it.    │\n  │  pipeline gates.              Your workflow persists.        │\n  │                                                              │\n  └──────────────────────────────────────────────────────────────┘\n```\n\n---\n\n## Protocol Stack\n\nAll 14 agents load the same 9 protocols at startup:\n\n```\n  ┌──────────────────────────────────────────────┐\n  │          Loop Protocol                        │  ← oracle-driven iteration\n  ├──────────────────────────────────────────────┤\n  │          Boundary Safety                      │  ← system boundary patterns\n  ├──────────────────────────────────────────────┤\n  │          Receipt Protocol                     │  ← proof of completion\n  ├──────────────────────────────────────────────┤\n  │          Freshness Protocol                   │  ← verify volatile data\n  ├──────────────────────────────────────────────┤\n  │          Visual Identity                      │  ← consistent formatting\n  ├──────────────────────────────────────────────┤\n  │          Conflict Resolution                  │  ← sole-authority domains\n  ├──────────────────────────────────────────────┤\n  │          Tool Efficiency                      │  ← dedicated tools > shell\n  ├──────────────────────────────────────────────┤\n  │          Input Validation                     │  ← classify external inputs\n  ├──────────────────────────────────────────────┤\n  │          UX Protocol                          │  ← structured interactions\n  └──────────────────────────────────────────────┘\n```\n\n---\n\n## Engagement Modes\n\nChoose your depth at pipeline start. Propagates to all 14 agents.\n\n```\n  Express     ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░  zero agent questions, auto-resolve all\n  Standard    ████░░░░░░░░░░░░░░░░░░░░░░░░░░  1-2 per skill, subjective/irreversible only\n  Thorough    █████████████░░░░░░░░░░░░░░░░░░  all major decisions surfaced\n  Meticulous  ██████████████████████████████░░  every decision point, full user control\n```\n\n> **3 pipeline gates (BRD, Architecture, Production Readiness) always fire regardless of mode.**\n> Agent questions are separate — they scale from zero (Express) to exhaustive (Meticulous).\n\n---\n\n## Token-Efficient Architecture\n\nLarge skills split into **router + on-demand phases**. Only what's needed loads. Independent phases run as parallel agents with minimal context.\n\n```\n  Polymath ─────────── 6 modes    onboard | research | ideate | advise | translate | synthesize\n  Software Engineer ── 5 phases   context | implement | cross-cutting | integration | local dev\n  Frontend Engineer ── 6 phases   analysis | functional foundation | components | pages | design polish | testing\n  Security Engineer ── 6 phases   threat model | code audit | auth | data | supply chain | remediation\n  SRE ─────────────── 5 phases   readiness | SLOs | chaos | incidents | capacity\n  Data Scientist ──── 6 phases   audit | LLM optimization | experiments | pipeline | ML infra | cost\n  Technical Writer ── 4 phases   audit | API reference | dev guides | Docusaurus\n```\n\n---\n\n## By the Numbers\n\n```\n  ┌─────────────────────────────────────────────────────┐\n  │                                                     │\n  │   14  specialized agents                            │\n  │    9  shared protocols                              │\n  │    2  oracle scripts generated per project          │\n  │    1  fast oracle check after every single edit     │\n  │   10  execution modes                               │\n  │   10+ parallel execution points                     │\n  │    3  approval gates                                │\n  │    4  engagement modes                              │\n  │   ~3x faster than sequential execution              │\n  │  ~45% fewer input tokens from parallelism           │\n  │    0  open-ended questions — all structured         │\n  │   11  governing principles                          │\n  │    5  languages: TS, Go, Python, Rust, Java/Kotlin  │\n  │                                                     │\n  └─────────────────────────────────────────────────────┘\n```\n\n---\n\n## Platforms\n\nOne repo, one shared core (`skills/` — Agent Skills standard `SKILL.md` — plus the protocols in `skills/_shared/`), thin per-platform glue. Where a platform lacks a tool the skills name, `skills/_shared/platform-adaptation.md` maps the mechanism; the guarantees (structured choices, receipts, gates, re-anchoring, oracle discipline) stay identical.\n\n| Platform | Install | Invoke | Status |\n|---|---|---|---|\n| **Claude Code** | `/plugin marketplace add nagisanzenin/claude-code-plugins` then `/plugin install production-grade@nagisanzenin` | `/production-grade …` or natural language | Reference platform — hooks, parallel waves, worktrees, everything |\n| **OpenAI Codex** | [INSTALL-CODEX.md](INSTALL-CODEX.md) — plugin route or Agent Skills route | `$production-grade …` | Manifests mirror the Claude ones; **not yet verified against a live Codex binary** (honest status in the doc) |\n| **OpenCode** | [INSTALL-OPENCODE.md](INSTALL-OPENCODE.md) — clone + one `skills.paths` config entry | natural language | **Verified live on v1.18.4**: all 14 skills discovered (`opencode debug skill`) |\n| **Pi** | `pi install git:github.com/nagisanzenin/production-grade` — [INSTALL-PI.md](INSTALL-PI.md) | `/production-grade …` or `/skill:production-grade` | **Verified on pi 0.84.2, 14/14 checks** by the committed [payload-capture harness](experiments/pi-harness/) — skills, template, session-guard extension |\n\nAmbient enforcement varies by host: the SessionStart guard + PostToolUse oracle-gate hooks run on Claude Code (and ride along for Codex); Pi gets the session guard via `extensions/production-grade.ts`; on hosts without edit hooks, agents run the fast oracle themselves after every edit (loop-protocol Rule 7 — the hook is enforcement, not the rule).\n\n## Installation\n\n```bash\n# Claude Code — marketplace (recommended)\n/plugin marketplace add nagisanzenin/claude-code-plugins\n/plugin install production-grade@nagisanzenin\n\n# Or from source\ngit clone https://github.com/nagisanzenin/production-grade.git\nclaude --plugin-dir /path/to/production-grade\n\n# Other platforms: see the support matrix above / INSTALL-<PLATFORM>.md\n```\n\n**Requirements:** an agent platform from the matrix above (Claude Code is the reference), Docker & Docker Compose, Git.\n\nWorks on existing codebases — brownfield detection auto-maps your project structure.\n\n---\n\n## FAQ\n\n**Does it write working code?** Yes. Write, build, test, debug, fix. No stubs. No TODOs.\n\n**Existing projects?** Yes. Brownfield detection auto-maps. Run specific modes or full pipeline.\n\n**How do I know it ran everything?** Receipts. JSON proof from every agent, verified at gates.\n\n**Context degrade in long runs?** No. Re-anchoring re-reads from disk at every phase transition.\n\n**Not technical?** Every interaction is multiple choice. Polymath translates at any gate.\n\n---\n\n## Contributing\n\n1. Fork the repo\n2. Create a branch: `git checkout -b feature/your-feature`\n3. Commit changes\n4. Open a Pull Request\n\n**Adding a skill:** Create `skills/your-skill-name/SKILL.md` with `---` frontmatter.\n\n---\n\n## Community\n\nJoin the Discord to share what you've built, discuss workflows, report bugs, and request features.\n\n<a href=\"https://discord.gg/3ux2c5xz\"><img src=\"https://img.shields.io/badge/Discord-Join%20Community-5865F2?style=for-the-badge&logo=discord&logoColor=white\" alt=\"Join Discord\"></a>\n\n---\n\n## Star History\n\n<a href=\"https://star-history.com/#nagisanzenin/production-grade&Date\">\n <picture>\n   <source media=\"(prefers-color-scheme: dark)\" srcset=\"https://api.star-history.com/svg?repos=nagisanzenin/production-grade&type=Date&theme=dark\" />\n   <source media=\"(prefers-color-scheme: light)\" srcset=\"https://api.star-history.com/svg?repos=nagisanzenin/production-grade&type=Date\" />\n   <img alt=\"Star History Chart\" src=\"https://api.star-history.com/svg?repos=nagisanzenin/production-grade&type=Date\" />\n </picture>\n</a>\n\n---\n\n## More from the same workshop\n\nFive Claude Code plugins from the same workshop. Most share one habit: *let a deterministic core decide, and never let the producer of work grade it.*\n\n- **[engram](https://github.com/nagisanzenin/engram)** — evidence-based learning engine: first-principles curricula, generation-first tutoring, blind-graded free recall, FSRS-scheduled memory. The receipt-and-assessor discipline in this plugin started there.\n- **[effortmining](https://github.com/nagisanzenin/effortmining)** — benchmark-calibrated per-subagent reasoning effort: dispatch the cheapest tier a blind grader still accepts (64.7% fewer output tokens at equal quality, pre-registered). Built *with* this pipeline — its repo carries the receipts.\n- **[idiolect](https://github.com/nagisanzenin/idiolect)** — human-voice writing engine: 60+ measured voices plus a deterministic AI-tell scanner and a blind auditor, so text reads like a person, not a model.\n- **[less](https://github.com/nagisanzenin/less)** — a minimal comms protocol for Claude: a per-turn hook makes replies answer-first, pick-list-driven, and calm, without touching the work.\n\n## License\n\nMIT\n\n---\n\n<p align=\"center\">\n  <strong>14 agents. 9 protocols. 10 modes. One install.</strong>\n</p>\n",
  "bytes": 26598,
  "sha": "ff0037373274db7632ddb3c011f7974a64d5ebc6aeb3b8dc04580b883d210f80",
  "repo_slug": "nagisanzenin/claude-code-production-grade-plugin",
  "fonte": "repo",
  "truncated": false,
  "api": "https://agentalog.com/api/listings/plg_nagisanzenin_claude_code_production_grad_b43e26e8/readme"
}