Skip to main content
plugin

ai-shipping — Claude Code plugin: features and installation

The ai-shipping Claude Code plugin documents AI-built apps and checks changes before release. Its ship-check command brings documentation, reviews, and test coverage into one workflow.

MIT ★ 741 updated 2026-11-14

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add phuryn/product-engineering
/plugin install ai-shipping@product-engineering
Open on GitHub

What ai-shipping does

The plugin documents an app, reviews code changes, and guides them through a release gate. ship-check runs the full sequence: it prepares app documents and agent context, checks correctness, security, and performance, then gathers an independent review and a test-coverage map.

Individual skills can start from a request or a matching task. Static audits accept a Git commit range or the uncommitted working tree and focus on affected changes. In check mode, documentation skills compare the code with existing docs without writing files. If ship-check is about to overwrite existing documents or the coverage map, it lists the proposed changes and asks first.

Install the marketplace before installing the plugin. The default reviewer uses the Grok CLI when available; otherwise, the workflow tries a fresh Codex session, then Claude Code.

What it helps with

  • prepare app documentation for review
  • compare documented behavior with the implementation
  • review changes for correctness, security, and performance defects
  • map existing test coverage
  • run an independent review before release

Example prompts for the agent

  • Run the full ship-check workflow for this repository.
  • Compare the app documentation with the code in check mode.
  • Review these changes independently before release.

How to install ai-shipping

Plugin marketplace

/plugin marketplace add phuryn/product-engineering
/plugin install ai-shipping@product-engineering

Step by step, with commands for each platform: Claude Code plugins: marketplaces, installing, and building your own

Questions about ai-shipping

How do I install ai-shipping in Claude Code?

Run /plugin marketplace add phuryn/product-engineering first, then /plugin install ai-shipping@product-engineering.

What does ai-shipping do?

It documents an app, reviews code changes, and prepares checks for release. Start the full sequence with ship-check; individual stages are available as skills.

What happens if ship-check would overwrite existing documents?

It lists the files it plans to change and asks for approval. In check mode, documentation checks report discrepancies without writing files.

Source text

ai-shipping · MIT
# ai-shipping — ship AI-built apps

For builders, PMs and founders accountable for AI-built code. Document a vibe-coded app, review it for correctness, security and performance defects, have a fresh reviewer that never saw the build clear every push that deploys and every release, prove it with a test harness that fakes the right side, and release it through a gate the owner says go to.

