Multi AI Implementation

Multi-AI Implementation

Overview

multi-ai-implementation provides systematic code generation and incremental development using the proven Explore-Plan-Code-Commit workflow with built-in TDD, quality gates, and multi-agent coordination.

Purpose: Transform specifications into production-ready code through incremental, test-driven development

Pattern: Workflow-based (6-step sequential process)

Key Principles (validated by tri-AI research):

1. Explore Before Coding - Gather context first, never jump straight to implementation
2. Plan Architecture - Use multi-ai-planning before writing code
3. Incremental Development - Small changes (<200 lines), continuous testing
4. Test-Driven - Write/generate tests first, then implement
5. Quality Gates - Multi-layer validation before commit
6. Safe Rollback - Automatic revert on test failures

Quality Guarantee: Code generated through this workflow achieves ≥85/100 quality score with ≥80% test coverage

When to Use

Use multi-ai-implementation when:

• Implementing new features (>200 lines, multiple components)
• Refactoring existing code (maintaining backward compatibility)
• Migrating systems (database, framework, architecture changes)
• Integrating components (API, services, third-party libraries)
• Building complex functionality requiring testing and verification
• Multi-agent coordination needed for parallel development

When NOT to Use:

• Simple changes (<50 lines, single file, obvious implementation)
• Documentation-only changes
• Configuration tweaks (use fast-track workflow instead)

Prerequisites

Required

• Clear implementation specification or plan
• Test framework available (Jest, Vitest, pytest, etc.)
• Time allocated (2-8 hours depending on complexity)

Recommended

• multi-ai-planning - Create plan before implementation
• multi-ai-testing - Generate and execute tests
• multi-ai-verification - Quality validation before commit

Understanding

• Basic TDD concepts (test-first development)
• Git workflow (commits, branches, rollback)
• Testing frameworks for your language

Implementation Workflow

Step 1: Explore & Gather Context

Gather comprehensive context through progressive disclosure before writing any code.

Purpose: Understand existing system, patterns, and constraints

Inputs:

• Implementation objective or specification
• Existing codebase (if applicable)
• Design mockups (for UI features)
• API documentation (for integrations)

Process:

1. Progressive File Discovery:

   Use 3-level approach (never load everything):

   Level 1: Structure (Glob)

   # Map relevant files
   glob "**/*.{ts,js,py}" # Source files
   glob "**/test*.{ts,js,py}" # Test files
   glob "**/*auth*" # Domain-specific
   

   Level 2: Patterns (Grep)

   # Find specific patterns
   grep "export.*class.*Auth" --glob "**/*.ts"
   grep "describe\|it\(" --glob "**/*.test.ts"
   grep "TODO|FIXME" --glob "src/**"
   

   Level 3: Targeted Reading

   # Read only critical files
   read "src/auth/login.ts"
   read "src/auth/tokens.ts"
   read "tests/auth/login.test.ts"
   

2. Analyze Visual Mockups (for UI features):

   • Read design files/screenshots
   • Understand layout requirements
   • Note component hierarchy
   • Identify styling needs

