- name
SKILL.md
Файл навыка остаётся в репозитории издателя.
Вставьте скопированную команду в терминал. Она установит этот SKILL.md в выбранного агента.
npx skills add phuryn/product-engineering --skill ship-check -a cursor -yВставьте скопированную команду в терминал. Она установит этот SKILL.md в выбранного агента.
npx skills add phuryn/product-engineering --skill ship-check -a claude-code -yВставьте скопированную команду в терминал. Она установит этот SKILL.md в выбранного агента.
npx skills add phuryn/product-engineering --skill ship-check -a codex -yВставьте скопированную команду в терминал. Она установит этот SKILL.md в выбранного агента.
npx skills add phuryn/product-engineering --skill ship-check -a grok -yОтправьте скопированное сообщение в чат Grok Bot. Бот загрузит этот SKILL.md с GitHub и добавит его к навыкам, общим для всех ваших ботов.
Install this skill: https://github.com/phuryn/product-engineering/tree/HEAD/ai-shipping/skills/ship-checkОт издателя
Run the full shipping sequence and compile a packet for human sign-off. The question is "is it safe to ship?" The shipping packet brings the results together into one reviewer-ready artifact.
Run this pass only when the user starts it. It writes docs, edits agent instructions and spends a long session. It coordinates the specialist skills rather than replacing them; each also runs on its own when asked.
/ai-shipping:ship-check Claude Code, plugin installed
/ai-shipping:ship-check the payments service
$ai-shipping:ship-check supabase/functions Codex, plugin installed
/ship-check · $ship-check the skill folder copied into a repository
Run the steps in order on the requested scope. Accept a path or area, or use the whole repository if none was given. Each audit needs documented intent to compare against the code, so each step builds on the last.
First, fetch, and bring the checkout up to date before anything is written. Every step documents or audits this checkout; an older one is code that is no longer the product. Run git fetch; a failed fetch stops the pass. Then list what the remote has that the checkout lacks:
git log --oneline 'HEAD..@{u}'.git log --oneline HEAD..origin/HEAD. If that ref is missing, git remote set-head origin --auto sets it. A repository with no remote has nothing there.git log --oneline HEAD..<last release>. Step 6 defines the last release.If the upstream lists commits, use git pull --ff-only only with a clean tree and no local commits (git log --oneline '@{u}..HEAD' empty). If the release still lists commits afterward, use git merge --ff-only <last release> only with a clean tree and an empty git log --oneline <last release>..HEAD.
Where a ref still lists commits, stop and tell the owner which ref is newer. This includes commits on origin/HEAD with no upstream. Where none does, go on.
Identify records this pass must not overwrite unasked across the whole repository. The pass writes from code: missing or stale system docs (step 1), agent instructions (step 2) and the coverage map (step 7). Two kinds of record need the owner's choice:
Look across the whole repository, whatever the requested scope. Follow the shipping-artifacts skill's Locations and names rule to find docs and the coverage map. A path limits which code is read, not where records live; steps 1 and 7 write to those places.
If either record exists, list the files this pass would overwrite and ask the owner which to run:
document-app and derive-tests with check, as the release-gate skill does at a release. They write nothing and list where docs, the map and code disagree. Report what they list and stop there; which side moves is the owner's decision.If neither exists, go on to step 1 without asking.
Ensure system docs exist and are current before the audits. Apply the document-app skill if they are missing or stale. Apply the shipping-artifacts skill, including its Locations and names rule: use the repo's own docs setup first, defaults only where it has none. Include the core set (architecture, flows, permissions, variables) and applicable conditional docs (emails, cron, seo, automation). These docs are the intended-state baseline for everything that follows.
Derive the repo's agent instructions from its system docs. Create or refresh the operating instructions the next AI coding agent inherits. State what the system is, its trust boundaries, what may and may not be touched, and where guardrails are. These are instructions, a different artifact from the system docs' description.
Follow the repo's existing instruction-file structure. If one file only imports or points to the other, edit the target and leave the pointer alone. For example, a CLAUDE.md containing just @AGENTS.md points to the file to edit. If only one of CLAUDE.md and AGENTS.md exists, edit that one. Only when neither exists, create CLAUDE.md and a thin AGENTS.md pointing to it.
Apply the code-review skill with dimensions=correctness, using its forced probes. Reading through misses logic and state defects that compile, pass the suite and violate an agreement between two reasonable-looking places. This pass covers what the other two audits do not.
Run authority reconciliation: a requested value still drives state where the authority returned something different. Run identity correlation: results join to their originating entity by an unstable key. Strong agents miss these classes at the look, not the fix.
Fan out over flows, never over files. Summarize surviving findings.
Run security and performance audits in parallel once the docs exist. They are independent then. Use parallel subagents where the agent has them, and continue when both return.
security-audit-static, with intended-vs-implemented to flag code diverging from permissions.md, flows.md and architecture.md. Summarize surviving findings. Carry through its reported model mix: which clusters ran on the strongest model and which Fable's classifiers rerouted to an Opus model, and which.performance-audit-static: N+1 queries and waterfalls, over-fetching, missing indexes and caching. Summarize findings.Hand the subject to a fresh session that never saw the build. The earlier passes are steered by their checklists and share blind spots across reruns. This independent backstop is the highest-yield step on a real release.
Use the repo's named reviewer only when it meets every review requirement. Every reviewer must have:
Replace a named reviewer that cannot meet these requirements with the repo's recorded fallback when that one can, without asking. If none can, run the wrapper's reviewer without asking. If no other family can run, use a fresh session of the builder's family. Never use the building session, and never skip review.
Record the actual reviewer in the packet's Independent Review section. Say why it replaced the named one and what it couldn't switch off, which the wrapper prints.
Use the carried review wrapper when the repo names no reviewer. This skill carries the independent-review skill's wrapper as scripts/review.py so it works on its own:
python <skill dir>/scripts/review.py --brief <scratch>/brief.md --cwd <repo> --subject <range> --out <scratch>/round-N.md < /dev/null
For Codex, --out also keeps <out>.events.jsonl; treat it like the report and never commit it. Keep the brief, report and any events file outside the repository; one left in the checkout enters the next round's subject. When the wrapper warns about untracked files, keep every file that belongs to the change, step 2's edits included, and step 1's docs as context. For the rest, delete only what this session generated; otherwise gitignore it or ask the owner. Exit 2 means a failed round: a short report, missing Codex evidence or a Codex tool-isolation failure. The wrapper runs Grok when its CLI is installed, giving another model family. Without Grok it runs a fresh Codex session, and without Codex fresh headless Claude Code, each with nothing carried over. Either may be the builder's own family; a fresh session is still independent, because it never saw the build. Apply independent-review for what each run switches off and what still loads.
Define the subject mechanically, not in prose. Fetch, then diff against the last release plus the working tree. For example, run git fetch, then git log --oneline <last release>..HEAD and git status --porcelain -uall. Before any release, use the whole history. A described subject drifts; a computed one does not.
Take the last release from what production serves. Use what the release doc, a tag or the production branch says production serves. On release-gate's branches, that is origin/<product>-prod. Never use a branch that only deploys development, nor, before go-live, the product branch the host deploys (release-gate). Where nothing says, ask the owner. Never infer that nothing is live from a missing tag.
Use <last release>..HEAD, or HEAD before any release. The first release ships the whole history. For HEAD, the wrapper writes each commit's author and message, every file HEAD holds and every line its history removed.
A tag or branch inherited from history begun in another repository belongs to that repository, never the product's last release. This includes clones and forks whose first commit is not the product's. Check it with git log --max-parents=0 --format='%h %an %s'.
Treat step 1's docs as context and step 2's instruction edits as changes. This holds whether or not those docs are committed. Agent instructions decide what the next agent may touch.
When the range and working tree hold nothing, or only those two steps' files, use the whole history too. Review released code plus step 2's edits, leaving those edits uncommitted until the round has run. For HEAD, the wrapper shows every file HEAD holds as it stands; a committed edit to one does not show as a change. If those edits are already committed, run both:
HEAD round for released code.<last release>..HEAD reviewing those commits as changes.The brief states the product, its users and what the reviewer must find. Ask what would block or break this change. Require each finding to be labelled INTRODUCED or PRE-EXISTING, with the sequence that triggers it.
Name the docs step 1 wrote, for reading as claims about code, not as the change. A claim the code contradicts is an INTRODUCED finding because later steps rely on it. Every other subject change, committed or not, is the change.
When reviewing released code, say it is already live: findings in it are PRE-EXISTING. Findings in step 2's agent-instruction edits are INTRODUCED and block like any other. Before any release, say nothing is live yet, so every code finding is INTRODUCED.
Use --subject-only when none of the three CLIs is available. The wrapper still writes the subject file and prompt and prints their paths. Give the prompt, and nothing else, to a fresh read-only session of your agent. Run it as a separate process in the checkout under review, never a subagent, fork or resumed session of this one. Require read-only tools, no MCP servers or connectors and its highest available reasoning effort. Turn off memory and project and personal instructions where it allows.
If no fresh session can start, stop and hand the owner the prompt. The packet waits until the round has run. Treat a short clean answer as a failed round, and delete both files when the round ends.
Keep every round fresh, unprimed and mechanically scoped. A same-model reviewer shares more builder blind spots, and a round that runs still beats one skipped. Three rules apply either way:
Verify every finding against the code by hand before it enters the packet. Unsteered reviewers can report confident findings that the code already prevents. Apply the code-review skill's keep/drop rule. A finding survives only with a supported obligation, feasible execution, concrete contradiction, observable consequence and a counterargument you actually checked.
Distinguish defects the change introduced from those it merely revealed. Both belong in the packet. Only introduced defects block the change itself, except High or Critical findings, which block regardless of age and go in Launch Blockers. On a release pass, repeat until a round surfaces no introduced findings above Low and no High or Critical of any age remains open.
Apply derive-tests after the reviews to map rules and newly found gaps. The coverage map (tests.md) states which documented rules have tests today, which are only proposed, which are guarded-live or manual, and which have no verification. Each confirmed finding becomes a concrete regression test to pin so the gap cannot silently reopen on the next AI edit. This makes "documented == implemented" operational. Unverified boundary rules feed the launch-blocker assessment below.
Compile every stage's results into the shipping packet.
## Shipping Packet: [repo / area]
### Documentation Inventory
| Doc | Path (repo's own or plugin default) | Status (present / stale / missing / n/a) | Notes |
### Agent Context
Agent instructions: [path edited — the file the repo's structure makes canonical, or `CLAUDE.md` + a thin `AGENTS.md` where it had neither] · [created / updated / already current]
### Test Coverage
[Rules pinned by tests that exist today · proposed but not yet written · guarded-live/manual · and the documented rules nothing verifies yet]
### Correctness Summary
[Surviving findings, each: Expectation · Trigger · Defect · Impact · Remedy, citing every participant]
### Security Summary
[Counts by severity + the surviving findings, each: Risk · Attack · Impact · Fix]
### Performance Summary
[Findings by view/route/table, each: Recommendation · Effort · Priority]
### Independent Review
[Which model and session ran it, how the subject was computed, how many findings it returned, how many survived hand-verification — and the ones that survived. Note whether the last round was clean.]
### Audit Provenance
[Which model each audit actually ran on, any clusters Fable's classifiers rerouted to an Opus model, and which, and the reviewer used in Step 6 (another model family, or a fresh session of the same one) — so the reviewer knows how much of the work saw the strongest model vs. the fallback, and how independent the unsteered pass was]
### Launch Blockers
[Unresolved Critical/High items — including any boundary rule that is both unverified and unaudited — that should stop a ship]
### Recommended Next Actions
[Concrete owner actions or commands to run next]
document-app, derive-tests, code-review, security-audit-static and performance-audit-static.Every packet section is filled or marked "not run" with its reason; Independent Review is always filled, and each finding cites a file and line. Launch Blockers is empty or names what stops the ship.
Is this safe to ship? Documents the app, wires the agent's context, runs the correctness, security and performance reviews and an independent unsteered pass, maps test coverage, and compiles one revie
---name: ship-checkdescription: Is this safe to ship? Documents the app, wires the agent's context, runs the correctness, security and…---# ai-shipping/skills/ship-check/SKILL.mdОбзор
Is this safe to ship? Documents the app, wires the agent's context, runs the correctness, security and performance reviews and an independent unsteered pass, maps test coverage, and compiles one reviewer-ready shipping packet. Started by name only: /ai-shipping:ship-check in Claude Code, $ai-shipping:ship-check in Codex.
FAQ
Скачайте ai-shipping/skills/ship-check/SKILL.md у издателя или скопируйте путь и откройте репозиторий. PlugMCP только показывает навык в каталоге и не хранит файл.
Издатель хранит его в https://github.com/phuryn/product-engineering.
Claude, Cursor, Codex и Grok Build могут читать SKILL.md, который вы добавляете из репозитория издателя. Grok Bot устанавливает его, когда вы отправляете в чат ссылку на папку навыка на GitHub.