It is where the AI Shipping Kit from [pm-skills](https://github.com/phuryn/pm-skills) moved: its three skills and the five workflows that are commands there, plus `release-gate` and `test-harness`. `pm-ai-shipping` in pm-skills now only points here, so once this pack is installed, turn it off.

## Overview

AI agents write code fast but leave no record of *intent* — what the system should do, who may do what, where the secrets live. Without that record, no human and no auditing agent can tell whether the code is safe to ship. This kit restores reviewability: it documents the system, then audits the gap between what the docs say and what the code does — the class of bug generic scanners miss because they have no model of intent.

Start the whole sequence yourself with the ship check: `/ai-shipping:ship-check` in Claude Code, `$ai-shipping:ship-check` in Codex. Every stage of it is also a skill of its own that starts when you ask for that stage ("document the app", "what should we test", "run a security audit").

Folders and file names are defaults. The kit follows the repo's own setup — its agent instructions, its docs folder, and the documents and test-coverage file it already has — and falls back to `documentation/`, `documentation/tests.md` and `reports/` only where the repo has none, saying so in its output.

The two static audits take a git range (`<base>..<head>`, such as a release's unreleased commits) or `changes` (the uncommitted working tree) and then audit only the change: the changed files plus what the change makes newly reachable or newly wrong elsewhere. A release normally audits only its changes; audit the whole repository for the first release, or after a large refactor.

For a repo that keeps its docs and coverage map by hand as intent, `document-app` and `derive-tests` in `check` mode are the release-time form ("check the docs against the code"): they write no file, list each disagreement with `file:line` on both sides, leave the owner to decide whether the code or the doc is wrong, and end with a one-line summary a release checklist can cite.

## Install

```bash
claude plugin marketplace add phuryn/product-engineering
claude plugin install ai-shipping@product-engineering
```

Codex and other agents: see the collection's root `README.md`. Any skill can be started by name: `/ai-shipping:<skill>` in Claude Code, `$ai-shipping:<skill>` in Codex. All but `ship-check` also start on their own when the work matches.

## Skills (11)

**You start it:**

- **ship-check** — Turn a vibe-coded repo into a reviewer-ready shipping packet: document, wire agent context, run correctness, security and performance reviews, add an independent unsteered pass by a fresh reviewer that never saw the build (the reviewer the repository's instructions name, when it can run the way `independent-review` requires, and when it can't, their fallback runs if it can, otherwise the wrapper's reviewer runs without asking; if no other family can run, a fresh session of the builder's family, with the actual reviewer and why recorded; with none named, through the `independent-review` wrapper it carries: Grok when its CLI is installed, so another model family; without it a fresh read-only Codex session, then a fresh read-only Claude Code session; with none of the three CLIs, a fresh read-only session of your own agent, given the prompt the wrapper writes), map test coverage, and compile the results. Only when you start it, because it writes docs, the agent instructions and the coverage map, and takes a long session; where docs already say what the product should do, or whoever runs the gate keeps the coverage map, it lists what it would overwrite and asks first.

**They start on their own:**

- **shipping-artifacts** — The durable documentation set that makes an AI-built app reviewable: a core every app needs (architecture, user/permission flows, permissions, variables/secrets, test-coverage map) plus conditional docs added only when they apply (emails, cron, SEO, embedded agents/automation). Defines what each doc must capture and how a reviewer uses it.
- **code-review** — The top-level review skill. Correctness is its core; **performance and security are optional sub-cases** of the same engine. Anchors on agreements between participants across a boundary — the defects that are invisible file-by-file because each side looks reasonable alone — forces a violating execution, and refutes every candidate before reporting.
- **independent-review** — The unsteered review loop before anything ships: a fresh reviewer that never saw the build reads the unreleased diff and the working tree, round after round, until a round finds nothing the change introduced above Low. By default the reviewer is the Grok CLI when it's installed, so another model family; without it a fresh read-only Codex session, or else a fresh read-only Claude Code session. Your agent instructions can name another, or another order, that runs the way the skill requires. How to scope a round, write its brief, triage what it finds and when to stop, through a wrapper that writes the subject to disk and fails a round that came back too short to have run.
- **release-gate** — How a change ships: the three moments and their bars (a stage done, a push that deploys, a promotion), the owner's preview, the preconditions, go/no-go, promote, and proving the build serving is the one reviewed. Learned on Next.js + Supabase + Clerk + Netlify, principle first.
- **test-harness** — How to test an AI-built app so a green gate means something: what each harness fakes, the script contract, the authenticated mile, the rules that came from bugs, what to do when a fix doesn't land, and the coverage map written by whoever ran the gate.
- **intended-vs-implemented** — The method for finding the gap between what a system is documented to do and what the code actually does, with cited evidence on both sides and without hand-wavy findings.
- **document-app** — Reverse-engineer a codebase into the system documents reviewers and auditors need — a core set (architecture, flows, permissions, variables) plus conditional docs (emails, cron, SEO, automation) when they apply. In `check` mode it writes nothing and reports where the existing docs and the code disagree.
- **derive-tests** — Turn documented intent into a test-coverage map: inventory the tests that exist today, separate them from proposed tests and unverified gaps, mark each by what it depends on, and recommend a gate that follows the repo's stated gate policy (a green-before-merge CI gate where it states none). In `check` mode it writes nothing and reports where the coverage map is stale.
- **security-audit-static** — Static security audit: map trust boundaries, cross-reference documented intent, self-refute every finding, and report only evidence-backed risks. Given `<base>..<head>` or `changes`, it audits only a change. Starts on its own only when a security audit is asked for: `ship-check` runs it, and `release-gate` proposes it and never runs it unasked.
- **performance-audit-static** — Static performance audit: find N+1 queries and request waterfalls, over-fetching, missing indexes, and caching opportunities, ranked by effort and impact. Given `<base>..<head>` or `changes`, it audits only a change. Starts on its own only when a performance audit is asked for: `ship-check` runs it, and `release-gate` proposes it and never runs it unasked.

## Author

Paweł Huryn — [The Product Compass Newsletter](https://www.productcompass.pm)

## License

MIT

© Paweł Huryn · MIT · phuryn/product-engineering

Similar plugins

All plugins for Code review and refactoring →

From the same set51

The whole set →
app-lifecycle The app-lifecycle skill for Claude Code and Codex maps a SaaS product’s path from idea to production into stages with completion criteria. It activates for questions about the current stage, next steps, or whether a stage is done. CX Codex +1 ★ 741repo stars codex-agents The codex-agents Claude Code skill brings Codex CLI in as a second agent for implementation and independent review. It responds to requests to consult Codex and to decisions with competing options. CX Codex +1 ★ 741repo stars independent-review The independent-review Claude Code skill runs an independent code review before a release and after fixes. The reviewer must start in a session that did not build the change. CX Codex +1 ★ 741repo stars work-humanizer work-humanizer is a Claude Code plugin that revises work writing with an AI-like tone while preserving its meaning. It can also interview the writer and shape a piece from their answers. ★ 741repo stars app-stack The app-stack Claude Code plugin guides SaaS development from idea to production with Next.js, Supabase, Clerk, and Netlify. Its skills cover product stages, authorization, UI, analytics, and more. ★ 741repo stars agent-harness The agent-harness Claude Code plugin organizes agent instructions, hooks, and persistent work status. Its skills handle session handovers and turn session friction into setup changes. ★ 741repo stars agent-teams The agent-teams Claude Code plugin guides task delegation and lets coding agents act as peers, builders, or independent reviewers. Use it to brief a delegate or work with Codex CLI, Grok CLI, or headless Claude Code. ★ 741repo stars product This Claude Code plugin helps decide what to build before development starts. It turns idea research, hypotheses and key screens into a draft for the product owner to review. ★ 741repo stars

Project sponsors

Companies that keep this analytics open