3. Map Dependencies & Integration Points:

   # Integration Analysis
   
   **Components This Touches**:
   - src/auth/* (authentication logic)
   - src/api/routes.ts (API endpoints)
   - src/middleware/auth.ts (authorization)
   
   **External Dependencies**:
   - jsonwebtoken (JWT generation)
   - bcrypt (password hashing)
   
   **Integration Points**:
   - Database (users, tokens tables)
   - API (POST /login, POST /register)
   - Frontend (auth forms, protected routes)
   

4. Research Domain Patterns (optional - for unfamiliar domains):

   If using multi-ai-research:

   Use multi-ai-research for "Research [domain] implementation best practices and patterns"
   

   Manual research:

   • Search: "[domain] best practices 2024-2025"
   • Review: Official documentation
   • Find: 3-5 example implementations

5. Document Context Synthesis:

   # Context Synthesis
   
   ## Current State
   - [What exists now]
   - [Current patterns used]
   - [Existing tests]
   
   ## Desired State
   - [What should exist]
   - [New functionality needed]
   
   ## Constraints
   - Backward compatibility required
   - Must maintain existing API
   - Performance: <200ms response time
   
   ## Key Insights
   - [Pattern 1 found in codebase]
   - [Best practice from research]
   - [Integration consideration]
   

Outputs:

• Context synthesis document
• File inventory (relevant files identified)
• Pattern analysis
• Integration map
• Constraint documentation

Validation:

• Relevant files identified via progressive disclosure
• Existing patterns understood
• Integration points mapped
• Constraints documented
• Research conducted (if needed)
• Context comprehensive

Time Estimate: 30-60 minutes

Next: Proceed to Step 2

Step 2: Plan Architecture

Create detailed implementation plan using multi-ai-planning before writing any code.

Purpose: Think through architecture and approach before implementation

Inputs:

• Context synthesis (from Step 1)
• Implementation objective
• Success criteria

Process:

1. Invoke Multi-AI Planning:

   Use multi-ai-planning to create implementation plan for [objective]
   

   This will guide you through:

   • Objective analysis
   • Hierarchical task decomposition
   • Dependency mapping
   • Verification planning
   • Quality validation (≥90/100)

2. Review Generated Plan:

   Plan Review Checklist:
   - [ ] All requirements covered by tasks
   - [ ] Tasks decomposed to atomic level
   - [ ] Dependencies mapped correctly
   - [ ] Each task has success criteria
   - [ ] Verification methods defined
   - [ ] Quality score ≥90/100
   

3. Extract Implementation Sequence:

   # Implementation Sequence (from plan)
   
   Phase 1: Foundation (Tasks 1-2)
   - Task 1: Database schema
   - Task 2: Core models
   
   Phase 2: Business Logic (Tasks 3-4)
   - Task 3: Token management
   - Task 4: Authentication logic
   
   Phase 3: API Layer (Task 5)
   - Task 5: API endpoints
   
   Phase 4: Integration (Task 6)
   - Task 6: End-to-end integration
   

4. Identify Test Strategy (from plan verification):

   # Test Strategy
   
   **Test-First Approach**:
   - Generate tests before implementation
   - Confirm tests fail
   - Implement until tests pass
   
   **Coverage Targets**:
   - Gate (must pass): ≥80% line coverage
   - Target (desired): ≥95% line coverage
   
   **Test Types**:
   - Unit: Functions, classes
   - Integration: Components together
   - E2E: Complete workflows
   

5. Optional: Use Extended Thinking for Complex Decisions:

   • Press Tab for extended thinking mode
   • Evaluate multiple architectural approaches
   • Reason through trade-offs
   • Document decision with rationale

Outputs:

• Complete implementation plan (from multi-ai-planning)
• plan.json (machine-readable)
• PLAN.md (human-readable)
• Implementation sequence
• Test strategy

Validation:

• Plan created using multi-ai-planning
• Plan quality score ≥90/100
• All tasks have verification defined
• Implementation sequence clear
• Test strategy documented

Time Estimate: 30-90 minutes (most time in multi-ai-planning)

Next: Proceed to Step 3

Step 3: Incremental Implementation (TDD)

Implement features incrementally using test-driven development with continuous validation.

Purpose: Build quality code through small, tested increments

Inputs:

• Implementation plan (from Step 2)
• Context synthesis (from Step 1)
• Test strategy

Process:

1. For Each Task in Plan, Follow TDD Cycle:

   3.1. Generate Tests First (use multi-ai-testing):

   Use multi-ai-testing TDD workflow for Task [X]
   
   Specification:
   - [What this task should do]
   - Success criteria: [from plan]
   - Edge cases: [boundary conditions]
   

   This generates tests and confirms they FAIL.

   3.2. Implement to Pass Tests (incremental):

   // Implement feature incrementally
   // Target: <200 lines per commit
   // Keep tests running continuously
   
   // Example: Implement token generation
   export function generateToken(user: User): string {
     // 1. Basic implementation (30 lines)
     const payload = { userId: user.id };
     const token = jwt.sign(payload, process.env.JWT_SECRET);
     return token;
   }
   
   // Run tests → Some pass, some fail
   // 2. Add expiry (10 lines)
   // Run tests → More pass
   // 3. Add error handling (15 lines)
   // Run tests → All pass ✅
   

   3.3. Verify Tests Pass:

   # Run test suite
   npm test -- src/auth/tokens.test.ts
   
   # Check coverage
   npm run coverage -- --file=src/auth/tokens.ts
   
   # Verify ≥80% coverage
   

   3.4. If Tests Fail: Iterate:

   ## Iteration Loop (Max 3 Attempts)
   
   Attempt 1: Implement feature → Tests fail
      ↓ Analyze failure, adjust code
   Attempt 2: Fix implementation → Tests fail (different error)
      ↓ Analyze, adjust again
   Attempt 3: Final fix → Tests pass ✅
   
   If still failing after 3 attempts:
      ↓ HALT and request human review
      ❌ Doom Loop Prevention
   

   Doom Loop Breaker (Gemini recommendation):

   • Max 3 implementation attempts per task
   • If same error 3x: Escalate to human
   • If oscillating errors (A→B→A): Escalate
   • Prevents infinite refactoring loops

2. Maintain Incremental Commits:

   Small Change Pattern:

   # After each logical increment:
   git add <changed-files>
   git commit -m "Add [specific feature]: [what changed]"
   
   # Target: <200 lines per commit
   # Benefit: Clear intent, easy rollback
   

   Automatic Rollback on Test Failures:

   # If tests fail after commit:
   npm test || git reset --hard HEAD~1
   
   # TCR Pattern (Test-Commit-Revert):
   # - Tests pass → Commit
   # - Tests fail → Automatic revert
   

3. Handle Backward Compatibility (for changes to existing code):

   Expand-Migrate-Contract Pattern:

   ### Example: Add OAuth to Existing Auth
   
   **Phase 1: Expand**
   - Add new OAuth tables/functions
   - Keep existing password auth
   - Both work in parallel
   
   **Phase 2: Migrate**
   - Dual-write (password + OAuth)
   - Gradual user transition
   - Validate both paths work
   
   **Phase 3: Contract**
   - Deprecate password auth
   - Remove old code
   - OAuth only
   
   **Benefit**: Zero downtime, safe rollback at each phase
   

4. Error Handling Pattern:

   // Every function needs error handling
   
   export function generateToken(user: User): string {
     // Validate input
     if (!user || !user.id) {
       throw new Error('Invalid user: missing id');
     }
   
     // Validate environment
     if (!process.env.JWT_SECRET) {
       throw new Error('JWT_SECRET not configured');
     }
   
     try {
       // Implementation
       const token = jwt.sign({ userId: user.id }, process.env.JWT_SECRET);
       return token;
     } catch (error) {
       // Graceful handling
       console.error('Token generation failed:', error);
       throw new Error(`Failed to generate token: ${error.message}`);
     }
   }
   

Outputs:

• Working code (incremental commits)
• All tests passing
• Coverage ≥80% (gate), target ≥95%
• Error handling complete
• Backward compatible (if applicable)

Validation:

• All tests pass
• Coverage meets gate (≥80%)
• Changes <200 lines per commit (mostly)
• Error handling present
• Backward compatible verified
• No doom loops encountered

Time Estimate: 2-8 hours (varies by complexity)

Next: Proceed to Step 4 (if multi-agent needed) or Step 5

Step 4: Multi-Agent Coordination (Optional)

For complex features requiring parallel development, coordinate multiple implementation agents.

Purpose: Parallelize independent work to save time

When to Use:

• Feature has multiple independent components
• Different agents can work on different modules
• Clear separation of concerns possible
• Time optimization important

When to Skip:

• Simple linear implementation
• Strong coupling between components
• Single developer workflow

Inputs:

• Implementation plan with parallel groups identified
• Clear boundaries between components

Process:

1. Identify Parallel Opportunities (from plan):

   ## Parallel Groups (from multi-ai-planning)
   
   **Parallel Group 1** (after Task 1):
   - Task 2.1: Frontend authentication component
   - Task 2.2: Backend API endpoints
   - Task 2.3: Database migrations
   
   These can run simultaneously (independent).
   

2. Spawn Parallel Implementation Agents (Task tool):

   // Coordinate multiple agents via Task tool
   
   const implementations = await Promise.all([
     task({
       description: "Implement frontend auth component",
       prompt: `Create React authentication component.
   
       Specifications:
       - Login form with email/password
       - Form validation
       - API integration hooks
       - Error handling
   
       Write to: src/components/Auth/LoginForm.tsx
       Write tests to: src/components/Auth/LoginForm.test.tsx
   
       Success criteria:
       - Component renders correctly
       - Validation works
       - Tests pass
       - Coverage ≥80%`
     }),
   
     task({
       description: "Implement backend API endpoints",
       prompt: `Create authentication API endpoints.
   
       Endpoints:
       - POST /api/auth/login
       - POST /api/auth/register
       - POST /api/auth/refresh
   
       Write to: src/api/auth.ts
       Write tests to: src/api/auth.test.ts
   
       Success criteria:
       - All endpoints functional
       - Tests pass
       - Coverage ≥80%`
     }),
   
     task({
       description: "Create database migrations",
       prompt: `Create database schema for authentication.
   
       Tables:
       - users (id, email, password_hash, created_at)
       - sessions (id, user_id, token, expires_at)
   
       Write migrations to: migrations/001_auth_schema.sql
       Write tests to: migrations/001_auth_schema.test.ts`
     })
   ]);
   
   // All three execute in parallel
   // Each has isolated context
   // Results returned when all complete
   

3. Integrate Results:

   # Integration After Parallel Execution
   
   **Check Each Component**:
   - [ ] Frontend component complete and tested
   - [ ] Backend API complete and tested
   - [ ] Database migrations complete and tested
   
   **Integration Steps**:
   1. Verify all components built correctly
   2. Connect frontend → API
   3. Connect API → database
   4. Run integration tests
   5. Verify end-to-end workflow
   

4. Handle Coordination Issues:

   ## Common Coordination Challenges
   
   **Issue**: Components don't integrate
   - **Cause**: Mismatched interfaces
   - **Fix**: Review specifications, align interfaces, re-implement
   
   **Issue**: Duplicate work
   - **Cause**: Overlapping agent responsibilities
   - **Fix**: Clearer task boundaries in plan
   
   **Issue**: Conflicting changes
   - **Cause**: Agents modifying same files
   - **Fix**: Use git worktrees for isolation
   

Outputs:

• Multiple components implemented in parallel
• All components tested independently
• Integration verified
• Time saved (20-40% faster than sequential)

Validation:

• All parallel tasks completed
• Each component tested independently
• Integration successful
• No conflicts or duplicate work
• Time savings achieved

Time Estimate: 2-6 hours (potentially 20-40% faster than sequential)

Next: Proceed to Step 5

Step 5: Integration & End-to-End Testing

Integrate all components and verify complete workflows function correctly.

Purpose: Ensure components work together, catch integration issues

Inputs:

• Implemented code (from Step 3-4)
• Integration test strategy (from plan)

Process:

1. Integration Testing:

   Generate Integration Tests (use multi-ai-testing):

   Use multi-ai-testing test generation workflow for integration tests
   
   Components:
   - [List all components to integrate]
   
   Workflows to Test:
   - User registration → database → email confirmation
   - User login → token generation → API access
   - Token refresh → validation → new token
   
   Write tests to: tests/integration/auth-workflows.test.ts
   

2. Execute Integration Tests:

   # Run integration test suite
   npm test -- tests/integration/
   
   # Verify all workflows work
   # Fix any integration issues found
   

3. End-to-End Testing:

   # E2E Test Scenarios
   
   **Scenario 1: Complete Registration Flow**
   1. User submits registration form
   2. API validates and creates user
   3. Database stores user record
   4. Email confirmation sent
   5. User confirms email
   6. User can log in
   
   **Scenario 2: Complete Login Flow**
   [Similar detailed steps]
   

   Execute E2E Tests:

   # Run E2E test suite
   npm run test:e2e
   
   # Or use multi-ai-testing
   Use multi-ai-testing for E2E testing of [workflows]
   

4. Performance Validation:

   # Run performance tests
   npm run test:performance
   
   # Check response times
   # Verify: <200ms for critical paths
   # Identify bottlenecks if any
   

5. Backward Compatibility Check (for changes to existing code):

   # Run full test suite (old + new tests)
   npm test
   
   # Verify: All existing tests still pass
   # Verify: No breaking changes
   # Verify: APIs backward compatible
   

Outputs:

• Integration tests passing
• E2E tests passing
• Performance validated
• Backward compatibility verified
• Integration issues resolved

Validation:

• Integration tests generated and passing
• E2E workflows verified
• Performance acceptable (<200ms or spec)
• No backward compatibility breaks
• All existing tests still pass

Time Estimate: 1-3 hours

Next: Proceed to Step 6

Step 6: Quality Verification & Commit

Run final verification before committing, ensuring all quality gates pass.

Purpose: Multi-layer quality assurance before production

Inputs:

• Complete implementation (from Steps 3-5)
• All tests passing
• Plan verification criteria

Process:

1. Run Multi-Layer Verification (use multi-ai-verification):

   Use multi-ai-verification for complete quality check of [implementation]
   

   This runs all 5 verification layers:

   • Layer 1: Rules-based (linting, types, schema) - 95% automated
   • Layer 2: Functional (tests, coverage) - 60-80% automated
   • Layer 3: Visual (if UI) - 30-50% automated
   • Layer 4: Integration (E2E, system) - 20-30% automated
   • Layer 5: Quality scoring (0-100) - LLM-as-judge

2. Review Verification Report:

   # Verification Results
   
   ## Layer 1: Rules ✅
   - Linting: PASS
   - Type checking: PASS
   - Schema validation: PASS
   
   ## Layer 2: Functional ✅
   - Tests: 95/95 passing
   - Coverage: 87% (≥80% gate)
   - Examples: All working
   
   ## Layer 3: Visual ✅ (if applicable)
   - Screenshots match mockups
   - Responsive design works
   
   ## Layer 4: Integration ✅
   - E2E tests pass
   - API integration verified
   
   ## Layer 5: Quality Score
   - **Total**: 92/100 ✅ (≥90 gate)
   - Correctness: 19/20
   - Functionality: 19/20
   - Quality: 18/20
   - Integration: 18/20
   - Security: 18/20
   
   **Status**: ALL GATES PASS ✅
   

3. If Quality <90: Iterate:

   ## Gap Analysis (if score <90)
   
   **Issues Found**:
   1. [Issue 1] - Priority: High
      - Fix: [Specific action]
   2. [Issue 2] - Priority: Medium
      - Fix: [Action]
   
   **Action**: Apply fixes, re-verify
   **Target**: Reach ≥90/100
   

4. Create Git Commit (only if all gates pass):

   # Stage changes
   git add <files>
   
   # Commit with clear message
   git commit -m "feat: Add user authentication with OAuth
   
   - Implemented JWT token generation and validation
   - Added login/register API endpoints
   - Created database schema and migrations
   - Tests: 95/95 passing, coverage 87%
   - Quality score: 92/100
   
   Closes #123"
   

5. Create Pull Request (for team workflows):

   # Push branch
   git push -u origin feature/auth
   
   # Create PR
   gh pr create --title "Add user authentication" --body "$(cat <<EOF
   ## Summary
   Implements user authentication with OAuth support.
   
   ## Changes
   - Database schema for users and tokens
   - JWT token generation and validation
   - Login/register API endpoints
   - Frontend auth components
   
   ## Testing
   - Unit tests: 95/95 passing
   - Integration tests: 12/12 passing
   - Coverage: 87% (gate: ≥80%)
   - Quality score: 92/100
   
   ## Verification
   - ✅ All 5 verification layers pass
   - ✅ Security scan: No vulnerabilities
   - ✅ Backward compatible
   - ✅ Performance: <150ms avg response
   
   Ready for review.
   EOF
   )"
   

6. Document Implementation:

   # Implementation Complete
   
   **What Was Built**:
   - [List of components]
   
   **Tests Added**:
   - [Test files and coverage]
   
   **Quality Metrics**:
   - Quality score: 92/100
   - Test coverage: 87%
   - Performance: <150ms
   
   **Next Steps**:
   - Code review by team
   - Deployment to staging
   - Production release
   

Outputs:

• Production-ready code
• All tests passing
• Coverage ≥80% (gate), ideally ≥95%
• Quality score ≥90/100
• Git commit(s) created
• PR created (if team workflow)
• Documentation updated

Validation:

• All 5 verification layers pass
• Quality score ≥90/100
• Test coverage ≥80%
• Git commit created
• PR created (if applicable)
• Documentation complete

Time Estimate: 30-90 minutes

Result: Production-ready, tested, verified implementation

Integration with Other Skills

With multi-ai-planning (Step 2)

Usage: Create implementation plan before coding

Benefits:

• Structured approach (not ad-hoc)
• Quality ≥90 plans
• Clear task breakdown
• Verification built-in

With multi-ai-testing (Steps 3, 5)

Usage: TDD workflow, test generation, coverage validation

Benefits:

• Test-first development
• Independent verification prevents gaming
• 95% coverage achievable
• Self-healing tests

With multi-ai-verification (Step 6)

Usage: Multi-layer quality assurance before commit

Benefits:

• 5-layer verification (automated → LLM-as-judge)
• Quality scoring (0-100)
• All gates must pass
• Actionable feedback

Workflow Modes

Standard Mode (Full Quality)

Use For: Features, refactorings, security changes, integrations

Process: All 6 steps with all 5 verification layers Time: 5-15 hours Quality: Maximum (all gates, score ≥90)

Fast-Track Mode (Gemini Recommendation)

Use For: Typos, documentation, minor config tweaks

Process: Steps 1-3 + Layer 1-2 verification only Time: 30-90 minutes Quality: Essential checks only

Usage: Explicitly request "fast-track" or skip verification step

Best Practices

1. Always Explore First (Step 1)

Never jump straight to coding. Context prevents errors.

2. Always Plan (Step 2)

Use multi-ai-planning for quality ≥90 plans.

3. Test-Driven Development (Step 3)

Tests first, then implementation. Prevents overfitting.

4. Small Increments (<200 Lines)

Prevents LLM degradation, enables easy rollback.

5. Continuous Testing

Run tests after each change, not just at end.

6. Independent Verification (Step 6)

Use multi-ai-verification for unbiased quality check.

Common Mistakes

Mistake 1: Skipping Exploration

Problem: Coding without understanding existing patterns Fix: Always complete Step 1

Mistake 2: No Plan

Problem: Ad-hoc implementation, rework needed Fix: Always use multi-ai-planning (Step 2)

Mistake 3: Large Monolithic Changes

Problem: >500 lines, hard to review, LLM quality degrades Fix: Incremental commits (<200 lines)

Mistake 4: Implementation-First (Not Test-First)

Problem: Tests fit to code (gaming) Fix: Generate tests first in Step 3

Mistake 5: Skipping Verification

Problem: Low-quality code reaches production Fix: Always run multi-ai-verification (Step 6)

Appendix A: Task Tool Coordination Patterns

Pattern 1: Sequential Verification Agent

// Implementation complete
const implResult = await task({
  description: "Implement authentication",
  prompt: `Implement user authentication.
  Write code to: src/auth/
  Write tests to: tests/auth/
  Write summary to: implementation-summary.json`
});

// Independent verification (separate agent)
const verification = await task({
  description: "Verify implementation independently",
  prompt: `Review implementation in src/auth/.

  Do NOT read previous conversation.
  Verify against success-criteria.json ONLY.

  Check:
  - All success criteria met
  - Tests pass
  - Code quality
  - Security

  Write report to: verification-report.md`
});

// Read verification results
const report = readFile('verification-report.md');
if (report.score >= 90) {
  // Approved for commit
} else {
  // Apply fixes from feedback
}

Pattern 2: Parallel Component Implementation

// Build multiple components in parallel

const [frontend, backend, database] = await Promise.all([
  task({
    description: "Build frontend component",
    prompt: "Create React auth component. Write to: src/components/Auth/"
  }),

  task({
    description: "Build backend API",
    prompt: "Create auth API endpoints. Write to: src/api/auth.ts"
  }),

  task({
    description: "Create database schema",
    prompt: "Create auth schema. Write to: migrations/"
  })
]);

// Integrate results after all complete

Pattern 3: Shared State via Files

// Agent 1: Research
await task({
  description: "Research OAuth patterns",
  prompt: "Research OAuth 2.0 implementation. Write findings to: research.md"
});

// Agent 2: Plan based on research
await task({
  description: "Create implementation plan",
  prompt: "Read research.md. Create detailed plan. Write to: plan.json"
});

// Agent 3: Implement based on plan
await task({
  description: "Implement OAuth",
  prompt: "Read plan.json. Implement OAuth. Write code to: src/oauth/"
});

// Pattern: Agent A → file → Agent B reads → next file

Appendix B: Doom Loop Prevention

Detection Patterns

Oscillating Errors:

Attempt 1: Fix error A → Test B fails
Attempt 2: Fix error B → Test A fails
Attempt 3: Fix error A → Test B fails again
↓
DOOM LOOP DETECTED → Escalate to human

Same Error Repeatedly:

Attempt 1: Error: "undefined userId"
Attempt 2: Error: "undefined userId" (same fix tried)
Attempt 3: Error: "undefined userId" (stuck)
↓
ESCALATE → Human needed

Breaker Implementation

MAX_RETRIES = 3
error_history = []

for attempt in range(MAX_RETRIES):
    result = implement_and_test()

    if result.success:
        break

    error_history.append(result.error)

    # Detect doom loop
    if attempt >= 2:
        # Same error 3 times?
        if error_history[0] == error_history[1] == error_history[2]:
            escalate_to_human("Same error 3x:", error_history[0])
            break

        # Oscillating?
        if error_history[0] == error_history[2] and error_history[1] != error_history[0]:
            escalate_to_human("Oscillating errors:", error_history)
            break

    # Continue trying

Appendix C: Technical Foundation

Orchestration Runtime

• Development: Claude Code Task tool
• CI/CD: GitHub Actions
• Data Contracts: JSON schemas (in schemas/)
• Artifact Storage: File system (.implementations/)

Tooling Per Language

JavaScript/TypeScript:

• Linter: ESLint
• Type checker: TypeScript compiler (tsc)
• Test framework: Jest or Vitest
• Coverage: c8 or nyc
• SAST: Semgrep or eslint-plugin-security

Python:

• Linter: Pylint/Ruff
• Type checker: mypy
• Test framework: pytest
• Coverage: pytest-cov
• SAST: Bandit

Rollback Strategy

• Code: Git tags + git worktree (NOT git reset)
• Database: Migration down scripts
• Feature flags: Gradual rollout with kill switch

Cost/Latency Controls

• Budget: $50/month cap for LLM-as-judge
• Caching: Cache verification results for 24h
• Fast-path: Skip Layer 5 for changes <50 lines

Quick Reference

The 6-Step Workflow

Total: 5-15 hours (standard mode) or 30-90 min (fast-track)

Quality Metrics

• Test Coverage: ≥80% gate, ≥95% target
• Quality Score: ≥90/100 required
• Change Size: <200 lines per commit ideal
• Verification Layers: All 5 must pass
• Performance: Meets specification

multi-ai-implementation delivers production-ready code through systematic Explore-Plan-Code-Commit workflow with TDD, multi-agent coordination, and rigorous quality gates - validated by Claude + Gemini + Codex research.

For examples, see examples/. For coordination patterns, see Appendix A.