By iampawan
PRD-to-production pipeline with quality gates. Author contracts, run critics, implement via agent, verify deploys, and produce post-launch reports — all from markdown in your repo.
Pick up, fix, and promote Manifest contracts. Run with no args (or `help`) to get a quick tutorial. Subcommands: pickup (canonical Spec entry), fix, promote, decompose, diagram, migrate, archive. `new` and `verify` exist for backward compatibility and power-user re-checks respectively.
Review a PR diff for code-level defects (security, correctness, performance, maintainability) and post a severity-tagged review comment. Complements /verify-pr's AC-conformance check.
Manually run bug triage for a contract — scan Sentry, support tickets, and app store reviews for new bug clusters, dedupe against existing JIRA tickets, file new ones. Normally fires automatically via the daily launch-monitor cron, but invoke this when you want an ad-hoc check.
Show where a feature is in its canary ramp and the next recommended step. Reads the latest rollback-guard health verdict and the rolloutPlan. Recommends the next flag change for a human to make — never flips the flag itself.
Express lane for trivial bugs and tiny changes — skips the full contract ceremony. Use for one-line fixes, copy/CSS tweaks, config changes, dependency bumps. Triages size and escalates to /contract if the change turns out bigger than trivial.
Scan Sentry, support tickets, and app store reviews for new bug clusters; deduplicate against existing tickets; file to JIRA with contract back-references; then route each new cluster back into the pipeline (trivial→/fix, substantial→/contract) with propose-by-default guardrails. Invoked nightly by launch-monitor.yml as part of the 4-week monitoring window.
Review a PR diff for code-level defects — security, correctness, performance, and maintainability — and post a severity-tagged review comment. Runs at the PR stage AFTER implementation, complementing verify-pr (which checks contract/AC conformance). Invoked by /code-review or the pr-verify.yml workflow. Stack-agnostic.
Turn a Large contract into a dependency-ordered sequence of Small/Medium child contracts, with risky parts (migrations, auth) flagged as human-led. Use when a contract is sized Large and the user says "decompose", "break this down", "split this epic", or invokes `/contract decompose <ID>`. Large isn't refused — it's made tractable.
Author a new Manifest contract from a rough idea, a one-liner, OR a link to an existing source of truth — JIRA ticket, Linear issue, Notion page, Confluence doc, GitHub issue, or Figma file. Use when the user says "new contract", "draft PRD", "spec out a feature", "pull contract from this JIRA ticket", or invokes `/contract new` with either prose or a URL. Pre-fills as much of the contract as possible from the source, then asks the user only what's still missing.
The canonical Spec entry for Manifest. Dev gives any source — JIRA / Linear / Notion / Confluence / Google Doc / Slack message / GitHub issue / Figma URL, pasted text, an image, or a free-form description — and the agent does the code archaeology, drafts the contract, runs the critics inline, and sorts every gap into three buckets (auto-fill from code, dev decides, PM must answer). PM stays in their normal tool (JIRA comment, Slack DM); they never have to touch Manifest. Use when the user says "pick up this PRD", "start on this ticket", "spec out this feature", "I got a doc from PM", or invokes `/contract pickup <source>` / `/pickup <source>`. Replaces the older `/contract new` → `/contract verify` two-step flow with a single conversational pass.
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
A Claude Code / Cowork plugin that takes a PRD ("contract") through the full lifecycle — spec → implement → ship → land — with quality gates that won't let an under-specified spec progress.
The contract lives as markdown in your repo at .manifest/contracts/*.md.
Critics produce findings as adjacent files. Reports are committed alongside.
Git is your audit trail; no external database required.
For the full walkthrough — mental model, day-by-day flow, recovery playbooks — read GUIDE.md.
New in 0.18 — dev-led Spec flow. Most PMs write PRDs in JIRA, Google Docs, Slack, or Notion and hand them off; the dev does the homework to make the spec build-ready.
/contract pickup <source>is the entry point for that case — paste any source and the agent does the code archaeology, runs the critics, and presents every gap in three buckets (auto-fill from code, dev decides, only PM can answer). Questions for the PM go out as one batched JIRA comment / Slack DM in the dev's voice — PM never has to touch Manifest. See skills/contract-pickup/SKILL.md and ROADMAP.md. Enable per repo viapickup.enabled: trueinrepos.yml.
Manifest scales the ceremony to the change. Four tiers:
| Change | Path | Process |
|---|---|---|
| Typo, single CSS value, config flip | just edit + commit | none |
| One-line bug, copy tweak, dep bump | /fix (express lane) | triage → fix + regression test → PR; minutes |
| New behavior, 1 platform, ≤3 behaviors | /contract pickup → Small | full pipeline, 24h SLA |
| ≤2 platforms, ≤8 behaviors, additive schema | /contract pickup → Medium | full pipeline, 72h SLA |
| Breaking change, migration, auth/billing | /contract decompose → epic | broken into Small/Medium children; migrations human-led |
/contract pickup <source-or-description> is the canonical Spec
entry — it accepts a JIRA / Linear / Notion / Google Doc / Slack URL,
a Figma file, pasted text, an image, or a free-form description. The
agent fetches whatever you give it, drafts a contract, runs the
critics inline, and walks you through the gaps. There's no separate
"author" step.
| Stage | What runs | Output |
|---|---|---|
| Spec | /contract pickup <source-or-description> — fetches the PRD (JIRA / Linear / Notion / Google Doc / Slack / paste / image), runs the validator + relevant judgment critics inline, sorts every gap into 3 buckets (auto-fill from code, dev decides, only PM can answer), drafts batched questions back to the PM in their own tool | .manifest/contracts/<ID>.md + .findings.{md,json} + .qa.md sidecar |
| Promote | /contract promote | Frozen revision, JIRA epic, SLA timer (24h/72h) |
| Implement | /implement <ID> (PR comment, runs in CI) | PR with code + tests in the repo's stack |
| Verify PR | pr-verify.yml → verify-pr (AC conformance) + code-review (code-level defects) | coverage comment + CR- findings; open blockers gate merge |
| Review→fix | @claude /fix-pr <ID> (Implementer fix-mode) | findings addressed + re-pushed, bounded by maxFixIterations |
| Verify deploy | verify-deploy.yml (platform-aware: web/Flutter/backend) | per-AC pass/fail + canary verdict |
| Canary guard | rollback-guard.yml (every 30 min) + /canary, /rollback-check | proceed / hold / recommend-rollback + next ramp step (recommends only) |
| Launch report | launch-monitor.yml (cron, 4 weeks) | Slack DM at day 1/7/14/28 |
| Bug watch + route | bug-triage (daily) | tickets with contract refs, routed to /fix or /contract (gated) |
| Rollback | /postmortem <ID> (after a revert) | landed: rolled-back, blameless postmortem, reopened follow-up |
Anytime: /status [<ID>] shows phase, SLA time-left (IST + UTC),
readiness, and next action — for one contract or everything in flight.
The deterministic validator classifies each verified contract as
Small (24h), Medium (72h), or Large. Small and Medium use
the automated pipeline. Large is decomposed (via /contract decompose) into a dependency-ordered sequence of Small/Medium child
contracts — Manifest doesn't refuse Large, it makes it tractable. The
truly tiny stuff goes through the /fix express lane (no contract at
all). See "Pick the right path" in /manifest or GUIDE section 1b.
Verification runs in two layers, not one pile of LLM prompts:
npx claudepluginhub iampawan/manifest --plugin manifestComprehensive skill pack with 66 specialized skills for full-stack developers: 12 language experts (Python, TypeScript, Go, Rust, C++, Swift, Kotlin, C#, PHP, Java, SQL, JavaScript), 10 backend frameworks, 6 frontend/mobile, plus infrastructure, DevOps, security, and testing. Features progressive disclosure architecture for 50% faster loading.
v9.44.1 — Patch release for Gemini environment/version detection and qwen auth gating. Run /octo:setup.
Develop, test, build, and deploy Godot 4.x games with Claude Code. Includes GdUnit4 testing, web/desktop exports, CI/CD pipelines, and deployment to Vercel/GitHub Pages/itch.io.
Comprehensive PR review agents specializing in comments, tests, error handling, type design, code quality, and code simplification
Comprehensive feature development workflow with specialized agents for codebase exploration, architecture design, and quality review
A growing collection of Claude-compatible academic workflow bundles. Covers scientific figures, manuscript writing and polishing, reviewer assessment, citation retrieval, data availability, paper reading, literature search, response letters, paper-to-PPTX conversion, and evidence-grounded Chinese invention patent drafting. Rules are organized as reusable skill folders with explicit workflows and quality checks.