convez.ai
Agente
baard-ovrebo

claude-agent-team

baard-ovrebo/claude-agent-team

Ver no GitHub
InicialPluginScore · de 0 a 100

AI development team built on Claude Code — 21 slash commands that orchestrate specialized agents for Jira, design, implementation, testing, and deployment

Instalação

$npx convez-ai baard-ovrebo/claude-agent-team

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
0
Forks
0
Acompanhando
0
Saúde
42%
Último commit
há 5 meses
Versão
—
Issues abertas
0
Contribuidores
1

README

A tradução para o português deste README ainda está na fila.

Claude Agent Team

An AI development team built on Claude Code — 32 slash commands that orchestrate specialized AI agents to manage Jira tickets, design UIs, implement features, fix bugs, verify with Playwright, review code, run tests, audit dependencies, sync branches, onboard repositories, generate changelogs, enforce code reuse via a project rules file, containerize, and deploy.

Enforces Rule Z — Code Quality at five layers (mandate + hard rule + agent-level quality bar + runtime hooks + external Quality Gate service) so AI-generated code is production-optimized, not just working. Measured result: 98–100% reduction in anti-patterns + 25% fewer DOM nodes at runtime vs no-Rule-Z baseline.

No framework. No SDK. No infrastructure. Just Markdown files that become executable pipelines (plus optional Python hooks for runtime enforcement).

Last updated: 2026-04-14 · Rule Z v3

Full Command Reference Guide — comprehensive interactive documentation for every command with usage examples, flags, relationships, and architecture diagrams.

Also available: Benchmark Results | Initial Benchmark | Architecture Deep Dive | Flow Diagrams | Skills Reference

What This Is

A collection of custom Claude Code commands (Markdown files in .claude/commands/) that turn Claude into a coordinated team of AI agents:

AgentRole
OrchestratorPlans work, asks user, coordinates agents
UI DesignerCreates mockups in Paper.design via MCP
Frontend DeveloperImplements UI from approved designs
Backend DeveloperImplements APIs, DB, middleware
Security AuditorOWASP Top 10 vulnerability scanning
Quality EngineerCode smells, anti-patterns, dead code
Test EngineerUnit tests across 9 language stacks
Code AnalystGit diff security + quality review
E2E Verification EngineerPlaywright verification with screenshots
Documentation LeadCompiles HTML reports
Merge Conflict ResolverAnalyzes and resolves Git conflicts
Onboarding EngineerAnalyzes repos and sets up dev environments
Council ChairConsults ChatGPT + Gemini for multi-model decisions

Commands

Project Management

CommandDescription
/jira FO-2847Full ticket-to-resolution: fetch, analyze JAM recordings, classify, design, implement, review, verify, report, update Jira
/jira sprintBatch process sprint tickets — fetches Scrum teams dynamically, user picks team, processes each ticket
/jira teamsList all available Scrum teams from Jira
/jira watch FO-2847Poll a ticket for new comments — auto-entered when pipeline posts a question, auto-resumes on reply
/jira resume FO-2847Resume a paused ticket from a saved state file (new session)
/jam {url}Analyze JAM bug recordings via MCP — video analysis, console logs, network requests, user events
/tempoLog time to Jira (/tempo addTime FO-2847 2h "Bug fix")

Universal (work in any project)

