productionize

Transform any codebase into production-grade, industry-standard code with one command — in any of 8 AI coding agents.

The core idea: before touching code, classify every unit as a statement (single call site, no boundary — gets minimum lines, zero ceremony) or a seam (crosses a boundary, shared state, untrusted input, load-bearing at 10k+ users / 1M+ records — gets full rigor). This prevents the two classic failure modes of AI-generated code: five lines of ceremony around a one-line check, and the API handler that falls over at 2,000 concurrent jobs.

---

Agent compatibility

Agent	What it reads	How to install
Claude Code	SKILL.md (agentskills.io standard)	cp -r . ~/.claude/skills/productionize/ → run /productionize
OpenAI Codex	AGENTS.md (auto) + SKILL.md skills	Rules: nothing to do — AGENTS.md auto-loads. Skill: cp -r . ~/.codex/skills/productionize/ → $productionize
Cursor	.cursor/rules/*.mdc + AGENTS.md (auto)	Nothing to do — both auto-load when this repo's files are in your project
Google Antigravity	AGENTS.md (auto, v1.20.3+) + .agent/rules/	Nothing to do — auto-loads. Native rules in .agent/rules/productionize.md
Kiro (AWS)	.kiro/steering/*.md + AGENTS.md (auto)	Nothing to do — steering file live-inlines the canonical rules via #[[file:]] refs
OpenCode (SST)	AGENTS.md (auto) + Claude skills compat	Nothing to do — AGENTS.md auto-loads; also reads ~/.claude/skills/
OpenClaw	SKILL.md (Claude-compatible)	cp -r . <workspace>/skills/productionize/ or ~/.agents/skills/productionize/
Hermes (Nous)	SKILL.md (requires version field — included)	cp -r . ~/.hermes/skills/engineering/productionize/ (skills are user-level only)

Two delivery modes, one source of truth:

• Passive rules (always on while you code): AGENTS.md, .cursor/rules/, .agent/rules/, .kiro/steering/ — the agent applies statement/seam discipline to every edit it makes in your project.
• Active transformation (on demand): SKILL.md — run it to audit and fix an entire existing codebase, producing a PRODUCTION_CHANGES.md report.

All adapters point at the same canonical content in rules/ — edit rules once, every agent picks it up.

---

What each file does

Path	Responsibility	Loaded by
SKILL.md	The executable skill: 5-phase transformation workflow (classify → discover → audit → transform → verify & report)	Claude Code, Codex, OpenClaw, Hermes, OpenCode
AGENTS.md	Condensed always-on rules per the agents.md standard	Codex, Cursor, OpenCode, Antigravity, Kiro
rules/00-production-orchestrator.md	Canonical. Statement vs seam classification + minimalism ladder + routing	Referenced by every adapter
rules/01-system-design.md	Canonical. 8-question capacity checklist (load, volume, concurrency, latency, backpressure, blast radius, next bottleneck, delivery) + worked example	Referenced by every adapter
rules/02-structure-and-coupling.md	Canonical. SRP, encapsulation, dependency injection, open/closed — seams only	Referenced by every adapter
rules/03-portability-and-defense.md	Canonical. Cross-platform, fail fast/safe/loud, least privilege, safe defaults	Referenced by every adapter
rules/04-testability-and-docs.md	Canonical. Intern-on-vacation test bar, pure functions, YAGNI for structure	Referenced by every adapter
rules/05-definition-of-done.md	Canonical. 5-point acceptance gate — nothing is "done" until linter/types/tests ran clean	Referenced by every adapter
.cursor/rules/*.mdc	Cursor-native mirror of the six rules (alwaysApply: true)	Cursor
.agent/rules/productionize.md	Antigravity-native rule pointing at canonical rules/	Antigravity
.kiro/steering/productionize.md	Kiro steering that live-inlines rules/ via #[[file:]] (zero drift)	Kiro
patterns/standards.md	Per-language idioms: TypeScript, Python, Go, Rust, Java	SKILL.md workflow
patterns/error-handling.md	Error-class hierarchy + boundary-catcher playbook	SKILL.md workflow
patterns/security.md	Security hardening checklist (secrets, SQLi, XSS, deps)	SKILL.md workflow
examples/before-after.md	Concrete before/after transformation examples	SKILL.md workflow

---

Usage

Active mode — transform a codebase

/productionize              # entire codebase       (Claude Code / OpenClaw)
/productionize src/         # specific folder
/productionize src/api/users.ts   # single file
$productionize              # Codex

Passive mode — rules while you code

Drop this repo's files into your project (or install project-wide). Every edit the agent makes then goes through: classify → statement gets one line, seam gets the system-design checklist + coupling + defense + test rules + done-gate.

---

What you get when you run it

Every run produces PRODUCTION_CHANGES.md with:

Output	Contents
Summary table	Found / Fixed / Needs-review counts across 12 audit categories
Seams identified	Each seam: location, why it's a seam, its design-note summary
Files modified	Per-file changelog by category
Needs manual attention	Risky changes flagged, not auto-applied — including missing tooling (no linter/test runner)
Conventions established	New constants, config, .env.example, logger setup
Definition-of-done results	Pass/fail per gate: linter, types, code-ran, design notes, tests
Test results	Actual runner output — never "would pass"

The 12 audit categories: documentation · error handling · input validation · type safety · structured logging · security · naming · magic values · contributor notes · system design (seams) · coupling (seams) · portability & defense (seams).

Typical results

Illustrative single run on a ~40-file TypeScript API service (results vary by codebase):

Category	Found	Auto-fixed
Missing docs on public symbols	63	63
Silent catches / swallowed errors	11	9
Unvalidated API boundaries	7	7
any types / missing return types	48	44
console.log → structured logger	92	92
Hardcoded secrets / SQLi / XSS	5	4 (1 flagged for human)
Magic values extracted	31	31
Seams without design notes	6	6

Hard guarantees regardless of codebase:

• Zero silent skips — a missing linter or test runner becomes a report finding, never an excuse.
• Zero functionality changes — risky fixes are flagged for humans, not auto-applied.
• Every seam documented — the 8-question design note (load, volume, concurrency, latency, backpressure, blast radius, bottleneck, delivery) sits above the code.
• Evidence, not claims — "done" requires the linter, type checker, and tests to have actually run.

---

Design principles

1. Single source of truth. All rule content lives in rules/. Adapters are thin pointers or generated mirrors — fix a rule once, all 8 agents inherit it.
2. Statement vs seam is the whole game. Most production-readiness tools apply maximum rigor everywhere and produce ceremony. This skill spends rigor only where code crosses boundaries.
3. Definition of done is a gate, not a vibe. Ran ≠ would run. Missing tooling is reported, never silently skipped.

Supported languages

TypeScript · Python · Go · Rust · Java · Kotlin

Contributing

PRs welcome. Ground rules:

• Rule content changes go in rules/ — then mirror to .cursor/rules/*.mdc (Kiro and the pointer adapters pick changes up automatically).
• Keep every rule file under 500 lines (Cursor/Claude listing limits).
• New language support goes in patterns/standards.md + examples/before-after.md.
• Test a change by running /productionize against a real project in at least one agent before opening the PR.

License

MIT © 2026 G. Karthik Koundinya