Claude Agent Team

28 slash commands that orchestrate specialized AI agents for software development

Last updated: 2026-03-24

31
Commands
12
Agent Roles
8
Categories
9
Language Stacks
3
Integrations

Quick Start

git clone https://github.com/baard-ovrebo/claude-agent-team.git
cp claude-agent-team/.claude/commands/*.md ~/.claude/commands/     # Install globally
cp .env.example ~/.claude/.env                                     # Configure credentials
claude mcp add jam -- npx @anthropic-ai/jam-mcp                   # Optional: JAM MCP
claude mcp add paper --transport http http://127.0.0.1:29979/mcp   # Optional: Paper MCP

Configuration

.env File

Place in .claude/.env (per-project) or ~/.claude/.env (global). Local takes priority.

# Project role (used by /create and /bug)
ProjectType=APPLICATION
# Values: GAME, APPLICATION, SAAS, API, MOBILE

# Jira credentials (used by /jira, /tempo)
JIRA_BASE_URL=https://your-instance.atlassian.net
JIRA_EMAIL=your-email@company.com
JIRA_API_TOKEN=your-api-token

Rule Z — Code Quality Enforcement

Five Layers of Enforcement — v3

AI-generated code has a documented tendency to produce "works but wasteful" implementations. Rule Z is the enforcement system that prevents this across ALL code-writing commands (/create, /bug, /jira, /new-feature, /create-project, /fix-all, /dev-team, /full-pipeline, /impact-scan --apply, /code-analysis, /unit-test).

Measured result (12-build benchmark, 4 variants × 3 runs each):
MetricNo Rule Zv1v2v3
Anti-patterns per build60.6721.670.001.33
DOM nodes after mount851697633630
Mount time (ms)843852856852
Reduction vs baseline—−64%−100%−98%
→ Full comparison: rule-z-benchmark-results.html
LayerWhatLocation
1. MandatePrompt text explaining performance, resource, and code structure standards (zero allocations in hot paths, proper data structures, cleanup, batching, code reuse)Every code-writing command file
2. Hard Rule ZOrchestrator-level rule at same weight as "never force-push to main"Top of each command's rules section
3. Quality Bar block[QUALITY BAR — NON-NEGOTIABLE] block injected into every sub-agent prompt. The agents themselves see "your code will be REJECTED if..."Every sub-agent dispatch
4. Mandatory Quality AuditEvery agent report must include ## Quality Audit covering hot paths, data structures, cleanup, caching, batching, memory at scale, and shortcuts rejected. Orchestrator re-dispatches if missing.Every agent response
5. External Quality GateHTTP service running linter + project analysis (reuse + convention checks) + fresh Claude reviewer + human review queue. Blocks sub-agent turn if verdict is FAIL or HUMAN_REVIEW_REQUIRED.quality-gate/ service
Runtime Hooks (layer 4 + 5 teeth)

Four Python hooks wire the enforcement into Claude Code at runtime:

  • hooks/quality-audit-check.py (SubagentStop) — blocks sub-agent completion if ## Quality Audit is missing from the report
  • hooks/quality-audit-verify.py + hooks/ast-verify.mjs (SubagentStop) — v3 upgrade — parses the YAML audit block and cross-checks claims against the code via TypeScript's AST (falls back to improved regex). Fabricated claims fail and block.
  • hooks/quality-reminder.py (UserPromptSubmit) — prepends Rule Z reminder to every user prompt so it stays in short-term context
  • hooks/quality-gate-check.py (SubagentStop) — calls the Quality Gate service and blocks on FAIL verdict

Install via ~/.claude/settings.json — see hooks/README.md.

Quality Gate Service (external validator)

Standalone HTTP service that runs four independent checks on every AI code change:

  1. Linter pass — auto-detects language and runs the matching linter:
    LanguageLinter
    JavaScript / TypeScriptESLint (via npx)
    Pythonruff (preferred) / pylint
    Gogo vet
    Rustcargo clippy
    C#dotnet format
    Rubyrubocop
    PHPphpstan
  2. Project analysis — scans the existing codebase, builds an index of every exported function/class/component/type/hook across .ts/.tsx/.py/.cs/.java/.go files. Detects style conventions (indent, quotes, file naming). Flags new code that:
    • Duplicates existing functionality — major severity. e.g. agent writes formatDate when @/utils/dates.ts already exports one. Finding includes the existing file:line and says “Consider importing the existing one.”
    • Breaks project conventions — minor severity. e.g. file uses tabs but project uses 2-space, or kebab-case vs camelCase mismatch.
    This catches a real loophole: before this layer, an agent could write entirely fresh utilities that duplicated existing project functionality and the gate would still PASS as long as the new code itself was clean. Now it has to import, not duplicate.
  3. Fresh Claude reviewer — spawns an isolated Claude instance (via claude -p CLI, with OpenAI/Gemini as fallbacks) that reviews the diff with NO knowledge of the original agent's reasoning. This is the key part: an anchored reviewer in the same conversation would justify the original choices; a fresh reviewer sees them cold and spots what was rationalized.
  4. Human review queue — SQLite-backed queue with web UI at http://127.0.0.1:7733/ for items flagged for human approval. The hook polls the service and waits for your Approve / Reject / Defer decision (default: up to 10 minutes, configurable via GATE_HUMAN_WAIT). Progress is printed every 30 seconds so the session stays visibly alive. On approve: agent continues. On reject (with comment): hook blocks with your feedback and the orchestrator re-dispatches. On defer or timeout: session pauses and the user re-triggers the command when ready.

Verdict: PASS, FAIL (with specific findings), or HUMAN_REVIEW_REQUIRED.

Install: cd quality-gate && docker compose up -d

See quality-gate/README.md for full setup, API docs, and configuration.

What the QUALITY BAR block contains
[QUALITY BAR — NON-NEGOTIABLE]
Your code will be REJECTED if it does not meet these standards:

PERFORMANCE FIRST:
- Zero allocations in hot paths (loops, render functions, frame handlers)
- Proper data structures (Set/Map for O(1) lookups, not linear scans)
- Batched operations (no N+1 queries, batch DB writes, batch state updates)
- Early returns and lazy evaluation
- No synchronous I/O in request handlers or render paths

RESOURCE EFFICIENCY:
- Must run well on 8 GB RAM / integrated GPU / slow disk / 3G network
- All resources cleaned up (listeners, subscriptions, timers, connections)
- No unbounded caches or buffers
- GPU awareness for frontend — minimize re-renders, batch DOM ops

CODE STRUCTURE:
- Single responsibility per function
- No duplicated logic — extract shared utilities
- Reuse existing utilities before writing new ones
- Shared types/interfaces/models in ONE place — import, don't redefine

CODE REUSE:
- Grep project for existing utilities BEFORE writing new ones
- Extend existing components with props vs creating duplicates
- Constants/magic values in central location
- ONE way to do each thing

WATCH OUT for AI "works but wasteful" patterns:
- Rebuilding entire lists when one item changed
- Loading all data then filtering in memory (filter in SQL/API)
- setState in loops, creating functions inside render
- JSON.parse(JSON.stringify(obj)) for deep clone
- Repeated find/includes on same array in hot path
- Fetching data the backend already cached
- 3-layer validation

BEFORE REPORTING DONE, include ## Quality Audit:
- Hot paths: what you kept clean and how
- Data structures: why Set vs Array vs Map
- Cleanup: subscriptions/timers released
- Caching: what you memoized and why
- Batching: N+1 patterns avoided
- Memory at scale: estimate at 10x and 100x
- Code I avoided writing: shortcuts rejected

Related command: /quality-scan — hunts down existing Rule Z violations in any codebase, grades A–F.

How Commands Work Together

Command Relationships
/full-pipeline
↓ uses
/dev-team
/playwright-test
/docker-build
/docker-deploy
/docker-test
↓ /dev-team uses
/security-audit
/quality-audit
/fix-all
/test-all
/master-report
/jira {KEY}
→ uses →
/jam
/jira watch
/verify
Paper MCP
/code-analysis
/jira sprint
→ uses →
/jira {KEY}
for each ticket
/create
→ reports →
/changelog
← reports ←
/bug
/create
→ auto-calls →
/verify
← auto-calls ←
/bug

Project Management

/jira {KEY} Project Management

Full Jira ticket-to-resolution pipeline. Takes a ticket from assignment to completed implementation with design review, code analysis, and Jira updates.

/jira FO-2847
/jira FO-2847 "Reviewer says the date format is wrong and missing validation"
/jira FO-2847 --add-context "Use ISO 8601 format, check DateUtils in shared/utils"
/jira FO-2847 "Fix date format" --add-context "Must use existing DateUtils"
/jira FO-2847 --council
/jira FO-2847 --autonomous
/jira sprint --autonomous
Flags
FlagDescription
--add-context "text"High-priority developer guidance that supplements the ticket description. Passed to ALL implementation agents as a top-level instruction. Takes precedence over ticket description when conflicting. Appears in ticket summary, Jira comment, and final report. Can combine with review feedback mode.
--councilConsult the LLM Council before committing to an approach. Sends ticket details to ChatGPT + Gemini, synthesizes perspectives. Also auto-recommended for architecture decisions, migrations, and tickets with multiple valid approaches. Can combine with any mode.
--autonomousFully autonomous mode. Works on the ticket with ZERO user interaction. Evaluates 5 clarity criteria — if any fail, the ticket is SKIPPED (not asked about). When clear: auto-transitions to In Progress, auto-creates branch (bugfix/FO-xxx, feature/FO-xxx, hotfix/FO-xxx based on issue type), implements without approval gates, runs code analysis + verification, generates a markdown report. All changes LOCAL ONLY — no Jira comments, no uploads, no remote pushes. Works with sprint mode to batch-process all tickets.
Autonomous Mode — Deep Dive

Clarity Gate (5 criteria, ALL must pass):

  1. What needs to change is described
  2. Where in the codebase is identifiable
  3. Expected behavior is described or inferable
  4. No unanswered questions in comments
  5. No conflicting instructions between description and comments

Branch naming: Auto-maps issue type to prefix:

Issue TypeBranch PrefixExample
Bug, DevBug, Defectbugfix/bugfix/FO-2847
Hotfixhotfix/hotfix/FO-2850
Story, Task, Oppgavefeature/feature/FO-2855
Technical Debtchore/chore/FO-2860
Spikespike/spike/FO-2870

Sprint mode: /jira sprint --autonomous processes all tickets sequentially, skips unclear ones, and generates a summary table showing completed vs skipped with reasons.

Output: reports/{timestamp}_autonomous_{KEY}.md per ticket with branch info, all changes, testing instructions.

What It Does (5 Phases)
  1. Fetch & Analyze — fetches ticket via REST API, downloads/resizes image attachments, auto-detects JAM links and analyzes them via MCP, reads all comments for additional requirements and unanswered questions, classifies scope (UI/Backend/Full-stack)
  2. Design (if UI changes) — captures BEFORE screenshots with Playwright, creates mockups in Paper via MCP, presents to user for approval
  3. Implementation — creates Git branches for all affected projects, launches Frontend + Backend agents in parallel, Code Analyst reviews the diff
  4. Report & Jira Update — generates HTML report, uploads to Jira as attachment, posts summary comment, transitions ticket status
  5. Summary & Time Logging — presents results, logs time via Tempo
Advanced Features
  • Comment analysis — reads ALL comments chronologically, extracts additional requirements added after the description, identifies unanswered questions, notes latest context that may override the description
  • Automatic @mention + watch loop — if the agent determines it doesn’t have enough info to implement, it recommends asking the reporter, posts a question @mentioning them on Jira, then automatically enters a watch loop (polls every 2 min). When the reporter replies, the agent detects it, analyzes the answer, and auto-resumes the pipeline. If it still needs more info, it posts another question and watches again. This back-and-forth continues until the ticket has enough info.
  • JAM auto-detection — scans description and comments for jam.dev links, analyzes each via MCP (video, console logs, network requests, user events)
  • Git branch setup — after plan approval, asks to create branches. Lists available branches from each project, user picks base branch and names the new one (hotfix/FO-xxx, feature/FO-xxx, custom)
  • Image auto-resize — resizes downloaded attachments to max 1600px before analysis (prevents multi-image dimension errors)
  • State persistence — saves full pipeline state to reports/jira-state-{KEY}.json when paused. Resume from a new session with /jira resume {KEY} — no need to re-enter project paths, branches, or approvals
The Automatic Dialogue Flow
  1. Agent analyzes ticket → determines it needs more information
  2. Agent recommends asking the reporter (“I recommend asking — the ticket doesn’t specify X and Y”)
  3. Posts @mention comment on Jira with specific questions
  4. Automatically enters watch loop (no user prompt needed)
  5. Polls every 2 minutes for new comments
  6. Reporter replies on Jira → agent detects reply → analyzes if it answers the question
  7. If answered: auto-resumes pipeline from where it paused
  8. If reporter asks a counter-question: presents to user, can draft AI response
  9. If agent still needs more info after resuming: posts another question → watches again
  10. Loop continues until ticket is fully resolved

In sprint mode: asks whether to watch this ticket or move to the next one (since watching blocks the batch).

Interrupt: Ctrl+C saves state. Resume later with /jira resume {KEY}.

Review Feedback Mode

When a ticket comes back from review with issues, use: /jira FO-2847 "Description of what needs fixing"

  1. Fetches ticket + latest comments (the review feedback)
  2. Checks for JAM recordings in review comments
  3. Parses feedback into actionable items: bugs found, missing requirements, design changes, code quality issues
  4. Loads previous context (project paths, branches) from saved state — avoids re-asking
  5. Plans fixes, presents to user for approval
  6. Implements the minimum changes needed
  7. Verifies with Playwright (if app running)
  8. Generates jira-{KEY}-review-fix-report.html
  9. Offers to post a comment on Jira listing what was fixed + attach the report

Output: reports/jira-{KEY}-report.html or reports/jira-{KEY}-review-fix-report.html

Uses:

Requires: .env with Jira credentials

/jira sprint Project Management

Batch process all tickets in the current sprint. Fetches Scrum teams dynamically, user picks a team, presents tickets in a prioritized table, processes each through the full /jira pipeline.

/jira sprint
What It Does
  1. Fetches all Scrum teams from Jira (dynamically, not hardcoded)
  2. User picks a team or "All teams"
  3. Fetches current sprint tickets (assigned to user or unassigned)
  4. Presents prioritized table with ticket details
  5. User selects: all / specific / only mine / only unassigned
  6. Processes each ticket through the full 5-phase /jira pipeline
  7. Continue / Skip / Stop controls between tickets
  8. Sprint summary at the end

Uses:

/jira {KEY} for each selected ticket

/jira teams Project Management

Lists all available Scrum teams from Jira. Instant lookup, no processing.

/jira teams

/jira watch {KEY} Project Management

Polls a Jira ticket every 2 minutes for new comments. Automatically entered whenever the /jira pipeline posts a question to the reporter. Can also be run standalone. When the reporter replies, analyzes the answer and auto-resumes the pipeline.

/jira watch FO-2847                    # Standalone: watch a ticket
# Also auto-entered by /jira {KEY} when it posts a question
How It Gets Triggered

Automatic (most common): When /jira FO-2847 determines it needs more info, it posts a question @mentioning the reporter and immediately enters the watch loop. No user action needed.

Manual: Run /jira watch FO-2847 to start watching a ticket you previously paused or where you’re expecting a response.

The Dialogue Loop
  1. Pipeline posts a question on Jira (@mentions reporter)
  2. Automatically enters watch loop — polls every 2 minutes
  3. Ignores its own comments (from the authenticated user)
  4. When reply detected: analyzes if it answers the question
  5. If answered: auto-resumes pipeline from where it paused
  6. If counter-question: presents to user, can draft AI response or let user type, posts it, continues watching
  7. If pipeline needs more info after resuming: posts another question → watches again
  8. Loop continues until ticket is fully resolved

Interrupt: Ctrl+C or type stop to save state and exit. Resume later with /jira resume {KEY}.

/jira resume {KEY} Project Management

Resumes a paused ticket from a saved state file. Loads context from reports/jira-state-{KEY}.json, fetches new comments, continues from the exact phase where it stopped. No need to re-enter project paths, branches, or approvals.

/jira resume FO-2847

/jam {url} Project Management

Analyzes JAM (jam.dev) bug recordings via MCP tools. Fetches video analysis, console error logs, failed network requests, and user click events.

/jam https://jam.dev/c/abc123
/jam FO-2847                      # Extracts JAM links from Jira ticket

Accepts: JAM URL, JAM ID, or Jira ticket key (scans ticket for JAM links)

Requires: JAM MCP server

/tempo Project Management

Quick time logging without leaving the terminal.

/tempo addTime FO-2847 2h "Bug fix"
/tempo getTime FO-2847
/tempo getWeek
/tempo getMonth

Requires: .env with Jira credentials

Universal Commands

/create "description" Universal

Context-aware feature creator. Reads ProjectType from .claude/.env, adapts role (Game Dev, App Dev, SaaS Dev, etc.), generates an HTML plan with Paper design mockups, gets user approval, implements, then verifies with Playwright.

/create "Monsters that hunt the player using pathfinding AI"
/create "Add dark mode toggle to settings page"
/create "REST endpoint for bulk invoice export"
/create "Event-driven notification system" --council
/create "Implement caching layer for API" --council --tier pro
Role Adaptation
ProjectTypeStackRole Assumed
GAMEUnity (C#)Senior Unity Game Developer
GAMEUnreal (C++)Senior Unreal Engine Developer
GAMEGodotSenior Godot Developer
APPLICATIONReact/.NET/Java/PythonSenior {framework} App Developer
SAASAny web stackSenior SaaS Platform Developer
APIAny backendSenior API Developer
MOBILEReact Native/Flutter/Swift/KotlinSenior Mobile Developer
The Plan → Design → Implement Flow
  1. Analyze — reads 3-5 existing files first to understand conventions. Identifies files to create/modify, detects if UI changes needed
  2. Design mockups (if UI) — create artboards in Paper via MCP, capture screenshots
  3. Generate HTML plan — reports/feature-plan.html with embedded Paper screenshots, technical plan, API contracts, testing plan. Auto-opens in browser for review.
  4. User approval gate — Accept / Adjust / Redesign / Cancel
  5. BEFORE screenshots (if app running) — captures current state with Playwright before any changes
  6. Implement — follows the HTML plan. For large features, can spawn parallel Frontend + Backend agents. All agents match existing code style.
  7. Code analysis — reviews the diff for security issues, logic errors, dead code. Auto-fixes critical issues.
  8. Verify (if app running) — auto-offers Playwright E2E verification. Takes AFTER screenshots, generates before/after comparison.
  9. Master HTML report — optional: compile everything into a comprehensive report (like /new-feature)
Codebase Awareness

Before writing any code, /create reads existing files in the area it’s working on. It identifies naming conventions, code style, architecture patterns, and existing utilities to reuse. Generated code matches the existing codebase — same indentation, bracket style, naming convention, error handling pattern, and import structure. Sub-agents receive the same instruction.

Output: reports/feature-plan.html (plan, auto-opens) + .claude/unprocessed_reports/YYYY-MM-DD_HH-MM-SS_feature_{slug}.md (report) + reports/verify-report.html (if verified)

LLM Council Integration

--council flag forces consultation with ChatGPT + Gemini before planning. Also auto-recommended when the feature involves: architecture decisions, 3+ valid approaches, performance-critical design, new technology introduction, or cross-cutting concerns (auth, caching, state management). Council synthesis is included in the HTML plan document.

Uses:

Used by:

/changelog reads its reports

/bug "description" Universal

Context-aware bug fixer. Same role detection as /create. Analyzes pasted screenshots, diagnoses root cause, applies minimum fix, verifies with Playwright, saves report.

/bug "Player falls through floor when jumping near walls"
/bug "Login shows 500 error after session timeout"

Screenshots: Paste screenshots into the conversation before or with the command — the agent analyzes them for error messages, visual state, stack traces.

Verification

After fixing the bug, if the app is running, the agent auto-offers to verify the fix with Playwright. It logs in using the project profile, reproduces the original bug steps, confirms the bug no longer occurs, and takes screenshots as evidence. Results are attached to the report.

Output: .claude/unprocessed_reports/YYYY-MM-DD_HH-MM-SS_bugfix_{slug}.md

Uses:

Used by:

/changelog Universal

Reads all reports from .claude/unprocessed_reports/ and generates a project-themed HTML changelog. The design automatically matches the project: dark neon for games, clean corporate for apps, terminal-style for APIs. Saves design settings to the project profile for consistency.

/changelog
Project-Aware Design

The changelog visual design adapts to the project type:

ProjectTypeTheme
GAMEDark bg, neon accents, glow effects, “Patch Notes” style, ADDED/FIXED/PATCHED labels. Adapts to genre (pixel, dark fantasy, sci-fi)
APPLICATIONClean white, blue accent, corporate timeline, FEATURE/BUG FIX labels
SAASMinimal indigo, product update feel, feature highlights
APIDark terminal, green/cyan, technical changelog with code blocks
MOBILEApp-like, rounded corners, vibrant, “What’s New” style

Design is detected from: 1) .claude/project-profile.json design section, 2) project CSS/theme files, 3) auto-generated from ProjectType. Saved to profile for all future reports.

Output: reports/changelog.html

Reads from:

/create /bug report files

/council "question" Universal

Multi-model decision engine. Consults ChatGPT and Gemini in parallel, then Claude synthesizes all perspectives into a unified recommendation. Prevents anchoring bias by forming its own opinion first.

/council "Should we use GraphQL or REST for our new public API?"
/council "Best auth strategy for microservices?" --tier pro
/council "Implement a rate limiter middleware" --code
/council "Review this PR" --review src/auth/middleware.ts
/council "Redux vs Zustand for state management" --debate
/council --config
/council --cost
Modes
ModeFlagWhat It Does
Consult(default)Query all models, get synthesized recommendation with consensus areas, divergent opinions, and implementation plan
Code--codeAll models produce code implementations. Side-by-side comparison: patterns, libraries, edge case coverage. Picks best or merges.
Review--review {file}All models review the same code. Deduplicates findings (shared findings get confidence boost). Categorizes: Critical/Warning/Info.
Debate--debateModels argue opposing positions. Claude moderates, identifies strongest/weakest arguments, delivers verdict.
Config--configInteractive setup for API keys (OpenAI + Google AI). Saves to .claude/council.env, auto-adds to .gitignore.
Cost--costShow total API usage: calls, tokens, estimated cost across all council sessions.
Model Tiers
TierChatGPTGeminiBest For
budget (default)gpt-4o-minigemini-2.0-flash-liteQuick opinions, routine decisions (~$0.001)
balancedgpt-4ogemini-2.5-flashArchitecture decisions, tech choices (~$0.01-0.05)
proo3-minigemini-2.5-proCritical decisions, complex trade-offs (~$0.05-0.50)
How Synthesis Works
  1. Claude forms own opinion FIRST — before reading other responses (prevents anchoring bias)
  2. Reads ChatGPT and Gemini responses
  3. Identifies: consensus areas, unique insights per model, blind spots, disagreements
  4. Synthesizes unified recommendation incorporating the best from all perspectives
  5. Rates confidence: HIGH (all agree), MEDIUM (minor disagreements), LOW (fundamental disagreement)
Flags
FlagDescription
--models gpt,geminiWhich models to consult (default: both)
--tier budget|balanced|proModel quality tier (default: budget)
--codeCode implementation comparison mode
--review {file}Multi-model code review mode
--debateAdversarial debate mode
--context "text"Extra project context for all models
--configSet up API keys
--costShow usage/cost stats

Output: reports/council-{slug}.md + reports/council-{slug}.html (for significant decisions) + reports/council-responses.json

After decision: Can hand off directly to /create to implement the recommended approach.

Requires: .claude/council.env with OpenAI + Google AI API keys

/create-project "description" Universal

Full project creator — from idea to running application. Asks clarifying questions, designs architecture and UI in Paper, generates an HTML plan with embedded mockup screenshots (auto-opens in browser), then orchestrates the full agent team to build, test, and deliver.

/create-project "A task management app with Kanban boards"
/create-project "REST API for a pet adoption service"
/create-project "2D platformer game with procedural levels"
/create-project "SaaS dashboard for monitoring IoT devices"
The Full Pipeline
  1. Questions — asks about stack preference, features for v1, auth needs, design style, where to create the project
  2. Architecture — designs directory structure, database schema, API endpoints, component architecture
  3. UI Design in Paper — creates 3-5+ screens in Paper via MCP (login, dashboard, feature pages, mobile). Takes screenshots.
  4. HTML Plan — generates reports/project-plan.html with ALL Paper screenshots embedded, architecture docs, API spec, DB schema. Auto-opens in browser.
  5. User Approval — Build / Adjust / Redesign / Change stack / Cancel
  6. Build — scaffolds project, launches Backend Dev + Frontend Dev agents, Code Analyst reviews
  7. Quality Loop — Security Auditor + Quality Engineer scan, Backend Dev fixes, Test Engineer tests, re-scan until clean
  8. Verify — builds, starts the app, runs Playwright E2E verification with screenshots
  9. Docker (if requested) — creates Dockerfiles, docker-compose.yml, builds and verifies
  10. Delivery Report — generates reports/project-delivery-report.html with all screenshots, auto-opens

Output: reports/project-plan.html (plan) + reports/project-delivery-report.html (delivery) + complete working project

Uses:

Requires: Paper MCP (for UI design), Playwright (for verification)

Feature Development

/new-feature Feature Dev

6-phase feature pipeline: plan, screenshot existing UI, design in Paper (user approval gate), parallel frontend + backend implementation, code analysis, master report.

/new-feature
6 Phases
  1. Planning — ask for project paths, analyze codebase, draft feature plan, user approval gate
  2. Visual Capture — screenshot existing app with Playwright (if running)
  3. Design in Paper — UI Designer agent creates mockups via MCP, user reviews and approves
  4. Implementation — Frontend + Backend agents work in parallel, Code Analyst reviews diff
  5. Report — Documentation Lead compiles master HTML report
  6. Testing — optional handoff to /full-pipeline

Output: reports/feature-report.html

Uses:

/code-analysis Feature Dev

Reviews ONLY the git diff (not the entire codebase). Checks for SQL injection, XSS, command injection, hardcoded secrets, null refs, race conditions, missing auth. Auto-fixes critical issues.

/code-analysis

Output: reports/code-analysis.md

Used by:

Code Quality

/dev-team Code Quality

Iterative quality loop with 5 specialized agents. Scans, fixes, tests, re-scans until zero findings. Typically 2-3 rounds.

/dev-team
The Loop
  1. Parallel Scan — Security Auditor + Quality Engineer run simultaneously
  2. Fix — Backend Developer fixes all findings (Critical → Warning → Info)
  3. Test — Test Engineer writes tests for every fix, runs until green
  4. Verify — Re-run both scans. New issues? Loop back. Zero findings? Done.
  5. Report — Documentation Lead compiles master report

Output: reports/master-report.html

Uses:

Used by:

/security-audit Code Quality

OWASP Top 10 vulnerability scan across all source files. Injection, XSS, broken auth, data exposure, access control, misconfiguration.

Output: reports/security-audit.md

/quality-audit Code Quality

Code smells, bugs, anti-patterns. Type safety, error handling, performance, dead code, API design.

Output: reports/quality-audit.md

/fix-all Code Quality

Reads findings from security + quality audit reports and fixes all issues by severity: Critical → Warning → Info.

Output: reports/fixes-applied.md

/test-all Code Quality

Writes unit tests for every fix. Edge cases + security regression tests. Runs all tests, iterates until 100% pass.

Output: reports/test-report.md

/quality-scan Code Quality Rule Z

Hunts down AI-generated "works but wasteful" code. Finds allocations in hot paths, N+1 queries, linear scans on lookups, memory leaks, GPU waste, unbounded caches, wrong data structures. Grades the codebase A–F.

/quality-scan                          # Current project
/quality-scan D:\Projects\my-app       # Specific path
/quality-scan --group                  # All linked projects + cross-project issues
/quality-scan --area "invoice export"  # Scoped to feature area
/quality-scan --severity critical      # Only critical findings
/quality-scan --fix                    # Apply fixes
/quality-scan --create-roadmap         # Create Jira tickets
What It Finds
  • Performance: allocations in hot paths, N+1 queries, linear scans, missing pagination, sync I/O in handlers
  • Resource management: memory leaks, missing cleanup, GPU waste, unbounded caches
  • Code structure: oversized functions, duplication, dead code, wrong data structures
  • Scalability: patterns that break at 10x data, hardcoded limits, missing caching
  • AI-specific: JSON.parse/stringify clones, filter-in-memory-vs-SQL, render-time allocation, setState in loops, repeated find/includes, fetching cached data, 3-layer validation
Cross-Project Analysis (--group)
  • Frontend re-fetching data the backend already caches
  • Duplicate validation in frontend AND backend
  • API endpoints returning 30 fields when frontend uses 4
  • Missing shared types between frontend and backend
  • Chatty APIs (5+ calls for one screen that could be 1 composite)

Grade scale: A (<1 finding per 1000 LOC), B (<5), C (<15), D (<30), F (30+)

Output: reports/quality-scan-report.html (auto-opens) + reports/quality-findings.json

Uses:

/jira to create roadmap tickets

/master-report Code Quality

Compiles all agent reports into a single polished HTML master report with 8 sections.

Output: reports/master-report.html

Testing & Dependencies

/unit-test Testing

Unit test engineer. Maps existing coverage, identifies gaps, creates tests, runs and fixes iteratively. Supports 9 language stacks.

/unit-test *                              # Full project scan
/unit-test * control-backend-api          # Scan specific project
/unit-test AdminAuth.java                 # Single file
/unit-test --fix-ignored                  # Rehabilitate disabled tests
/unit-test --fix-ignored control-backend  # Fix ignored in specific project
ModeWhat It Does
*Full scan: map all tests, find gaps, create missing tests, run until green
{file}Create tests for a specific file or class
--fix-ignoredFind @Disabled/@Ignore/skip tests, present selectable list, unignore and fix each

Stacks: Java/JUnit, C#/xUnit, JS/Jest, Python/pytest, Go, Rust, PHP/PHPUnit, Ruby/RSpec

Output: reports/unit-test-report.html

/playwright-test Testing

Runs Playwright E2E browser tests. Analyzes failures (distinguishes app bugs from test bugs), writes missing tests for coverage gaps.

Output: reports/playwright-report/ + reports/playwright-test-report.md

Used by:

/deps Dependencies

Dependency health audit: CVEs (with exploitability check), outdated packages (staleness score), license compatibility risks. Health grade A–F.

/deps                                 # Full audit at current directory
/deps control-backend-api             # Specific project
/deps --vuln-only                     # CVEs only
/deps --outdated                      # Outdated packages only
/deps --license                       # License audit only

Output: reports/deps-audit-report.html

/verify Testing

E2E verification engineer. Uses Playwright to verify that implemented features and bug fixes actually work in the running application. Takes before/after screenshots as evidence. Uses a project profile for login and navigation.

/verify                                    # Auto-verify latest report
/verify reports/jira-FO-2847-report.html   # Verify specific report
/verify setup                              # Create/update project profile
/verify "Check login redirects properly"   # Manual verification
Project Profile System

On first run, /verify interactively builds a .claude/project-profile.json with:

  • Frontend URL — where the app runs (localhost:3000, etc.)
  • Auth config — login page URL, form selectors, test user credentials
  • Auth types supported: form login, OAuth/SSO (saved session), API key, basic auth, no auth
  • Viewport and timing — screenshot size, wait times

Credentials go in .claude/.env (gitignored), not the profile JSON. The profile is reused for all future verifications.

How Verification Works
  1. Reads the “How to Verify” section from the report (/create, /bug, or /jira output)
  2. Translates each step into Playwright actions (navigate, click, fill, assert)
  3. Logs in using the project profile auth config
  4. Takes BEFORE screenshots
  5. Performs each verification step
  6. Takes AFTER screenshots
  7. Visually analyzes screenshots for confirmation
  8. Reports pass/fail per step with screenshot evidence
Integration with Other Commands

/create and /bug automatically offer to run /verify after implementation if the app is running. The verification results and screenshots are attached to the report.

/jira includes verification screenshots in the Jira ticket attachments and comment.

Output: reports/verification-report.md + reports/verification-screenshots/*.png

Used by:

Requires: Playwright + running application

/report Testing

Analyzes ALL code changes on the current branch (vs main/develop), understands what was done and why, generates a Jira-ready HTML report with categorized changes and detailed testing instructions for QA. Works for both AI-assisted and manual code changes.

/report                     # Analyze current branch vs auto-detected base
/report FO-2847             # Analyze and upload to Jira ticket
/report --compare develop   # Compare against specific branch
/report --since abc1234     # Changes since a specific commit
What the Report Contains
  1. Executive Summary — what the branch does, scope, risk assessment
  2. Changes by Category — new features (green), bug fixes (amber), refactoring (blue), config (gray), database (purple), styling (cyan), tests (teal)
  3. Files Changed — table with file, change type, category, summary
  4. Screenshots — if app is running, captures affected pages with Playwright
  5. Testing Instructions for QA — step-by-step test cases with: preconditions, exact steps, expected results, test data, priority (must/should/nice to test). Checkboxes for testers.
  6. Commit History — all commits with hash, author, date, message
  7. Technical Details — dependencies, migrations, env var changes
Jira Upload

After generating, asks if you want to upload to Jira:

  • Uploads HTML report as attachment
  • Uploads screenshots as attachments
  • Posts summary comment on the ticket
  • Auto-detects ticket key from branch name (e.g., feature/FO-2847)

Output: reports/change-report.html (auto-opens in browser)

Requires: Git. Optional: Jira credentials for upload, Playwright for screenshots.

Git Operations

/git Git

Git operations manager. Sync branches with AI-powered conflict resolution, or get a quick status overview.

/git sync develop                           # Merge develop into current branch
/git sync develop --fix-merge-errors        # Auto-resolve conflicts with AI
/git sync develop --all                     # Sync all projects in project map
/git sync main control-backend-api          # Sync specific project
/git status                                 # Branch overview: ahead/behind, uncommitted
Conflict Resolution

With --fix-merge-errors, for each conflicting file a specialized agent:

  1. Reads both versions (HEAD and incoming)
  2. Analyzes what each side is doing
  3. Resolves: both needed (merge both), incoming preferred, current preferred, or needs human review
  4. Removes all conflict markers
  5. Regenerates lock files (package-lock.json, yarn.lock, etc.)

If the AI isn't confident, it flags the file as NEEDS_HUMAN_REVIEW instead of guessing.

Output: reports/git-sync-report.md

Repository Onboarding

/repo-setup Onboarding

Repository setup assistant and organization scanner. Clones repos, analyzes stacks, installs deps, configures environments, detects dependent repos, maps inter-repo relationships, generates comprehensive HTML documentation.

/repo-setup https://github.com/org/project.git        # Single repo
/repo-setup https://github.com/nexum-fo                # Scan entire org
/repo-setup https://github.com/nexum-fo --auto-setup   # Auto-setup all repos
/repo-setup https://github.com/nexum-fo --search "API" # Filter by search
/repo-setup https://github.com/nexum-fo --auto-setup --search "control"
/repo-setup D:\Projects\my-app                          # Local repo
/repo-setup --local-scan D:\Projects                    # Scan disk for org repos
/repo-setup https://github.com/org --analyze-only       # Report only
FlagDescription
--auto-setupSkip all prompts, clone + install + build + test automatically
--search "text"Filter repos by name, description, topics, README content
--analyze-onlyReport only, don't install anything
--gh-user {acct}Switch GitHub account (or auto-detect from available accounts)
--local-scan {path}Scan disk for repos instead of cloning from GitHub
Organization Scan Features
  • Fetches all repos via GitHub API
  • Maps inter-repo relationships: depends-on, frontend-for, shares-data, shared-library, gateway
  • Calculates correct startup order from dependency graph
  • Generates CSS architecture diagram with color-coded repo boxes and connection lines
  • GitHub account switching: lists all authenticated gh accounts, user picks one

Output: reports/repo-setup-guide.html (single) or reports/org-documentation.html (org)

/impact-scan "description" Onboarding

Cross-repository impact scanner. Describes a change you want to make, then scans all repos in an org (or local disk) to find exactly where changes are needed. Produces a detailed HTML report with per-repo file-level change descriptions, dependency chain, and implementation order.

/impact-scan "Add product price to payload response for REST public api"
/impact-scan "Add price field" --org https://github.com/nexum-fo
/impact-scan "Add price field" --local-scan D:\Projects
/impact-scan "Add price" --repos backend-api,frontend,shared-types
/impact-scan --apply reports/impact-scan-salesorder-unit.html
/impact-scan --apply report.html --target D:\Dev\feature-work
/impact-scan --convert-json reports/impact-scan-customer-status.html
Flags
FlagDescription
--org {url}Scan all repos in a GitHub organization
--local-scan {path}Scan repos already cloned on local disk
--repos repo1,repo2Only scan specific repos (by name or path)
--gh-user {account}Use a specific GitHub account for org access
--apply {report}Implement ALL changes from a previous scan report locally (never pushes to remote)
--apply {report} --target {path}Clone affected repos into a specific directory before implementing
--convert-json {html_path}Parse an existing HTML report and generate a structured JSON file (same filename with .json extension)
How It Works
  1. Resolve repos — fetch from GitHub org, scan local disk, or use specified repos
  2. Extract keywords — parse the description into entities, actions, layers, search patterns
  3. Deep scan each repo — search for models, DTOs, controllers, endpoints, serializers, tests. Read matching files to understand what they do.
  4. Classify impact per file — change type (add/modify/create), priority (must/should/consider), complexity (simple/medium/complex)
  5. Map dependencies — determine implementation order (shared libs first, then backends, then frontends)
  6. Generate HTML report — impact diagram, per-repo tables with exact files and change descriptions, code snippets
Report Contents
  • Executive summary with complexity estimate
  • CSS impact diagram showing affected vs unaffected repos
  • Implementation order with dependency reasoning
  • Per-repo detail: file, change type, what to do, priority, complexity, code snippets
  • Repos NOT affected (with reasoning)
  • Risk assessment and rollback plan
  • Suggested PR strategy
Apply Mode (--apply)

After scanning, use --apply to implement ALL changes from a report locally:

  1. Reads the scan report HTML to extract repos, files, changes
  2. Clones/pulls all affected repos
  3. Creates identical feature branches in each repo (LOCAL ONLY)
  4. Installs dependencies
  5. Implements changes in dependency order (spawns agents per repo)
  6. Builds all repos, runs tests
  7. Starts all services locally
  8. Generates delivery report with testing instructions

Safety: NEVER pushes to remote. All changes stay on local branches. Includes rollback instructions.

Next Steps After Scanning
  • Apply locally — --apply report.html implements everything on local branches
  • Start implementing — uses /create for each repo in dependency order
  • Create Jira tickets — one ticket per affected repo with change details + blocked-by links
  • Just the report — for planning purposes only
JSON Dual Output

Every scan generates both an HTML and a JSON file (same filename, different extension). The JSON uses a structured schema with: title, changeRequest, date, reposScanned, reposAffected, complexity, executiveSummary, architectureFlow, implementationOrder, affectedRepos (with per-file changes + currentCode/newCode snippets), unaffectedRepos, riskAssessment, and suggestedApproach.

The JSON can be consumed by --apply mode, CI pipelines, or external tools. Use --convert-json to retroactively generate JSON from older HTML-only reports.

Output: reports/impact-scan-{slug}.html + reports/impact-scan-{slug}.json (auto-opens HTML in browser)

Requires: gh CLI for org scan, otherwise standalone

Docker & Full Pipeline

/full-pipeline Pipeline

End-to-end delivery pipeline: code quality loop + Playwright E2E + Docker build/deploy/test + master report. The one command that does everything.

/full-pipeline
4 Phases
  1. Code Quality Loop — /dev-team iterative scan/fix/test
  2. Playwright E2E — browser tests, failure triage, coverage gaps
  3. Docker Pipeline — build, deploy, integration tests against live container
  4. Master Report — compiles everything into one HTML document

Output: reports/master-report.html + running Docker container

Uses:

/docker-build Docker

Build Docker image, validate (size, non-root user, health check, no secrets in layers), security scan.

Output: reports/docker-build-report.md

/docker-deploy Docker

Deploy with docker compose up -d, wait for health check, test key endpoints, collect container ID, IP, ports, network, resource usage.

Output: reports/docker-deploy-report.md

/docker-test Docker

Full integration test suite against a live Docker container: auth, CRUD, security, edge cases. Records every request/response.

Output: reports/docker-integration-test-report.md

/docker-teardown Docker

Gracefully tear down Docker containers and report freed resources.

Output: reports/docker-teardown-report.md