CommandDescription
/prompt "task"Rules-governed prompt — runs any task through a project's rules file (.claude/prompt-rules.env + global ~/.claude/prompt-rules.env). Forces the AI to search for and reuse existing components/classes/utils (or promote a local one to shared and migrate all usages) before creating anything new
/prompt --add-rule "text"Append a rule from the CLI. Add --project <name> to scope it to one project, --global to write the global file. /prompt --list-rules shows what's active
/create "description"Context-aware feature creator: detects project type, designs in Paper, generates HTML plan, gets approval, implements, verifies with Playwright. Supports --council for multi-model consultation
/bug "description"Context-aware bug fixer: analyzes screenshots, diagnoses root cause, fixes, verifies with Playwright
/changelogReads reports from /create and /bug, generates project-themed HTML changelog (adapts to GAME/APPLICATION/SAAS/API/MOBILE), moves to processed
/council "question"LLM Council — consults ChatGPT + Gemini in parallel, Claude synthesizes unified recommendation. Modes: consult, --code, --review, --debate. Tiers: budget/balanced/pro
/council --configSet up API keys for ChatGPT and Gemini
/create-project "description"Full project creator: questions → Paper design → HTML plan → build with full agent team → test → verify → deliver
/reportAnalyze all branch changes, generate Jira-ready HTML report with QA testing instructions, optional upload to Jira ticket
/report FO-2847Same + auto-upload report and screenshots to the specified Jira ticket
/verifyE2E verification with Playwright — uses project profile for login, takes before/after screenshots, generates HTML report with clickable lightbox

Feature Development

CommandDescription
/new-feature6-phase pipeline: plan → screenshot → design in Paper → parallel implementation → code review → report
/code-analysisReview only the git diff for security + quality issues, auto-fix critical problems

Code Quality (Iterative Loop)

CommandDescription
/dev-teamIterative: scan → fix → test → re-scan until zero findings
/quality-scanRule Z scanner — finds AI "works but wasteful" patterns: allocations in hot paths, N+1 queries, linear scans, memory leaks, GPU waste. Grades A–F
/quality-scan --groupScan all linked projects + cross-project issues (frontend re-fetching, duplicate validation, over-fetching)
/security-auditStandalone OWASP Top 10 scan
/quality-auditStandalone code quality scan
/fix-allFix all findings from audit reports
/test-allWrite tests for all fixes
/master-reportCompile all reports into master HTML

Testing & Dependencies

CommandDescription
/unit-test *Full project test coverage scan + gap filling
/unit-test --fix-ignoredFind and rehabilitate disabled/skipped tests — user selects which to unignore and fix
/unit-test {file}Create tests for a specific file or class
/playwright-testRun Playwright E2E browser tests
/depsDependency health audit: CVEs (with exploitability check), outdated packages, license risks (grade A–F)

Git Operations

CommandDescription
/git sync developMerge latest from a branch into current — pre-flight checks, fetch, merge
/git sync develop --fix-merge-errorsSame + auto-resolve conflicts with AI analysis per file
/git sync develop --allSync all projects in the project map
/git statusQuick branch overview: ahead/behind, uncommitted changes, stashes

Repository Onboarding

CommandDescription
/repo-setup {url}Clone a repo, analyze stack, install deps, configure env, build, test, start — produces HTML setup guide
/repo-setup https://github.com/orgScan entire GitHub org — map all repos, relationships, architecture diagram, startup order
/repo-setup {org} --auto-setupAuto-clone, install, build, test ALL repos without prompting
/repo-setup {org} --search "API"Filter org repos by name, description, topics, or README content
/repo-setup {url} --analyze-onlyReport only, don't install anything
/repo-setup --local-scan D:\ProjectsScan repos already on disk instead of cloning
/impact-scan "description"Scan all org repos to find where a change needs to be implemented — per-repo file-level analysis
/impact-scan "desc" --org {url}Same, targeting a specific GitHub org
/impact-scan "desc" --local-scan {path}Same, scanning repos already on disk
/impact-scan --apply report.htmlApply a scan report: clone repos, create local branches, implement all changes, build, start services. Local only — never pushes.

Docker Pipeline

CommandDescription
/docker-buildBuild + validate Docker image
/docker-deployDeploy with docker compose
/docker-testIntegration tests against live container
/docker-teardownGraceful cleanup
/full-pipelineAll of the above: dev-team + Playwright + Docker + report

Key Features

