easyplatform

[Architecture] Use when designing solution architecture across backend, frontend, data & consistency, integration & APIs, deployment, monitoring, testing, and code quality. Architecture laws, style-selection triggers, coupling taxonomy, trade-off tables and the anti-pattern catalog live in `.claude/docs/architecture-knowledge.md`.

[Code Quality] Use when reviewing architecture compliance for layers, messaging, service boundaries, CQRS, repos, entity events, and data/consistency/tenancy boundaries. Universal architecture laws, coupling taxonomy and the anti-pattern catalog live in `.claude/docs/architecture-knowledge.md` (project docs always outrank it).

[Architecture] Use when auditing the ENTIRE project architecture and production readiness in one pass — bundles architecture-review + architecture-scalability-review + production-readiness-review at project or diff scope, then synthesizes one consolidated Architecture Health Report.

[Architecture] Use when grading project architecture and scalability quality for greenfield init or brownfield audit: build/CI scalability, distributed-monolith risk, module isolation, dependency discipline, loose coupling, horizontal scaling, DRY, abstraction, clean architecture, observability, and delivery.

[Code Quality] Use when you need to review artifact quality (PBI, user story, test spec, design spec) before handoff. Supports --type={pbi|story|spec-tests|design}.

[Utilities] Use when you need to answer technical and architectural questions.

[Content] Use when you need to brainstorm as a PO/BA — structured ideation for problem-solving, new product creation, or feature enhancement.

[Git] Use when the user asks to compare branches, analyze git diffs, review changes between branches, update specifications based on code changes, or analyze what changed.

[Project Management] Use when creating user stories, writing acceptance criteria, analyzing requirements, or mapping business processes.

[Content] Use when you need to evaluate business idea viability: Business Model Canvas, financial projections, risk matrix, go-to-market, execution plan.

[Documentation] Use when you need to generate or update changelog entries.

[Code Quality] Use when reviewing current changes, staged or unstaged diffs, or branch-to-branch diffs.

[Code Quality] Use when you need to combine /changes-review + /fix in a recursive loop — each round runs /changes-review (report-only) to surface validated findings over a fixed diff scope, then /fix to resolve them, then loops again with a FRESH full /changes-review over the CHANGED diff until one complete pass produces zero validated findings (nothing left to fix).

[Utilities] Use when you need to save analysis context to a checkpoint file for recovery (user-facing alias for memory-management Part 1 CHECKPOINT_CREATE).

[Utilities] Use when you need claudeKit usage guide - just type naturally.

[Utilities] Use when you need Claude Code CLI setup, configuration, troubleshooting, and feature guidance.

[Documentation] Use when you need initialize, update, or refactor CLAUDE markdown from project-config JSON and codebase scan results.

[Code Quality] Use when evaluating review feedback, requesting targeted code-quality review, or verifying completion claims.

[Code Quality] Use when you need to simplify and refine code for clarity, consistency, and maintainability while preserving all functionality.

[Utilities] Use when you need to set coding experience level for tailored explanations.

[Git] Use when asked to "commit", "stage and commit", "save changes", or after completing implementation tasks. Flag: --push (a.k.a. "commit and push") stages + commits + pushes to remote in one shot.

