A Claude Code plugin with skills for hand-drawn architecture diagrams, code and architecture review guides, frontend design-system references, team knowledge wiki capture, and screen specification documents from PRDs.
Auto-invoked ships a router so the right skill fires automatically as you prompt. No remembering which skill to call.
Normal is the plain upstream plugin, installed as-is. You invoke its skills yourself.
Claude Code
The plugin> /plugin marketplace add wigtn/wigtn-plugins> /plugin install wigtn-plugins@wigtn-pluginsAuto-invocation> /plugin marketplace add flowy-sh/flowy-core> /plugin install flowy-core> /plugin install flowy-wigtn-plugins
Codex
$ npx skills add wigtn/wigtn-plugins -a codex
Cursor
$ npx skills add wigtn/wigtn-plugins -a cursor
Gemini CLI
$ npx skills add wigtn/wigtn-plugins -a gemini-cli
GitHub Copilot
$ copilot plugin marketplace add wigtn/wigtn-plugins$ copilot plugin install wigtn-plugins@wigtn-plugins
OpenCode
$ npx skills add wigtn/wigtn-plugins -a opencode
Windsurf
$ npx skills add wigtn/wigtn-plugins -a windsurf
Without this plugin: You open Claude Code → write a vague prompt → get generic code → spend 30 min fixing → repeat.
With WIGTN Plugins:
You run /prd → get a structured contract → generate screen specifications when needed → implement → commit only after the configured checks pass.
WIGTN Plugins is a Claude Code plugin with 11 specialized agents for requirements, architecture, implementation, and review. It uses parallel work only where tasks are independent, and carries one contract from PRD through commit.
For WIGTN members it also keeps a team knowledge wiki: what you learn in WIGTN repos is collected and comes back as context in later work (details).
/prd "SaaS dashboard with OAuth" → Contract-based PRD + task plan
/screen-spec dashboard → (if UI) IA + flow + screen spec + clickable wireframe HTML
/implement --parallel → Backend + Frontend + AI + Ops teams build simultaneously
/auto-commit → Findings rollup + objective checks + commit
# Install
/plugin marketplace add wigtn/wigtn-plugins
/plugin install wigtn-plugins@wigtn-plugins
# Try it — this is the full workflow
/prd landing page for an AI startup with modern design
/implement ai-landing
/auto-commit
That's it. The plugin handles PRD generation, 4-category quality analysis, architecture decisions, design style selection, parallel build, code review, and commit.
┌─────────────────────────────────────────────────────────────────────────────┐
│ /prd "SaaS dashboard with OAuth" │
│ │
│ 1. Context Gathering ─── scan project structure, tech stack, package.json │
│ 2. AskUserQuestion ───── Scale Grade? (Hobby / Startup / Growth / Enterprise) │
│ 3. PRD Generation ────── PRD_{feature}.md (7 sections, Gherkin stories) │
│ 4. Task Planning ─────── PLAN_{feature}.md (phases + tasks) │
│ │
│ ┌─── prd-reviewer — 4 adversarial lenses ────────────────────────────┐ │
│ │ Phase 0: Context Harvest (CLAUDE.md, code patterns, deps) │ │
│ │ Phase 1: PRD Structure Parsing │ │
│ │ Phase 2: ═════════════ 4 ADVERSARIAL LENSES ══════════ │ │
│ │ │ Completeness │ Feasibility │ Security │ Consistency │ │ │
│ │ │ FR/NFR/edge │ stack fit │ OWASP │ naming/arch │ │ │
│ │ │ cases, dups │ blast radius│ auth/z │ PRD↔code │ │ │
│ │ Phase 3: Cross-Category Synthesis (compound risks) │ │
│ │ Phase 4: Quality Gate ─── PASS / WARN / BLOCKED │ │
│ └────────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────────────┘
│
BLOCKED → stop
│ PASS / WARN
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ /implement ai-landing │
│ │
│ ┌─── DESIGN PHASE ──────────────────────────────────────────────────┐ │
│ │ ═══════════════ 3 AGENTS IN PARALLEL ═══════════════ │ │
│ │ │ Agent A │ Agent B │ Agent C │ │ │
│ │ │ PRD load + │ architecture-decision│ Project scan + │ │ │
│ │ │ quality gate │ Mono/Modular/MSA │ gap analysis │ │ │
│ │ ══════════════════════════════════════════════════════════════ │ │
│ │ │ │ │
│ │ Team Allocation ─────── pattern match files → teams │ │
│ │ api/, services/ → Backend │ │
│ │ components/, app/ → Frontend │ │
│ │ ai/, llm/ → AI Server │ │
│ │ Dockerfile, CI/ → Ops │ │
│ │ │ │
│ │ Design Discovery (Frontend only, if no existing style) ──────── │ │
│ │ VS technique: 4 questions → suitability % per style → select │ │
│ │ │ │
│ │ ✋ CHECKPOINT: AskUserQuestion ── proceed / review / cancel │ │
│ └───────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─── BUILD PHASE ─── team-build-coordinator ────────────────────────┐ │
│ │ │ │
│ │ Phase 0: Setup ─── SHARED_CONTEXT_{feature}.md + PLAN ledger │ │
│ │ Context Harvest: sample existing code → learn patterns │ │
│ │ │ │
│ │ Phase 1: Foundation (if Backend + dependents exist) │ │
│ │ Backend writes: DB schema, shared types, API contracts │ │
│ │ ↓ unblocks other teams │ │
│ │ │ │
│ │ Phase 2: ════════════ UP TO 4 TEAMS IN PARALLEL ════════════ │ │
│ │ │ BACKEND │ FRONTEND │ AI SERVER │ OPS │ │
│ │ │ backend- │ frontend- │ ai-agent │ gen │ │
│ │ │ architect │ developer │ │ pur │ │
│ │ │ │ + style guide │ │ │ │
│ │ │ API, services │ pages, comps │ LLM, STT │ CI │ │
│ │ │ DB, middleware │ state, styling │ prompts │ CD │ │
│ │ ════════════════════════════════════════════════════ │ │
│ │ ▲ reads │ writes │ │
│ │ └──── SHARED_CONTEXT ────┘ │ │
│ │ │ │
│ │ Phase 3: Integration ─── API contract match, type consistency, │ │
│ │ pattern verification vs Phase 0 learned patterns │ │
│ │ │ │
│ │ Phase 4: Build & Test ─── typecheck + test + build │ │
│ └───────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ /auto-commit │
│ │
│ Step 1: Branch Strategy │
│ on feature branch → reuse │ on main + PLAN → feat/<name> │
│ │
│ Step 2: Quality Gate │
│ ┌─── code-reviewer — evidence-backed findings ───────────────────┐ │
│ │ Each finding: file + line + severity + confidence + evidence │ │
│ │ │ │
│ │ FAIL ← critical ≥1 │ │
│ │ WARN ← critical 0 AND (major ≥1 OR minor ≥5) │ │
│ │ PASS ← critical 0 AND major 0 AND minor <5 │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ Step 3: Objective Checks ─── typecheck / lint / configured checks │
│ non-zero exit → blocked │
│ Step 4: Commit Message ─── <type>(<scope>): <subject> + gate result │
│ ✋ CHECKPOINT: AskUserQuestion ── PR / Draft PR / Commit only / Cancel │
│ Step 5: git commit → git push -u → gh pr create │
└─────────────────────────────────────────────────────────────────────────────┘
Shared Memory (3 layers):
Layer 1 — MEMORY.md ─────────── persistent cross-session conventions
Layer 2 — SHARED_CONTEXT ────── session-scoped API contracts, types, patterns
Layer 3 — PLAN ledger ───────── task checkboxes + execution log
Independent steps can run in parallel; dependent steps remain ordered. Runtime varies with the task, model, and configured checks.
| Command | What it does |
|---|---|
/prd <feature> | Generate PRD + phased task plan from a feature idea (now includes User Roles, Page State Matrix, User Flow sections for UI features) |
/screen-spec <feature> | Optional UI gate: IA + User Flow + Screen Spec + clickable HTML wireframe + Dev Handoff. Lo-fi wireframe (grayscale + semantic colors); style is decided later at /implement |
/implement <feature> | Design + build with automatic parallel team dispatch (consumes screen-spec output if present) |
/auto-commit | Evidence-backed findings → deterministic rollup → objective checks → commit + PR |
/review-pr <PR> | Review a GitHub PR from terminal: diff analysis, severity findings, inline comments |
For WIGTN members. The plugin collects nothing outside github.com/wigtn/ repos unless you configure a wiki yourself.
| When | What happens |
|---|---|
| End of each response | The session is rewritten as a short note on what was learned (not what was done), screened by a four-step gate for secrets, personal data, and client identifiers, then pushed to per-user/<you>/ in wigtn/wigtn-team-wiki (private) |
Stars on GitHub
A development methodology for coding agents that makes the agent brainstorm before building, follow plans, run parallel work and finish branches in a disciplined way. You get fewer skipped steps and more consistent results from your coding assistant.
@obraHelps you take a change from a rough idea or bug report through to a tested, reviewed result, with each step handled by a focused skill. Its skills cover pinning down domain terms, designing module interfaces, diagnosing hard bugs, and reviewing changes against your repo's coding standards.
@mattpocockGives your coding agent a planning, testing and review routine to follow on every task. It plans before building, checks changes with tests, has a fresh reviewer look for regressions, and saves repeated wins as reusable skills.
@affaan-mDeveloper tools for working on the React codebase itself. Provides skills for extracting error messages, managing and debugging feature flags across release channels, running Flow type checks, and fixing lint and formatting issues before committing.
@facebookInstall it once and the right skill fires as you prompt, with no slash command to remember. It is listed on Flowy in the Development category. It includes architecture-diagram, code-review-levels, design-system-reference. Free and open source.
Is this plugin yours?
Claim it with GitHubSubmit a pluginPromote it