Jira Pipeline — Ticket to Resolution

  • Fetches full ticket details, downloads and auto-resizes image attachments
  • Auto-detects JAM links in tickets and analyzes bug recordings via MCP
  • Reads and analyzes comments — extracts additional requirements, identifies unanswered questions
  • @mentions the reporter on Jira if info is missing, then automatically enters watch loop to wait for reply
  • Watch mode — polls every 2 min, auto-resumes pipeline when reporter answers, supports back-and-forth dialogue
  • State persistence — saves full pipeline state to JSON for cross-session resume
  • Git branch setup — lists available branches, user picks base and names the new branch
  • Design in Paper — creates mockups via MCP, user approval gate before any code is written
  • Parallel implementation — Frontend + Backend agents work simultaneously
  • E2E verification — auto-offers Playwright verification after implementation
  • Status reporting — every agent prints [Agent Name] what it's doing... in real time

Universal Commands — /create, /bug, /verify

  • Context-aware roles — reads ProjectType from .claude/.env (GAME, APPLICATION, SAAS, API, MOBILE), adapts to Senior Unity Dev, Senior React Dev, etc.
  • HTML plan with Paper mockups — /create generates reports/feature-plan.html with embedded design screenshots before implementing. User reviews in browser.
  • E2E verification — after implementation, both /create and /bug auto-offer Playwright verification if the app is running
  • Project profile — /verify builds .claude/project-profile.json on first run (login URL, selectors, test user). Reused for all future verifications.
  • Self-contained HTML reports — all screenshots embedded as base64, clickable lightbox for full-size viewing
  • Changelog pipeline — /create and /bug save timestamped reports → /changelog compiles them into a project-themed HTML changelog
  • Project design profile — all HTML reports adapt their visual design to match the project. Design settings stored in .claude/project-profile.json. Auto-generated per ProjectType: dark neon for games, clean corporate for apps, terminal-style for APIs

Rules-Governed Prompt — /prompt

  • Reuse enforced, not hoped for — before writing any code, /prompt forces the AI to search the project for an existing component/class/function/util and follow a strict order: use a shared version if it exists → else promote a local/duplicate to shared and update every usage → else create new (as shared). The goal is one implementation, one style, used everywhere — no duplication.
  • Rules live in a plain file — .claude/prompt-rules.env (project) and ~/.claude/prompt-rules.env (global), combined at runtime. One rule per line; edit in plain English with no code changes. Copy /.claude/prompt-rules.example.env to get started.
  • Per-project tags — [project: <name>] sections scope rules to a single project (matched by git-repo/folder name), so one global file can carry pointer rules for many projects. Pointer rules (e.g. "shared components live in src/app/shared — check there first") are what make reuse reliable in large codebases.
  • Manage from the CLI — /prompt --add-rule "..." (deduplicated, with optional --project/--global) and /prompt --list-rules.
  • Transparent & auditable — prints which rules it loaded, reports its reuse scan, and ends with a per-rule ✅/⚠️/❌ compliance checklist.

Repository Onboarding

  • Single repo mode — detects stack, installs deps, configures env, sets up DB, runs migrations, builds, tests, starts dev server
  • Organization scan — fetches all repos via GitHub API, analyzes each, maps inter-repo relationships
  • GitHub account switching — lists all authenticated gh accounts, user picks which to use
  • Search filtering — --search "text" filters repos by name, description, topics, README content
  • Auto-setup — --auto-setup skips all prompts, processes everything in dependency order
  • Architecture diagram — CSS visual showing repos as color-coded boxes with connection lines
  • HTML setup guide — 12-section document with prerequisites, quick start, step-by-step, env vars, architecture, testing, troubleshooting

Git Operations

  • Pre-flight checks — uncommitted changes detection, stash option, branch existence verification
  • AI conflict resolution — per-file analysis with confidence levels (high/medium/needs-human-review)
  • Lock file regeneration — auto-regenerates package-lock.json, yarn.lock, poetry.lock, go.sum after merge
  • Multi-project sync — syncs across frontend + backend repos simultaneously

Rule Z — Code Quality Enforcement (applies to ALL code-writing commands)

