wigtn-plugins

English | 한국어 | 中文

WIGTN Plugins

One plugin. 11 agents. From idea to a verified commit.

---

Why WIGTN-Coding?

Without this plugin: You open Claude Code → write a vague prompt → get generic code → spend 30 min fixing → repeat.

With WIGTN-Coding: You run /prd → get a structured contract → generate screen specifications when needed → implement → commit only after the configured checks pass.

---

What it does

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.

/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

---

Quick Start

# Install
/plugin marketplace add wigtn/wigtn-plugins
/install 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.

---

The Pipeline

┌─────────────────────────────────────────────────────────────────────────────┐
│  /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.

---

Commands

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

---

Coordinators

Agent	Role
team-build-coordinator	Dispatches Backend, Frontend, AI, Ops teams in parallel
architecture-decision	MSA vs Monolithic vs Modular Monolith

Developers

Agent	Role
frontend-developer	React 19, Next.js 16+, 20 design styles
backend-architect	API design, database schema, backend patterns
mobile-developer	React Native / Expo, native modules
ai-agent	WhisperX STT, OpenAI/Anthropic integration

Quality

Agent	Role
code-reviewer	Evidence-backed findings with deterministic PASS/WARN/FAIL rollup
pr-reviewer	GitHub PR diff review, severity findings, inline review comments (used by /review-pr)
prd-reviewer	Finds gaps across completeness, feasibility, security, consistency
code-formatter	Multi-language auto-formatting and lint fixes
design-discovery	VS-based style recommendation for Web and Mobile