Claude Agent Team
28 slash commands that orchestrate specialized AI agents for software development
Last updated: 2026-03-24
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).
| Metric | No Rule Z | v1 | v2 | v3 |
|---|---|---|---|---|
| Anti-patterns per build | 60.67 | 21.67 | 0.00 | 1.33 |
| DOM nodes after mount | 851 | 697 | 633 | 630 |
| Mount time (ms) | 843 | 852 | 856 | 852 |
| Reduction vs baseline | — | −64% | −100% | −98% |
| Layer | What | Location |
|---|---|---|
| 1. Mandate | Prompt 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 Z | Orchestrator-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 Audit | Every 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 Gate | HTTP 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 Auditis missing from the reporthooks/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 contexthooks/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:
- Linter pass — auto-detects language and runs the matching linter:
Language Linter JavaScript / TypeScript ESLint (via npx) Python ruff (preferred) / pylint Go go vet Rust cargo clippy C# dotnet format Ruby rubocop PHP phpstan - 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
formatDatewhen@/utils/dates.tsalready 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.
- Duplicates existing functionality — major severity. e.g. agent writes
- Fresh Claude reviewer — spawns an isolated Claude instance (via
claude -pCLI, 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. - 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 viaGATE_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
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
| Flag | Description |
|---|---|
--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. |
--council | Consult 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. |
--autonomous | Fully 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):
- What needs to change is described
- Where in the codebase is identifiable
- Expected behavior is described or inferable
- No unanswered questions in comments
- No conflicting instructions between description and comments
Branch naming: Auto-maps issue type to prefix:
| Issue Type | Branch Prefix | Example |
|---|---|---|
| Bug, DevBug, Defect | bugfix/ | bugfix/FO-2847 |
| Hotfix | hotfix/ | hotfix/FO-2850 |
| Story, Task, Oppgave | feature/ | feature/FO-2855 |
| Technical Debt | chore/ | chore/FO-2860 |
| Spike | spike/ | 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)
- 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)
- Design (if UI changes) — captures BEFORE screenshots with Playwright, creates mockups in Paper via MCP, presents to user for approval
- Implementation — creates Git branches for all affected projects, launches Frontend + Backend agents in parallel, Code Analyst reviews the diff
- Report & Jira Update — generates HTML report, uploads to Jira as attachment, posts summary comment, transitions ticket status
- 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}.jsonwhen paused. Resume from a new session with/jira resume {KEY}— no need to re-enter project paths, branches, or approvals
The Automatic Dialogue Flow
- Agent analyzes ticket → determines it needs more information
- Agent recommends asking the reporter (“I recommend asking — the ticket doesn’t specify X and Y”)
- Posts @mention comment on Jira with specific questions
- Automatically enters watch loop (no user prompt needed)
- Polls every 2 minutes for new comments
- Reporter replies on Jira → agent detects reply → analyzes if it answers the question
- If answered: auto-resumes pipeline from where it paused
- If reporter asks a counter-question: presents to user, can draft AI response
- If agent still needs more info after resuming: posts another question → watches again
- 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"
- Fetches ticket + latest comments (the review feedback)
- Checks for JAM recordings in review comments
- Parses feedback into actionable items: bugs found, missing requirements, design changes, code quality issues
- Loads previous context (project paths, branches) from saved state — avoids re-asking
- Plans fixes, presents to user for approval
- Implements the minimum changes needed
- Verifies with Playwright (if app running)
- Generates
jira-{KEY}-review-fix-report.html - 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
- Fetches all Scrum teams from Jira (dynamically, not hardcoded)
- User picks a team or "All teams"
- Fetches current sprint tickets (assigned to user or unassigned)
- Presents prioritized table with ticket details
- User selects: all / specific / only mine / only unassigned
- Processes each ticket through the full 5-phase /jira pipeline
- Continue / Skip / Stop controls between tickets
- Sprint summary at the end
Uses:
/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
- Pipeline posts a question on Jira (@mentions reporter)
- Automatically enters watch loop — polls every 2 minutes
- Ignores its own comments (from the authenticated user)
- When reply detected: analyzes if it answers the question
- If answered: auto-resumes pipeline from where it paused
- If counter-question: presents to user, can draft AI response or let user type, posts it, continues watching
- If pipeline needs more info after resuming: posts another question → watches again
- 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
| ProjectType | Stack | Role Assumed |
|---|---|---|
| GAME | Unity (C#) | Senior Unity Game Developer |
| GAME | Unreal (C++) | Senior Unreal Engine Developer |
| GAME | Godot | Senior Godot Developer |
| APPLICATION | React/.NET/Java/Python | Senior {framework} App Developer |
| SAAS | Any web stack | Senior SaaS Platform Developer |
| API | Any backend | Senior API Developer |
| MOBILE | React Native/Flutter/Swift/Kotlin | Senior Mobile Developer |
The Plan → Design → Implement Flow
- Analyze — reads 3-5 existing files first to understand conventions. Identifies files to create/modify, detects if UI changes needed
- Design mockups (if UI) — create artboards in Paper via MCP, capture screenshots
- Generate HTML plan —
reports/feature-plan.htmlwith embedded Paper screenshots, technical plan, API contracts, testing plan. Auto-opens in browser for review. - User approval gate — Accept / Adjust / Redesign / Cancel
- BEFORE screenshots (if app running) — captures current state with Playwright before any changes
- Implement — follows the HTML plan. For large features, can spawn parallel Frontend + Backend agents. All agents match existing code style.
- Code analysis — reviews the diff for security issues, logic errors, dead code. Auto-fixes critical issues.
- Verify (if app running) — auto-offers Playwright E2E verification. Takes AFTER screenshots, generates before/after comparison.
- 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:
/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:
| ProjectType | Theme |
|---|---|
| GAME | Dark bg, neon accents, glow effects, “Patch Notes” style, ADDED/FIXED/PATCHED labels. Adapts to genre (pixel, dark fantasy, sci-fi) |
| APPLICATION | Clean white, blue accent, corporate timeline, FEATURE/BUG FIX labels |
| SAAS | Minimal indigo, product update feel, feature highlights |
| API | Dark terminal, green/cyan, technical changelog with code blocks |
| MOBILE | App-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:
/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
| Mode | Flag | What It Does |
|---|---|---|
| Consult | (default) | Query all models, get synthesized recommendation with consensus areas, divergent opinions, and implementation plan |
| Code | --code | All 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 | --debate | Models argue opposing positions. Claude moderates, identifies strongest/weakest arguments, delivers verdict. |
| Config | --config | Interactive setup for API keys (OpenAI + Google AI). Saves to .claude/council.env, auto-adds to .gitignore. |
| Cost | --cost | Show total API usage: calls, tokens, estimated cost across all council sessions. |
Model Tiers
| Tier | ChatGPT | Gemini | Best For |
|---|---|---|---|
| budget (default) | gpt-4o-mini | gemini-2.0-flash-lite | Quick opinions, routine decisions (~$0.001) |
| balanced | gpt-4o | gemini-2.5-flash | Architecture decisions, tech choices (~$0.01-0.05) |
| pro | o3-mini | gemini-2.5-pro | Critical decisions, complex trade-offs (~$0.05-0.50) |
How Synthesis Works
- Claude forms own opinion FIRST — before reading other responses (prevents anchoring bias)
- Reads ChatGPT and Gemini responses
- Identifies: consensus areas, unique insights per model, blind spots, disagreements
- Synthesizes unified recommendation incorporating the best from all perspectives
- Rates confidence: HIGH (all agree), MEDIUM (minor disagreements), LOW (fundamental disagreement)
Flags
| Flag | Description |
|---|---|
--models gpt,gemini | Which models to consult (default: both) |
--tier budget|balanced|pro | Model quality tier (default: budget) |
--code | Code implementation comparison mode |
--review {file} | Multi-model code review mode |
--debate | Adversarial debate mode |
--context "text" | Extra project context for all models |
--config | Set up API keys |
--cost | Show 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
- Questions — asks about stack preference, features for v1, auth needs, design style, where to create the project
- Architecture — designs directory structure, database schema, API endpoints, component architecture
- UI Design in Paper — creates 3-5+ screens in Paper via MCP (login, dashboard, feature pages, mobile). Takes screenshots.
- HTML Plan — generates
reports/project-plan.htmlwith ALL Paper screenshots embedded, architecture docs, API spec, DB schema. Auto-opens in browser. - User Approval — Build / Adjust / Redesign / Change stack / Cancel
- Build — scaffolds project, launches Backend Dev + Frontend Dev agents, Code Analyst reviews
- Quality Loop — Security Auditor + Quality Engineer scan, Backend Dev fixes, Test Engineer tests, re-scan until clean
- Verify — builds, starts the app, runs Playwright E2E verification with screenshots
- Docker (if requested) — creates Dockerfiles, docker-compose.yml, builds and verifies
- Delivery Report — generates
reports/project-delivery-report.htmlwith 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
- Planning — ask for project paths, analyze codebase, draft feature plan, user approval gate
- Visual Capture — screenshot existing app with Playwright (if running)
- Design in Paper — UI Designer agent creates mockups via MCP, user reviews and approves
- Implementation — Frontend + Backend agents work in parallel, Code Analyst reviews diff
- Report — Documentation Lead compiles master HTML report
- 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
- Parallel Scan — Security Auditor + Quality Engineer run simultaneously
- Fix — Backend Developer fixes all findings (Critical → Warning → Info)
- Test — Test Engineer writes tests for every fix, runs until green
- Verify — Re-run both scans. New issues? Loop back. Zero findings? Done.
- 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/stringifyclones, filter-in-memory-vs-SQL, render-time allocation,setStatein loops, repeatedfind/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:
/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
| Mode | What 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-ignored | Find @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
- Reads the “How to Verify” section from the report (
/create,/bug, or/jiraoutput) - Translates each step into Playwright actions (navigate, click, fill, assert)
- Logs in using the project profile auth config
- Takes BEFORE screenshots
- Performs each verification step
- Takes AFTER screenshots
- Visually analyzes screenshots for confirmation
- 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
- Executive Summary — what the branch does, scope, risk assessment
- Changes by Category — new features (green), bug fixes (amber), refactoring (blue), config (gray), database (purple), styling (cyan), tests (teal)
- Files Changed — table with file, change type, category, summary
- Screenshots — if app is running, captures affected pages with Playwright
- 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.
- Commit History — all commits with hash, author, date, message
- 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:
- Reads both versions (HEAD and incoming)
- Analyzes what each side is doing
- Resolves: both needed (merge both), incoming preferred, current preferred, or needs human review
- Removes all conflict markers
- 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
| Flag | Description |
|---|---|
--auto-setup | Skip all prompts, clone + install + build + test automatically |
--search "text" | Filter repos by name, description, topics, README content |
--analyze-only | Report 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
ghaccounts, 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
| Flag | Description |
|---|---|
--org {url} | Scan all repos in a GitHub organization |
--local-scan {path} | Scan repos already cloned on local disk |
--repos repo1,repo2 | Only 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
- Resolve repos — fetch from GitHub org, scan local disk, or use specified repos
- Extract keywords — parse the description into entities, actions, layers, search patterns
- Deep scan each repo — search for models, DTOs, controllers, endpoints, serializers, tests. Read matching files to understand what they do.
- Classify impact per file — change type (add/modify/create), priority (must/should/consider), complexity (simple/medium/complex)
- Map dependencies — determine implementation order (shared libs first, then backends, then frontends)
- 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:
- Reads the scan report HTML to extract repos, files, changes
- Clones/pulls all affected repos
- Creates identical feature branches in each repo (LOCAL ONLY)
- Installs dependencies
- Implements changes in dependency order (spawns agents per repo)
- Builds all repos, runs tests
- Starts all services locally
- 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.htmlimplements 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
- Code Quality Loop — /dev-team iterative scan/fix/test
- Playwright E2E — browser tests, failure triage, coverage gaps
- Docker Pipeline — build, deploy, integration tests against live container
- 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