AI-generated code has a documented tendency to produce "works but wasteful" implementations — rebuilding entire lists when one item changed, loading all data then filtering in memory, setState in loops, creating functions inside render, fetching data the backend already cached. Rule Z prevents this.

Measured result (12-build benchmark): Rule Z v3 reduces AI anti-patterns by 98–100% vs a no-Rule-Z baseline (60.67 → 0.00-1.33 per build across 3 runs each), and produces 25% fewer DOM nodes at runtime. Mount time is unchanged — zero performance penalty from the extra structure. See benchmark results for the full A vs v1 vs v2 vs v3 comparison.

Every command that writes code (/create, /bug, /jira, /new-feature, /create-project, /fix-all, /dev-team, /full-pipeline, /impact-scan --apply, /code-analysis, /unit-test) enforces a four-layer quality model:

  1. Mandate (prompt text) — performance, resource efficiency, and code structure standards explained up-front

  2. Hard Rule (orchestrator level) — "Rule Z" at same enforcement level as "never force-push to main"

  3. Agent-level [QUALITY BAR — NON-NEGOTIABLE] block — injected into every sub-agent prompt so the agents themselves see "your code will be REJECTED if..."

  4. Runtime hooks (optional but recommended) — see hooks/ for four Python hooks that enforce the rule at runtime:

    • quality-audit-check.py — blocks sub-agent completion if ## Quality Audit section is missing from the report
    • quality-audit-verify.py + ast-verify.mjs — Rule Z v3 — parses the YAML audit block and cross-checks each claim (memoized components, useCallback handlers, hoisted style consts, Set/Map uses, cleanup) against the actual code. Uses TypeScript's AST when available, falls back to improved regex. Fabricated claims fail and block.
    • quality-reminder.py — prepends Rule Z reminder to every user prompt so it stays in short-term context
    • quality-gate-check.py — calls the external Quality Gate service (see layer 5) for linter + fresh reviewer verdict
  5. External Quality Gate service (strongest layer) — see quality-gate/ for a standalone HTTP service that runs four independent checks on every agent code change:

    • Linter pass (ESLint, ruff/pylint, go vet, cargo clippy, dotnet format, rubocop, phpstan) — mechanical issues the AI might overlook
    • Project analysis — scans the existing codebase, builds an index of all exported functions/components/types, detects style conventions. Flags new code that duplicates existing functionality (e.g., agent writes formatDate when @/utils/dates.ts already exports it) or breaks the project's style conventions (indent, quotes, file naming)
    • Fresh Claude reviewer — independent Claude instance with NO knowledge of the original agent's reasoning, reviews the diff cold (prevents anchoring bias)
    • Optional human review queue — web UI at http://127.0.0.1:7733/ for items flagged for human approval. When a change requires human review, the hook polls the service and waits (default 10 min, configurable) for your Approve / Reject / Defer decision before allowing or blocking the agent turn. Progress is printed to stderr every 30 seconds so you can see the session is still alive.

    The gate returns PASS, FAIL (with specific findings), or HUMAN_REVIEW_REQUIRED. The hook uses the verdict to allow or block the sub-agent turn. Install via Docker: cd quality-gate && docker compose up -d

Every agent report MUST include a ## Quality Audit section covering: hot paths, data structures, cleanup, caching, batching, memory at 10x/100x scale, and what shortcuts were rejected. The orchestrator is instructed to reject reports missing this section and re-dispatch.

/quality-scan (command) — hunts down existing Rule Z violations across a project or linked group. Finds allocations in hot paths, N+1 queries, linear scans, memory leaks, GPU waste, wrong data structures. Grades the codebase A–F. Can auto-fix or create Jira tickets for findings. Includes cross-project analysis in --group mode (frontend re-fetching backend-cached data, duplicate validation, over-fetching, chatty APIs).

Install the runtime hooks: See hooks/README.md for settings.json configuration. Without the hooks, enforcement relies on the LLM following its prompt (strong but soft). With the hooks, the Quality Audit is enforced at runtime — the AI cannot skip it.

