A sophisticated multi-agent command system for AI-assisted development workflows, built on Claude Code's extensible architecture.

This project provides a comprehensive set of Claude Code commands that implement multi-agent workflows for software development, including planning, execution, code review, and documentation management. The system uses GNU Stow for deployment and provides opinionated tool restrictions for optimal performance.

# Clone the repository
git clone <repository-url> ai-config
cd ai-config

# Install using Stow (deploys to $HOME)
just install

Note on Configuration Directory: This project uses XDG-compliant paths (~/.config/claude). Since Claude Code reverted to using ~/.claude as the default, you have two options:

1. Manually copy the configuration from claude/.config/claude/ to $HOME/.claude/
2. Set CLAUDE_CONFIG_DIR in your shell configuration

export CLAUDE_CONFIG_DIR="$HOME/.config/claude"

For more details, see Claude Code Issue #1455

# Show all available commands
just --list

# Install configuration
just install

• /user-plan - Multi-agent research and execution planning
• /user-review - Comprehensive pre-PR review with specialized agents
• /user-save - Session continuity and state management

• /user-start - Begin execution from tasks.md
• /user-lint - Language-specific linting (Python, Go, TypeScript, SQL, Terraform)
• /user-test - Intelligent test execution with focused scope
• /user-git-commit - Logical commit creation with conventional commits
• /user-git-pr - GitHub PR creation with automated descriptions

• /user-docs-update - Keep documentation current with code changes
• /user-docs-refactor - Restructure and improve documentation
• /user-rules-update - Update coding patterns and rules

Final consolidated set of sub-agents (5 roles):

• Orchestrator — Defines requirements and coordinates execution
  • Creates comprehensive requirements.md and acceptance criteria
  • Manages cross-team dependencies and timelines
  • Ensures smooth handoffs and quality gates

• Backend Engineer — Server-side logic, APIs, data pipelines, and infrastructure

  • Python/Go/TypeScript services; REST/GraphQL endpoints
  • Data engineering with Polars; orchestration with Temporal
  • Infrastructure-as-code with Terraform across AWS/GCP/Azure

• Frontend Engineer — User interfaces with React/TypeScript

  • Responsive, accessible UI components
  • State management and API integration

• Machine Learning Engineer — Model development and deployment

  • Training pipelines and experiments
  • Inference performance and deployment

• Reviewer — QA, Code Review, and Security
  • Validates requirements, quality, and security in a single pass
  • Produces a consolidated report and remediation plan

1. Orchestrator creates requirements.md
2. System identifies which implementation agents are needed
3. Only relevant agents create execution plans in .claude/tasks/[agent-name]-tasks.md
4. Orchestrator synthesizes plans and identifies dependencies

1. Reads root tasks.md to identify active agents
2. Deploys only the agents working on current project
3. Orchestrator manages dependencies and parallel execution
4. Agents work independently on their task lists

Deploys the consolidated Reviewer:

• Reviewer validates functionality, code quality, and security

Findings are synthesized into tasks for implementation agents.

All active agents update their task lists with:

• Current progress and completion status
• Technical decisions made
• Blockers and dependencies
• New tasks discovered

graph TB
    subgraph Planning
        A["/user-plan<br/>Orchestrator + Relevant Agents"]
    end

    subgraph Execution
        B["/user-start<br/>Active Implementation Agents"]
        C["/user-lint<br/>Quality Checks"]
        D["/user-test<br/>Test Execution"]
    end

    subgraph Review
        E["/user-review<br/>Reviewer"]
    end

    subgraph Deployment
        F["/user-git-commit"]
        G["/user-git-pr"]
    end

    A --> B
    B --> C
    C --> D
    D --> E
    E --> B
    E --> F
    F --> G

    H["/user-save<br/>All Active Agents"] -.-> A
    H -.-> B
    H -.-> E

• Python: ruff, pyright, pytest
• Go: golangci-lint, go vet, go fmt
• TypeScript: eslint, vitest, tsc
• SQL: sqlfluff
• Terraform: terraform validate

• GitHub: PR creation and repository operations
• Linear MCP: Issue tracking and project management
• Sentry MCP: Error tracking and monitoring

Each command defines minimal tools in frontmatter using a single tools: line (comma‑separated):

ai-config/
├── justfile                    # Build automation
├── tasks.md                    # Root task registry (audits, summaries)
├── .stowrc                     # Stow configuration
├── .editorconfig              # Editor standards
├── .vscode/settings.json      # VS Code configuration
├── .claude/                   # Project-scoped runtime state
│   └── tasks/                 # Distributed task lists per agent
│       ├── backend-engineer-tasks.md
│       ├── frontend-engineer-tasks.md
│       ├── ml-engineer-tasks.md
│       ├── orchestrator-tasks.md
│       └── reviewer-tasks.md
└── claude/.config/claude/     # Claude Code configuration
    ├── settings.json
    ├── commands/              # Command definitions
    └── agents/                # Sub-agent definitions

The system implements sophisticated patterns for agent collaboration:

• Selective Deployment - Only agents relevant to the work are activated
• Distributed Task Management - Each agent maintains their own task list
• Parallel Execution - Agents work simultaneously when dependencies allow
• Cross-Domain Coordination - Orchestrator manages handoffs and dependencies
• Clear Boundaries - Each agent has exclusive authority over their domain:
  • Only Backend Engineer builds ETL pipelines and provisions infrastructure
  • Only Backend Engineer owns API documentation
  • Reviewer has read-only access

This project follows conventional commits and uses the integrated review system:

1. Plan changes with /user-plan
2. Execute with /user-start
3. Review with /user-review
4. Commit with /user-git-commit
5. Create PR with /user-git-pr