Bazinga

# BAZINGA - Parallel AI Development Teams for Claude Code > **Repository:** https://github.com/mehdic/bazinga **One request → Multiple AI developers working simultaneously → Done 3x faster.** BAZINGA coordinates teams of AI agents to build software in parallel, aiming for one-shot execution when possible—powered by [Agentic Context Engineering](#core-philosophy-agentic-context-engineering). While traditional AI coding assistants work sequentially, BAZINGA analyzes your request, breaks it into independent tasks, and spawns multiple developers to work simultaneously—just like a real dev team. --- ## What Makes This Different This isn't a collection of agents you invoke one by one. BAZINGA is a complete development framework where a Project Manager analyzes your request, decides the optimal approach, and coordinates the entire workflow autonomously. The framework adapts to each task: it determines parallelism based on task independence, escalates to more powerful models when problems persist, and enforces quality gates automatically. You describe what you need; the system handles the how. Whether it helps you ship better software is something you'll have to judge for yourself. --- ## Core Philosophy: Agentic Context Engineering BAZINGA is strictly architected on the principles of **Agentic Context Engineering (ACE)**, solving the "infinite context fallacy" where larger context windows lead to signal dilution and reasoning drift. Instead of treating memory as a simple chat log, BAZINGA implements a **Tiered Memory Model** (Working Context, Sessions, Memory, Artifacts) inspired by research from Google's ADK and Anthropic. - **Context as a Compiled View:** Every agent prompt is dynamically compiled from the database, projecting only the minimal, relevant slice of history needed for the specific task. - **State Offloading:** Heavy research and file contents are offloaded to **Context Packages** (Artifacts), preventing token bloat. Agents receive pointers to this data and must actively "read" it, keeping the working context clean. - **Reasoning Capture:** We separate *what* happened (Interaction Logs) from *why* it happened (Reasoning Logs), allowing agents to evolve strategies without carrying the full weight of execution history. ### The Problem & Solution  *The "Infinite Context" Fallacy vs. the Compiled View Architecture—why bigger context windows don't equal better performance.* ### BAZINGA's Implementation  *How BAZINGA implements the 9 scaling principles: tiered memory, state offloading, schema-driven summarization, and sub-agent isolation.* For a detailed breakdown of the theory and our implementation, see the [Agentic Context Engineering Reference](docs/reference/agentic_context_engineering.md). --- ## See It In Action ```bash /bazinga.orchestrate implement JWT authentication, user registration, and password reset # (or: @orchestrator implement JWT authentication, user registration, and password reset) ``` **What happens:** ``` PM: "Analyzing request... 3 independent features detected" PM: "Spawning 3 developers in parallel" ┌─────────────────────┬─────────────────────┬─────────────────────┐ │ Developer 1 (JWT) │ Developer 2 (Reg) │ Developer 3 (Pwd) │ ├─────────────────────┼─────────────────────┼─────────────────────┤ │ ✓ Implementation │ ✓ Implementation │ ✓ Implementation │ │ ✓ Unit tests │ ✓ Unit tests │ ✓ Unit tests │ │ ✓ Security scan │ ✓ Security scan │ ✓ Security scan │ │ ✓ Lint check │ ✓ Lint check │ ✓ Lint check │ │ ✓ Coverage check │ ✓ Coverage check │ ✓ Coverage check │ │ ✓ Code review │ ✓ Code review │ ✓ Code review │ └─────────────────────┴─────────────────────┴─────────────────────┘ PM: "BAZINGA! All features complete in 18 minutes" (Sequential would've taken 60 minutes) ``` **Result:** 3 features implemented, tested, security-scanned, and reviewed—all in parallel. --- ## Quick Start ```bash # Option 1: Create new project uvx --from git+https://github.com/mehdic/bazinga.git bazinga init my-project cd my-project /bazinga.orchestrate implement user authentication with JWT # Option 2: Initialize in current directory cd your-existing-project uvx --from git+https://github.com/mehdic/bazinga.git bazinga init --here /bazinga.orchestrate implement user authentication with JWT # Note: You can also use @orchestrator instead of /bazinga.orchestrate if you prefer ``` That's it. No configuration needed. BAZINGA automatically: - ✅ Analyzes task complexity and independence - ✅ Spawns 1-4 developers based on parallelization opportunities - ✅ Runs security scans, lint checks, and test coverage - ✅ Reviews code quality with Tech Lead - ✅ Escalates to more powerful models (Opus) for difficult problems ### Advanced Mode (Optional) For complex or ambiguous requests, use the enhanced orchestration command: ```bash /bazinga.orchestrate-advanced "improve our authentication system" ``` **What it does:** 1. **Clarifies** ambiguous requests through interactive Q&A 2. **Discovers** existing codebase infrastructure and patterns 3. **Assesses** complexity, risks, and parallelization opportunities 4. **Structures** enhanced requirements for the PM This adds 2-4 minutes upfront but provides better decisions, fewer revisions, and prevents issues by identifying risks early. Use for complex features, new architecture, or unclear requirements. --- ## How It Works ### The Team BAZINGA coordinates 9 specialized AI agents: 1. **Tech Stack Scout** - Auto-detects project technology stack, frameworks, and versions before development begins 2. **Project Manager (PM)** - Analyzes requirements, breaks down work, decides parallelism 3. **Requirements Engineer** - Clarifies ambiguous requests, discovers codebase patterns, assesses complexity (used with `/orchestrate-advanced`) 4. **Developers (1-4)** - Implement code in parallel, create tests, fix issues 5. **Senior Software Engineer (SSE)** - Handles medium-to-complex tasks (complexity 4-10), security-sensitive code, and architectural work; escalation target when Developers get stuck 6. **QA Expert** - Runs integration/contract/E2E tests (optional, advanced mode) 7. **Tech Lead** - Reviews code quality, security, architecture; classifies problem complexity 8. **Investigator** - Deep-dive systematic investigation for complex multi-hypothesis problems (spawned by Tech Lead) 9. **Orchestrator** - Routes messages between agents, maintains workflow, manages investigation loops All agents are enhanced with **72 technology specializations** covering languages, frameworks, databases, and infrastructure—ensuring each agent receives context-appropriate expertise for your project's tech stack. ### The Workflow ``` Your request ↓ PM analyzes → Detects N independent tasks ↓ Spawns N developers in parallel ↓ Each developer: - Implements feature - Writes unit tests - Runs security scan - Runs lint check - Measures coverage ↓ Tech Lead reviews → Classifies problem complexity ↓ ├─ Simple (80%) → Standard review → Approve/Request changes ├─ Complex (15%) → Apply framework → Approve/Request changes │ • Root Cause Analysis (5 Whys + Hypothesis Matrix) │ • Architectural Decision Analysis │ • Performance Investigation │ • Flaky Test Analysis │ • Security Issue Triage └─ Investigation Required (5%) → Spawn Investigator ↓ Investigation Loop (max 5 iterations): 1. Investigator analyzes hypothesis matrix 2. Decides action (diagnostic code, testing, analysis) 3. May spawn Developer for diagnostic changes 4. Returns findings and updated hypotheses 5. Repeat until root cause found or blocked ↓ Tech Lead validates findings ↓