Domain-specific profiles at .claude/profiles/ — five specialized Quality Bar profiles for different stacks:

  • quality-bar-frontend-react.md — React-specific (style allocations, memoization, useMemo/useCallback)
  • quality-bar-backend-node.md — Node.js backend (N+1 queries, connection pooling, streaming)
  • quality-bar-backend-dotnet.md — .NET/EF Core (AsNoTracking, async propagation, HttpClientFactory)
  • quality-bar-game-unity.md — Unity C# (GetComponent caching, object pools, GC-free Update loops)
  • quality-bar-mobile.md — Mobile (virtualized lists, image sizing, battery awareness)

Each profile has domain-specific counter-patterns with before/after snippets and a machine-checkable YAML audit schema tailored to that domain.

LLM Council — Multi-Model Decisions

  • Parallel queries — consults ChatGPT (OpenAI) and Gemini (Google AI) simultaneously via their APIs
  • Anchoring bias prevention — Claude forms its own opinion FIRST before reading other models' responses
  • Smart auto-recommendation — /jira and /create automatically suggest council consultation for architecture decisions, migrations, performance-critical features, and ambiguous tickets
  • 4 modes — consult (default), --code (implementation comparison), --review (multi-model code review), --debate (adversarial moderation)
  • 3 tiers — budget (gpt-4o-mini + gemini-flash-lite), balanced (gpt-4o + gemini-2.5-flash), pro (o3-mini + gemini-2.5-pro)
  • Cost transparency — tracks token usage per model, shows estimated cost in each report
  • Graceful degradation — continues with available responses if one model fails or times out
  • Confidence ratings — HIGH when all models agree, LOW when fundamental disagreement exists
  • Synthesis — identifies consensus, divergent opinions, unique insights per model, blind spots

Reports & Screenshots

  • All HTML reports include a clickable screenshot lightbox — click any image to view full-size
  • Screenshots embedded as base64 — reports are self-contained, work offline, sharable via email
  • Reports are the primary deliverable — every command produces an HTML report as an audit trail

Setup

Prerequisites

  • Claude Code installed
  • Claude Code model: Opus 4.6 recommended (Sonnet works for simpler commands)