[Utilities] Use when you need to compress context to optimize token usage (user-facing alias for context-optimization Strategy #3 Compress).

[Utilities] Use when you need to load project context for current session.

[Utilities] Use when managing context window usage, compressing long sessions, or optimizing token usage.

[Content] Use when you need to create high-converting copy for marketing materials, social media, landing pages, email campaigns, and product descriptions.

[Content] Use when you need to build structured learning/teaching course material with Bloom taxonomy objectives, modules, lessons, exercises, and assessments.

[AI & Tools] Use when you need create, verify, or enhance Claude Code custom agents (Claude Code custom agent files).

[Utilities] Use when the user invokes, lists, saves, updates, or deletes a PROJECT-SPECIFIC saved prompt — a named, reusable procedure stored with the project rather than in the portable framework. `/custom-prompt list` prints every defined prompt with its description; `/custom-prompt <free-text request>` matches the request to the closest saved prompt and executes it only after a confirmation gate; `/custom-prompt save|update|delete ...` maintains the registry — save never stores raw wording, it drafts the best version of the prompt and confirms the name, description, inferred goal, and steps with the user first. Triggers: custom prompt, custom prompts, list custom prompts, save this prompt, save this prompt task, update this prompt, my saved prompt, project prompt, playbook, recipe, runbook.

[DevOps] Use when you need to run or create database migrations.

[Fix & Debug] Use when investigating a bug's root cause — reproduce the symptom, trace it end-to-start through the code, form and test hypotheses, and pinpoint the defect before any fix.

[Research] Use when deeply researching top sources from web-research.

[Documentation] Use when you need to generate a step-by-step demo guide (demo script / walkthrough) covering all main user stories and their test cases — scope from a named feature, else the current working context, else confirm with the user — explaining for each case how the domain data is stored/changed and how the domain solves the feature. Triggers: demo guide, generate demo guide, demo script, demo walkthrough, how to demo, prepare demo, sprint demo, user story demo.

[Project Management] Use when you need to map and visualize feature dependencies between modules, services, and work items.

[Design] Create or describe a UI design — quick (fast), immersive (good), or recreated/described from a screenshot or video, in a product-UI or marketing/creative lane. Dispatch via --mode={fast|good|describe|screenshot|video} (default fast) and --lane={product|marketing} (default product).

[Project Management] Use when you need to create UI/UX design specifications from requirements, PBIs, or user stories. Use --mode=wireframe to convert hand-drawn/digital wireframes or UI sketches into structured specs.

[DevOps] Use when deploying to Cloudflare (Workers, R2, D1, KV, Pages), Docker, or GCP (Compute Engine, GKE, Cloud Run).

[Documentation] Use when you need to initialize project reference docs via hook + scan skills.

[Documentation] Use when finding technical documentation for libraries, frameworks, repositories, or implementation topics.

[Documentation] Use when updating impacted documentation after code, spec, or test changes.

[Code Quality] Use when the user asks to enhance documentation, add code comments, create API docs, improve technical documentation, document code, or update README files.

[Document Processing] Use when you need to convert Microsoft Word ( DOCX) files to Markdown with GFM support (tables, images, code blocks).

[Architecture] Use when you need to analyze business domain: bounded contexts, aggregates, entities, ERD, domain events, and cross-context integration.

[DDD Quality] Use when you need to review domain entities and value objects for DDD design quality.

[Code Quality] Use when you need to validate a PBI against Definition of Ready before grooming.

[User-Invoked] Use ONLY when the user explicitly types /dual-ai or /dual-ai <workflow-id> — fans out one prompt, or one workflow invocation per tool, to two fresh parallel AI sessions (Claude Code + Codex CLI), both pre-set to xhigh reasoning effort and full-permission mode before the prompt executes. NEVER auto-activate.

[Testing] Use when generating, updating, or maintaining E2E tests from recordings, specs, or code changes.

[Planning] Use when calibrating estimates from actual code, diff, PR scope, and developer time.

[Utilities] Use when the user wants to visualize workflows, architectures, or concepts as Excalidraw diagram JSON files.

[Implementation] Use when you need to implement a feature [step by step].

[Documentation] Use when you need to synthesize all generated specs, PBIs, ideas and mockups into one standalone HTML slide presentation for stakeholders (PO/BA/Dev/QC).

[Frontend] Use when you need to extract design context from Figma URLs via MCP, REST API, or screenshot fallback.

[Implementation] Use when you need to analyze and fix issues [INTELLIGENT ROUTING]. Flag: --target={ci|issue|logs|test|types|ui} scopes the fix; --target=types resolves TypeScript errors inline.

[Git] Use when you need to resolve git merge/cherry-pick/rebase conflicts with backup, analysis, and reporting.

[Git] Use when generating developer KPI, performance, contribution value, story point, man-day, or code-quality reports from local git commit history.

[Git] Use when you need ⚠️ Merge code from one branch to another.

[Code Intelligence] Use when you need to analyze the blast radius of current code changes using the structural knowledge graph.

[Code Intelligence] Use when you need to build, update, or sync the code review knowledge graph. Flag: --scope={full|update|sync} (default auto-detect); --scope=full forces a full rebuild, --scope=update re-parses uncommitted working-tree changes, --scope=sync syncs committed git changes then updates the working tree.

[Code Intelligence] Use when you need to detect frontend-to-backend API connections using the knowledge graph.

[Code Intelligence] Use when you need to export the code review knowledge graph. Flag: --format={json|mermaid} (default json); --format=json dumps the full graph to a JSON file, --format=mermaid renders a single file as a Mermaid flowchart diagram.

[Code Intelligence] Use when you need to query code relationships and connections using the structural knowledge graph.

[Code Intelligence] Use when investigating what happens when code executes, understanding blast radius, or tracing frontend-to-backend flows.

[Planning] Use when you need to start a new project from scratch with full waterfall inception — idea, research, domain modeling, tech stack, and implementation plan.

[Quality] Use when setting up an agent quality harness with feedforward guides and feedback sensors.

[Project Management] Use when capturing new ideas, feature requests, or concepts for future refinement.

[Testing] Use when you need to generate or review integration tests.

[Code Quality] Use when you need to review integration tests for assertion quality, bug protection, repeatability, and test-spec traceability — AND verify the review target (changed production code) has test coverage (integration-first) with spec↔test↔code alignment.

[Testing] Use when you need to verify integration tests pass after writing and reviewing them.

[Testing] Use when you need to drive an integration-test suite to fully green — each round runs /integration-test-verify (whole system by default, or the target named in the prompt), and on ANY failure combines /debug-investigate + /integration-test-review (report-only) to adjudicate the fault (test wrong · test not optimal · source wrong), then /fix to resolve it at the owning layer, then /changes-review on that round's fix diff, then re-runs a FRESH full verify — looping until the whole suite passes its 2-consecutive-green-runs gate with zero failures.

[Fix & Debug] Use when you need to investigate and explain how existing features or logic work. Flag: --mode=explain produces a one-way developer-narrative explanation (Purpose → How → Why → Impact) tuned by coding level; use /understand for the standalone prompt-driven explainer.

[Utilities] Use when recording an engineering journal entry — capture decisions, blockers, lessons, or progress notes during work.

[Research] Use when you need to review knowledge artifacts for completeness, citation quality, confidence accuracy, and template compliance.

[Research] Use when you need to synthesize research findings into structured report using template.

[Utilities] Use when you need to teach Claude lessons that persist across sessions.

[Code Quality] Use when you need to run linters and fix issues for backend or frontend.

[Quality] Use when you need to research and configure code quality tooling for any tech stack — linters, formatters, static analysis, pre-commit hooks, and CI gates.

[Decision Support] Use when pressure-testing irreversible, high-stakes decisions with adversarial AI advisors.

[Content] Use when you need background HTTP server rendering markdown files with calm, book-like reading experience.

[Document Processing] Use when you need to convert markdown files to Microsoft Word ( DOCX) format with GFM support and math rendering.

[Document Processing] Use when you need to convert markdown files to PDF with syntax highlighting and custom CSS support.

[Research] Use when you need to analyze market landscape: competitors, sizing (TAM/SAM/SOM), trends, SWOT, customer segments.

[Utilities] Use when saving or recovering task progress across sessions via file checkpoints — especially before context compaction.

[Code Quality] Use when the user asks to analyze package upgrades, check for outdated dependencies, plan npm/NuGet updates, or assess breaking changes in package updates.

[Code Quality] Use when you need an AI-assisted Dev BA PIC review of PBI drafts.

[Project Management] Use when you need to generate an HTML mockup report from PBI and story artifacts.

[Document Processing] Use when you need to convert PDF files to Markdown with support for native text PDFs and scanned documents (OCR).

[Debugging] Use when analyzing or optimizing performance bottlenecks: database queries, N+1 fan-out, indexing, API latency, memory/GC, concurrency and pool saturation, algorithmic complexity (O(n²)), network/protocol round trips, frontend rendering and Core Web Vitals, caching, and distributed/resilience paths. Calibration constants and domain laws (latency ladder, Little's Law, utilization knee, CWV thresholds, symptom→cause triage) live in references/performance-knowledge.md.

[Planning] Use when you need intelligent plan creation with prompt enhancement. Flag: --mode={ci|cro} (default none — standard planning); --mode=ci plans a fix from a GitHub Actions CI run/log, --mode=cro plans conversion-rate optimization (25-item CRO framework).

[Planning] Use when the user provides an implementation plan file and asks to analyze it, assess impact, update specifications, or verify planned changes.

[Implementation] Use when you need to start coding & testing an existing plan. Flags: --approval=off (auto/trust mode, no approval gate), --tests=off (skip the test step), --parallel={auto|on|off} (default off — sequential; --parallel/=on opts in to parallel sub-agent waves; =auto fans out only when the plan declares PAR/SEQ tags and write sets).

[Planning] Use when you need to auto-review a plan for validity, correctness, and best practices — recursive: review, validate findings with why-review, fix validated findings, full re-review until no findings.

[Planning] Use when you need to validate a plan with critical questions interview.

[Git] Use when you need to create pull request with standard format.

[Project Management] Use when you need to prioritize backlog items using RICE, MoSCoW, or Value-Effort frameworks.

[Utilities] Use when applying structured problem-solving frameworks to complex, blocked, recurring, or uncertain decisions.

[Project Management] Use when you need to capture ideas, manage product backlogs, apply prioritization frameworks (RICE, MoSCoW), and facilitate stakeholder communication.

[Code Quality] Use when reviewing service-layer and API changes for production readiness.

[Utilities] Use when you need to scan workspace and update docs/project-config JSON to match current project structure.

[Utilities] Use when initializing or re-evaluating portable project context: project-config, project-reference docs, CLAUDE.md, AGENTS.md, universal agent rules, hookless setup. Triggers on: project init, init project, missing project-config, missing project docs, missing CLAUDE.md, missing AGENTS.md.

[Project Management] Use when you need to generate project status reports, track dependencies, manage risk registers, and facilitate team sync meetings.

[Utilities] Use when a project needs to add, change, list, or remove its OWN protocol rules layered on top of a framework skill — a named overlay of extra project rules that applies whenever the targeted skill runs, stored with the project rather than in the portable framework. `/project-skill-protocol list` prints every overlay with its target and description; `add` drafts a new overlay and confirms it before writing; `update` applies a surgical change; `delete` removes it. Overlays are ADDITIVE ONLY — they never replace, override, or waive anything the skill already does. Triggers: skill protocol, project protocol, custom protocol for skill, extend a skill, overlay rules, add rules to a skill, project rules for skills, skill protocol overlay.

[Skill Management] Use when enhancing, compressing, or expanding prompts, docs, or skills with attention anchoring [INTELLIGENT ROUTING]. Flag: --op={compress|expand|enhance} (default enhance); --op=compress strips token bloat, --op=expand reconstructs compressed text.

[Code Quality] Use when you need to prove fix correctness with adversarial code proof traces — a skeptic tries to DISPROVE the fix and trace all related paths first, with confidence scoring and stack-trace-style evidence chains, so confidence is earned by surviving attack, not by confirming it works.

[Code Quality] Use when you need to run quality gate checklist.

[Project Management] Use when you need to enforce quality gates, verify compliance with standards, track quality metrics, and generate audit trails.

[Utilities] Use when you need to restore workflow context from checkpoint after session loss.

[Code Quality] Use when you need restructure code without changing behavior using extract method, extract class, rename, move, and inline patterns.

[Project Management] Use when converting ideas to PBIs, validating problem hypotheses, adding acceptance criteria, or refining requirements.

[Documentation] Use when you need to generate a detailed, AI-analyzed release document from git history over a time range or custom prompt.

[Git] Use when creating release notes from git history.

[User-Invoked] Use when you need create, update, or preview Remotion videos.

[Planning] Use when you need to research, analyze, and plan technical solutions that are scalable, secure, and maintainable.

[Architecture] Use when scaffolding reusable OOP/SOLID project foundations before feature implementation.

[Documentation] Use when scanning the codebase to (re)generate ONE project-reference doc. Parameterized by `--target=<key>`: project-structure | backend-patterns | frontend-patterns | scss-styling | design-system | code-review-rules | domain-entities | feature-spec | docs-index | e2e-tests | integration-tests | seed-test-data | ui-system. Shared 4-phase scan engine; per-target detail lives in references/targets.md. `ui-system` is an orchestrator meta-target (`kind: orchestrator`) that runs the 3 UI child scans in parallel instead of the 4-phase engine.

[Documentation] Use when you need orchestrate all reference doc scans in parallel.

[Documentation] Use when you need to detect codebase health issues: unused exports, doc count-drift, orphan files, stale config references.

[Investigation] Use when quickly locating relevant files and affected areas across a large codebase.

[Code Quality] Use when you need to perform a security review or audit on any scope — application code (OWASP Top 10 2025), secrets exposure, dependency/supply-chain malware, third-party repository vetting before install, infrastructure/config, CI/CD pipeline, AI-agent risks, and host/VPS compromise detection.

[Dev Data] Use when you need to implement or enhance test data seeders that simulate QC happy-path scenarios via application-layer commands. Flag: --mode=review reviews a target seeder (or the current changes / current work-context result) against every universal seed-data rule AND the project-specific seeder conventions — read-only, evidence-backed PASS/FAIL.

[AI & Tools] Use when you need to apply structured, reflective problem-solving for complex tasks requiring multi-step analysis, revision capability, and hypothesis verification.

[Skill Management] Use when creating a new Claude Code skill, adding reference files or scripts to an existing skill, scanning/fixing invalid skill headers, or optimizing/packaging skills. Triggers on: create skill, new skill, add skill reference, add skill script, fix skill, validate skill, package skill.

[Documentation] Use to author, audit, amend, or test-spec a business Feature Spec. The single spec skill — modes draft|init|update|audit|amend create/maintain the tech-free 8-section Feature Spec; draft authors a provisional spec from an idea/requirement (no code yet, Evidence: TBD); tests generates Section 8 TC-{FEATURE}-{NNN} test specifications; sync reconciles §8 TCs ↔ executing test code. Per-mode procedure lives in references/{author,tests,sync}.md.

[Code Quality] Use to validate a spec artifact's decisions with the user across three contexts — a freshly-authored Feature Spec (idea-to-spec), an existing canonical spec before PBI decomposition (spec-to-pbi), or a refined idea + §8 test-specs (idea-to-pbi deep mode). Detects the context, walks every applicable validation category, and runs an exhaustive but budget-bounded blocking clarification gate so every non-obvious or conflicting decision is confirmed before the artifact drives downstream work.

[Investigation] Use when about to author a new Feature Spec from an idea — investigate all existing Feature Specs AND related code logic first to surface related/overlapping/affected specs, missing features, missing test cases/user stories, system unknowns, and the invariant landscape, before any spec is drafted.

[General] Use when you need to (re)generate a DERIVED navigation index, cross-capability ERD, or reimplementation guide assembled FROM the canonical Feature Specs under docs/specs/**. Never extracts a separate A-E engineering tree.

[Skill Management] Use when starting a detected workflow, initializing workflow state, or activating a workflow sequence.

[Project Management] Use when creating user stories from PBIs, slicing features, or breaking down requirements.

[Content] Use when you need to build marketing strategy: positioning, channels, messaging, campaigns, budget, KPIs.

[Codex] Use when you need to run the full Codex mirror sync + verify pipeline (migrate → hooks → context → verify) standalone, no npm/package JSON needed.

[Skill Management] Use when shared protocol checklists change and need propagation across skills.

[Documentation] Use when (re)generating the DERIVED technical spec view over code + tests, or reporting canonical §8 TC/test-code drift. A GENERATOR — it projects code + tests into a regenerable per-component view and NEVER authors business content. Modes generate|audit|sync. Per-mode procedure lives in references/{author,sync}.md.

[Architecture] Use when you need to research, analyze, and compare tech stack options as a solution architect.

[Testing] Use when you need to run tests locally and analyze the summary report.

[Testing] Use when you need full-site QA audit (accessibility, performance, security, SEO) with visual reports.

[General] Use when building 3D web apps with ThreeJS and related WebGL or WebGPU examples.

[Code Quality] Use when reviewing UI/frontend changes for long-content overflow, responsive multi-screen layout (flex-wrap / row-to-column on small devices), flex-vs-fixed sizing, z-index discipline, SCSS/BEM styling quality, and async UI states & feedback (loading indicator, error surface, empty state).

[Frontend] Use when designing beautiful or aesthetic interfaces with curated UI styles, palettes, fonts, charts, and stacks.

[Process] Use when the developer wants something explained or taught, or wants to know HOW TO REVIEW a change — by default the current working tasks + changes in context, or whatever the prompt names (a plan, a subsystem, a decision, a concept, a bug). AI derives WHAT to explain from the prompt and ALWAYS delivers a teacher-and-coach review guide, high level first then detail: what was done, a VISUAL MAP (system flowchart, domain ERD, sequence diagrams), the user stories and business rules with their REAL test-case IDs, a REVIEW PATH naming which files to open first and in what order with an exit criterion per stage, the technical concepts needed to follow it, how it works, why THIS solution, every alternative option with pros/cons, the trade-offs accepted, the blast radius, HOW TO TEST AND DEMO the change, the developer's decision levers, and written challenge prompts that provoke the reader to pressure-test the work. Works at ANY scope — from one line of code to the whole project: it SIZES the target into a scope tier, DECOMPOSES a large one into understanding groups, BREAKS the work into tasks before the first deep read, and ACCUMULATES the report group by group on disk so a huge explanation stays complete instead of thinning out. Writes the full report to a single combined markdown file (plans/reports/understand-*.md) that opens with a detailed summary section — or delivers it in full in chat when Step 3 finds no git-ignored directory for it — and always summarizes it in chat. Regardless of coding level. Never interrogates, never quizzes, never blocks.

[Utilities] Use when you need to review recent changes and wrap up the work.

[Code Quality] Use when reviewing UI code for accessibility, responsiveness, performance, and UX best practices.

[Research] Use when starting a web research task — discover, gather, and triage candidate sources on a topic to feed deeper investigation.

[Testing] Use when you need individual page/component testing with Python Playwright scripts.

[Code Quality] Use when reviewing rationale and change quality for plans, PBIs, commits, diffs, docs, specs, reports, or explicit artifacts.

[Code Quality] Use when you need to combine /why-review + /fix in a recursive loop — each round runs /why-review to find validated findings then /fix to resolve them, then loops again over the CHANGED target until a fresh full /why-review produces zero findings (nothing left to fix).

[Workflow] Use when activating the Architecture Audit workflow to review the whole project's architecture, run an architecture health check, or check production readiness/scalability in one pass — read-only, produces one consolidated Architecture Health Report.

[Workflow] Use when activating the Big Feature workflow for large or ambiguous research-driven feature work.

[Workflow] Use when activating the Bug Fix workflow for systematic debugging with root cause investigation, fix, and verification.

[Workflow] Use when activating code-to-spec development — author/maintain the single canonical Feature Spec FROM existing code, keeping spec, implementation, and tests synchronized. For idea→spec (no code yet) use workflow-idea-to-spec.

[Workflow] Use when activating the E2E testing workflow to generate, update, or maintain Playwright/E2E tests. Pick mode with --source={changes|recording|update-ui}.

[Process] Use when you need to end the active workflow and clear state.

[Workflow] Use when activating the Feature Implementation workflow for implement a well-defined feature with investigation, planning, implementation, and review. Also covers TDD/test-first development and spec-driven feature implementation with test specs written before code.

[Workflow] Use when activating the Business Feature Documentation workflow for 8-section tech-free feature docs.

[Workflow] Use when activating the Greenfield Project Init workflow for full waterfall project inception from idea through implementation with integration testing.

[Workflow] Use when activating the Idea to PBI workflow for turning an idea — or a raw product vision/problem — into prioritized PBIs and stories (single-PBI deep mode, or multi-opportunity discovery mode).

[Workflow] Use when activating the Idea-to-Spec workflow — turn a raw idea/vision/problem into ONE canonical (provisional) Feature Spec. STOPS at the reviewed spec; chain workflow-spec-to-pbi for a backlog. For code→spec use workflow-code-to-spec.

[Workflow] Use when activating the Integration Test Green workflow — drive an integration-test suite to fully green with a bounded convergence loop: verify the whole system (or the named target), adjudicate every failure with /debug-investigate + /integration-test-review before any edit, fix at the owning layer, /changes-review each round's fix diff, re-verify from scratch, then sync spec TCs, the integration-test reference doc, and feature docs.

[Workflow] Use when activating the Code Refactoring workflow for restructure and improve existing code without changing behavior.

[Workflow] Use when activating the Research & Synthesis workflow — research a topic via web sources, then synthesize per --output={synthesis|business-eval|marketing|course} (knowledge report, business evaluation, marketing strategy, or course material).

[Workflow] Use when activating the Review Current Changes workflow for review, fix, and re-review recursively until all issues resolved.

[Workflow] Use when you need to run /workflow-review-changes repeatedly in an outer convergence loop until a complete whole-workflow run applies zero fixes — recursive re-review of a fixed scope (branch-diff + current changes) until a clean no-op pass.

[Workflow] Use when activating the Seed Test Data workflow for idempotent QC happy-path seeders.

[Workflow] Use when activating the Test Spec Update (Post-Change) workflow for update test specs and feature docs after code changes, bug fixes, or pr reviews.

[Workflow] Use when activating the Spec to PBI Backlog workflow to convert canonical tech-free Feature Specs into complete, prioritized, dependency-aware PBIs and stories.

[Workflow] Use when activating the Visual Diagram workflow for create visual excalidraw diagrams from codebase investigation or web research.

[Workflow] Use when activating the Write Integration Tests workflow for spec-first integration test authoring. Also covers converting existing test specs into integration test code and verifying integration test stability (repeat-run verification).

[Git] Use when you need to create isolated git worktree for parallel development.