Installation

  1. Clone this repo into your working directory:

    git clone https://github.com/baard-ovrebo/claude-agent-team.git
    
  2. Copy commands to your project (or use globally):

    # Per-project: copy to your project's .claude/commands/
    cp -r claude-agent-team/.claude/commands/ /path/to/your/project/.claude/commands/
    
    # Global: copy to ~/.claude/commands/ (available everywhere)
    cp claude-agent-team/.claude/commands/*.md ~/.claude/commands/
    
  3. Configure credentials (for Jira/Tempo commands):

    cp .env.example .env
    # Edit .env with your Jira credentials
    
  4. Configure project type (for /create, /bug, /verify):

    # In your project's .claude/.env (or ~/.claude/.env for global):
    echo "ProjectType=APPLICATION" > .claude/.env
    # Values: GAME, APPLICATION, SAAS, API, MOBILE
    
  5. Configure MCP servers (optional, for JAM + Paper):

    # JAM bug recording analysis
    claude mcp add jam -- npx @anthropic-ai/jam-mcp
    
    # Paper.design UI mockups (requires Paper Desktop running)
    claude mcp add paper --transport http http://127.0.0.1:29979/mcp --scope user
    

Which Commands Need What

FeatureRequires
/jira, /tempo.env with Jira credentials
/jamJAM MCP server
/create, /new-feature (design phase)Paper MCP server (optional — skips design if unavailable)
/verifyPlaywright + running application + .claude/project-profile.json (built on first run)
/council.claude/council.env with OpenAI + Google AI API keys (run /council --config to set up)
/promptA rules file: .claude/prompt-rules.env and/or ~/.claude/prompt-rules.env (copy from .claude/prompt-rules.example.env)
/unit-test, /deps, /dev-teamNothing extra — works standalone
/create, /bug, /changelogNothing extra — works standalone (ProjectType in .env is optional)
/git syncGit installed (works standalone)
/repo-setup, /impact-scangh CLI for org scan, otherwise standalone
/docker-*Docker Desktop
/playwright-testNode.js + Playwright

How It Works

The Core Pattern

Each command is a Markdown file that describes a multi-phase pipeline. Claude reads the Markdown and executes it — spawning specialized sub-agents, coordinating their work through report files, and gating on user approval before expensive operations.

Agent Communication

Agents don't talk to each other directly. They communicate through reports/*.md files:

  1. Security Auditor writes → reports/security-audit.md
  2. Orchestrator reads it, passes to Backend Developer
  3. Backend Developer fixes issues, writes → reports/fixes-applied.md
  4. Orchestrator reads it, passes to Test Engineer
  5. And so on...

Real-Time Status Reporting

Every agent prints status lines before each major step:

[Orchestrator] Step 1/5 — Fetching ticket FO-2847 from Jira...
[Frontend Developer] Creating component: InvoiceExport.tsx...
[Backend Developer] Creating endpoint: POST /api/invoices/export...
[Code Analyst] Reviewing git diff (4 files changed)...
[Verify] Step 3/10: Checking URL field exists — PASS

Key Design Principles

  • Always ask for project paths — never guess which codebase to work in
  • User approval gates — plan and design must be approved before coding starts
  • Parallel where possible — Security + Quality scan simultaneously, Frontend + Backend build simultaneously
  • Iterative loops — scan → fix → re-scan until clean (not single-pass)
  • Stack-agnostic — runtime detection adapts to Java, C#, JS, Python, Go, Rust, PHP, Ruby
  • State persistence — paused pipelines can be resumed from new sessions
  • Always generate reports — every pipeline produces an HTML report as an audit trail
  • Clickable screenshots — all HTML reports include a lightbox for full-size image viewing
  • Mandatory phase execution — commands enforce "DO NOT SKIP" rules for critical phases

Documentation

Project Structure

.claude/
  prompt-rules.example.env # Template for /prompt rules (copy to prompt-rules.env)
  commands/
    prompt.md            # Rules-governed prompt (forces reuse before creating)
    jira.md              # Jira ticket orchestrator (the biggest pipeline)
    new-feature.md       # Feature development pipeline
    create.md            # Universal feature creator (role-adaptive)
    create-project.md    # Full project creator (idea to running app)
    bug.md               # Universal bug fixer (role-adaptive)
    verify.md            # E2E Playwright verification with project profile
    report.md            # Branch change report with QA test cases + Jira upload
    impact-scan.md       # Cross-repo impact analysis for change requests
    changelog.md         # Changelog generator from /create and /bug reports
    repo-setup.md        # Repository onboarding & org scanner
    unit-test.md         # Unit test engineer (9 stacks, --fix-ignored)
    deps.md              # Dependency health auditor (A-F grading)
    git.md               # Git operations (sync, conflict resolution)
    dev-team.md          # Iterative quality loop (5 agents)
    full-pipeline.md     # End-to-end delivery pipeline
    jam.md               # JAM bug recording analyzer (MCP)
    tempo.md             # Jira time tracking
    code-analysis.md     # Git diff code reviewer
    security-audit.md    # OWASP Top 10 scanner
    quality-audit.md     # Code quality scanner
    fix-all.md           # Automated issue fixer
    test-all.md          # Test writer + runner
    master-report.md     # HTML report compiler
    playwright-test.md   # E2E browser test runner
    docker-build.md      # Docker image builder
    docker-deploy.md     # Docker deployment
    docker-test.md       # Container integration tests
    docker-teardown.md   # Docker cleanup
docs/                    # HTML documentation, diagrams, command guide
reports/                 # Generated reports (gitignored)
.env.example             # Credential template

License

MIT

Author

Bård Øvrebø — Control Team, Finago

Ver o original no GitHub

Bom para

Relacionados