From fd3d5546fe857af1e2e1edea68f5a859d42bf514 Mon Sep 17 00:00:00 2001 From: kevin rajan Date: Tue, 2 Dec 2025 11:06:44 -0600 Subject: [PATCH 1/3] Fix Mermaid arrow visibility and update .claude/ directory structure MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Add dark theme configuration for Mermaid diagrams with visible arrows - Configure themeVariables for better contrast on dark backgrounds - Update .claude/ directory structure documentation to reflect current state - Document 54+ agents, 214+ commands across 25 categories - Add skills, router, sessions, and other new directories πŸ€– Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude --- .../01-architecture/CORE_ARCHITECTURE.md | 72 +++++++++++++++---- docs/conf.py | 24 +++++++ 2 files changed, 81 insertions(+), 15 deletions(-) diff --git a/claudedocs/01-architecture/CORE_ARCHITECTURE.md b/claudedocs/01-architecture/CORE_ARCHITECTURE.md index 0173f8b..fa38d49 100644 --- a/claudedocs/01-architecture/CORE_ARCHITECTURE.md +++ b/claudedocs/01-architecture/CORE_ARCHITECTURE.md @@ -101,23 +101,65 @@ Main configuration file loaded by Claude Code CLI: ``` .claude/ -β”œβ”€β”€ commands/ # Custom slash commands -β”‚ └── sc/ # SuperClaude command namespace -β”‚ β”œβ”€β”€ research.md -β”‚ β”œβ”€β”€ implement.md -β”‚ └── test.md +β”œβ”€β”€ agents/ # Specialized agent definitions (54+) +β”‚ β”œβ”€β”€ analysis/ # Code analysis agents +β”‚ β”œβ”€β”€ architecture/ # System design agents +β”‚ β”œβ”€β”€ consensus/ # Distributed consensus agents +β”‚ β”œβ”€β”€ core/ # Core agents (coder, reviewer, tester, etc.) +β”‚ β”œβ”€β”€ development/ # Development specialists +β”‚ β”œβ”€β”€ devops/ # CI/CD and infrastructure agents +β”‚ β”œβ”€β”€ flow-nexus/ # Cloud platform agents +β”‚ β”œβ”€β”€ github/ # GitHub integration agents +β”‚ β”œβ”€β”€ goal/ # Goal-oriented planning agents +β”‚ β”œβ”€β”€ hive-mind/ # Collective intelligence agents +β”‚ β”œβ”€β”€ optimization/ # Performance optimization agents +β”‚ β”œβ”€β”€ sparc/ # SPARC methodology agents +β”‚ β”œβ”€β”€ swarm/ # Swarm coordination agents +β”‚ └── testing/ # Testing specialists +β”œβ”€β”€ commands/ # Slash commands (214+ across 25 categories) +β”‚ β”œβ”€β”€ agents/ # Agent management commands +β”‚ β”œβ”€β”€ analysis/ # Analysis commands +β”‚ β”œβ”€β”€ automation/ # Workflow automation +β”‚ β”œβ”€β”€ consider/ # Decision framework commands +β”‚ β”œβ”€β”€ flow-nexus/ # Cloud platform commands +β”‚ β”œβ”€β”€ github/ # GitHub operations +β”‚ β”œβ”€β”€ hive-mind/ # Collective intelligence commands +β”‚ β”œβ”€β”€ hooks/ # Hook configuration commands +β”‚ β”œβ”€β”€ monitoring/ # System monitoring +β”‚ β”œβ”€β”€ optimization/ # Performance optimization +β”‚ β”œβ”€β”€ pair/ # Pair programming commands +β”‚ β”œβ”€β”€ pm/ # Project management (CCPM) +β”‚ β”œβ”€β”€ sc/ # SuperClaude meta commands +β”‚ β”œβ”€β”€ sparc/ # SPARC methodology commands +β”‚ β”œβ”€β”€ swarm/ # Swarm coordination commands +β”‚ β”œβ”€β”€ ui/ # UI/frontend commands +β”‚ └── workflows/ # Workflow templates +β”œβ”€β”€ context/ # Project context files +β”œβ”€β”€ helpers/ # Shell utilities +β”œβ”€β”€ prds/ # Product requirements (CCPM) +β”œβ”€β”€ router/ # Command routing configuration β”œβ”€β”€ rules/ # Operational rules β”‚ β”œβ”€β”€ agent-coordination.md -β”‚ β”œβ”€β”€ path-standards.md -β”‚ └── github-operations.md -β”œβ”€β”€ helpers/ # Shell utilities -β”‚ β”œβ”€β”€ setup-mcp.sh -β”‚ β”œβ”€β”€ github-setup.sh -β”‚ └── checkpoint-manager.sh -β”œβ”€β”€ prds/ # Product requirements -β”œβ”€β”€ epics/ # Epic management (gitignored) -β”œβ”€β”€ context/ # Project context -└── statusline/ # Status line config +β”‚ β”œβ”€β”€ command-routing.md +β”‚ β”œβ”€β”€ github-operations.md +β”‚ └── path-standards.md +β”œβ”€β”€ sessions/ # Session persistence +β”œβ”€β”€ skills/ # Reusable skill definitions +β”‚ β”œβ”€β”€ agent-sandboxes/ # E2B sandbox operations +β”‚ β”œβ”€β”€ create-agent-skills/ +β”‚ β”œβ”€β”€ create-hooks/ +β”‚ β”œβ”€β”€ create-meta-prompts/ +β”‚ β”œβ”€β”€ create-plans/ +β”‚ β”œβ”€β”€ create-slash-commands/ +β”‚ β”œβ”€β”€ create-subagents/ +β”‚ β”œβ”€β”€ debug-like-expert/ +β”‚ └── expertise/ # Domain expertise (iOS, macOS) +β”œβ”€β”€ statusline/ # Status line config +β”œβ”€β”€ superclaude/ # SuperClaude framework files +β”œβ”€β”€ tools/ # Custom tool definitions +β”œβ”€β”€ ccpm.config # CCPM configuration +β”œβ”€β”€ settings.json # Claude Code settings +└── statusline-command.sh # Status line shell script ``` ### 2. SPARC Methodology Engine diff --git a/docs/conf.py b/docs/conf.py index b7ad9c8..ebba12b 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -27,6 +27,30 @@ # MyST-Parser configuration - enable all features myst_fence_as_directive = ["mermaid"] # Render ```mermaid blocks as Mermaid diagrams +# Mermaid configuration for dark theme compatibility +mermaid_init_js = """ +mermaid.initialize({ + startOnLoad: true, + theme: 'dark', + themeVariables: { + lineColor: '#8B949E', + primaryTextColor: '#C9D1D9', + primaryColor: '#238636', + primaryBorderColor: '#30363D', + secondaryColor: '#161B22', + tertiaryColor: '#21262D', + edgeLabelBackground: '#21262D', + clusterBkg: '#161B22', + clusterBorder: '#30363D', + nodeTextColor: '#C9D1D9' + }, + flowchart: { + curve: 'basis', + useMaxWidth: true + } +}); +""" + myst_enable_extensions = [ "amsmath", "colon_fence", From 5f1484275fb2a71d82019beace9e7c62cd08720e Mon Sep 17 00:00:00 2001 From: kevin rajan Date: Tue, 2 Dec 2025 11:15:06 -0600 Subject: [PATCH 2/3] Update command routing system for 234 commands, 78 agents, 8 skills MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Update counts: 214+ β†’ 234 commands, 25 β†’ 27 categories - Add 3 new classification triggers: decision_frameworks, skill_management, context_management - Add 15 root-level commands documentation - Add /consider:* category (12 decision framework commands) - Add /context:* category (3 context management commands) - Add Skills Integration section (8 skills) - Update Quick Reference Matrix with new patterns πŸ€– Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude --- .claude/rules/command-routing.md | 90 +++++++++++++++++++++++++++++++- 1 file changed, 88 insertions(+), 2 deletions(-) diff --git a/.claude/rules/command-routing.md b/.claude/rules/command-routing.md index 34e09c0..81cbc5b 100644 --- a/.claude/rules/command-routing.md +++ b/.claude/rules/command-routing.md @@ -1,6 +1,6 @@ # Dynamic Command Routing Rules -This file defines intelligent routing logic for selecting optimal commands from **214+ commands across 25 categories**. +This file defines intelligent routing logic for selecting optimal commands from **234 commands across 27 categories**. ## Smart Routing Configuration @@ -104,11 +104,23 @@ CLASSIFICATION_TRIGGERS: prd_generation: true parallel_implementation: true quality_validation: true + + decision_frameworks: + keywords: ["decide", "trade-off", "prioritize", "analyze decision", "first principles", "80/20", "root cause", "mental model"] + route_to: /consider:* commands + + skill_management: + keywords: ["skill", "create skill", "audit skill", "heal skill", "skill authoring"] + route_to: /create-agent-skill OR /audit-skill OR /heal-skill + + context_management: + keywords: ["context", "prime", "load context", "project context"] + route_to: /context:* commands ``` --- -## Complete Command Reference (214+ Commands) +## Complete Command Reference (234 Commands) ### /sc:* - SuperClaude Commands (26 commands) Meta-routing and high-level operations. @@ -142,6 +154,27 @@ Meta-routing and high-level operations. | `/sc:troubleshoot` | Debugging | "fix", "debug", "error", "broken" | | `/sc:workflow` | Workflow generation | "workflow", "process", "pipeline" | +#### Root-Level Commands (15 commands) +Direct commands without namespace prefix. + +| Command | Purpose | Use When | +|---------|---------|----------| +| `/create-plan` | Plan creation | "create plan", "plan project" | +| `/create-prompt` | Prompt creation | "create prompt", "new prompt" | +| `/create-hook` | Hook creation | "create hook", "new hook" | +| `/create-subagent` | Subagent creation | "create agent", "new agent" | +| `/create-agent-skill` | Skill creation | "create skill", "new skill" | +| `/debug` | Debug mode | "debug", "investigate issue" | +| `/run-plan` | Execute plan | "run plan", "execute plan" | +| `/run-prompt` | Execute prompt | "run prompt" | +| `/whats-next` | Next steps | "what's next", "continue work" | +| `/check-todos` | Check todos | "check todos", "show todos" | +| `/add-to-todos` | Add todo | "add todo" | +| `/heal-skill` | Fix skills | "heal skill", "fix skill" | +| `/audit-skill` | Audit skill | "audit skill" | +| `/audit-slash-command` | Audit command | "audit command" | +| `/audit-subagent` | Audit agent | "audit agent" | + --- ### /sparc:* - SPARC Methodology (18 commands) @@ -522,6 +555,53 @@ System-level operations. --- +### /consider:* - Decision Frameworks (12 commands) +Mental models and decision-making frameworks. + +| Command | Purpose | Use When | +|---------|---------|----------| +| `/consider:first-principles` | Break down to fundamentals | "first principles", "fundamental" | +| `/consider:second-order` | Consequences of consequences | "second order", "ripple effects" | +| `/consider:opportunity-cost` | What you give up | "opportunity cost", "trade-off" | +| `/consider:pareto` | 80/20 analysis | "pareto", "80/20" | +| `/consider:eisenhower-matrix` | Urgent/important matrix | "eisenhower", "prioritize" | +| `/consider:inversion` | Solve backwards | "inversion", "reverse" | +| `/consider:occams-razor` | Simplest explanation | "occam", "simplest" | +| `/consider:5-whys` | Root cause drilling | "5 whys", "root cause" | +| `/consider:swot` | Strengths/weaknesses | "swot", "strengths" | +| `/consider:10-10-10` | Time horizon decisions | "10-10-10", "time horizon" | +| `/consider:one-thing` | Highest leverage action | "one thing", "focus" | +| `/consider:via-negativa` | Improve by removing | "via negativa", "remove" | + +--- + +### /context:* - Context Management (3 commands) +Project context and priming. + +| Command | Purpose | Use When | +|---------|---------|----------| +| `/context:create` | Create context | "create context" | +| `/context:update` | Update context | "update context" | +| `/context:prime` | Prime context | "prime", "load context" | + +--- + +### Skills Integration (8 skills) +Skills are invoked via the Skill tool for specialized guidance. + +| Skill | Trigger Keywords | Purpose | +|-------|-----------------|---------| +| `agent-sandboxes` | "sandbox", "isolated", "e2b" | E2B sandbox operations | +| `create-agent-skills` | "create skill", "skill authoring" | Skill creation guidance | +| `create-hooks` | "create hook", "hook config" | Hook development | +| `create-meta-prompts` | "meta prompt", "prompt pipeline" | Multi-stage prompts | +| `create-plans` | "create plan", "project plan" | Hierarchical planning | +| `create-slash-commands` | "create command", "slash command" | Command development | +| `create-subagents` | "create agent", "subagent" | Agent configuration | +| `debug-like-expert` | "deep debug", "root cause analysis" | Expert debugging methodology | + +--- + ## Routing Algorithm ```yaml @@ -579,3 +659,9 @@ When uncertain which command to use: | "Check status" | `/monitoring:status` | `/swarm:swarm-status` | | "What's next" | `/pm:next` | `/pm:status` | | "Not sure..." | `/sc:brainstorm` | `/sparc:innovator` | +| "First principles" | `/consider:first-principles` | `/consider:5-whys` | +| "Trade-off analysis" | `/consider:opportunity-cost` | `/consider:swot` | +| "Prioritize tasks" | `/consider:eisenhower-matrix` | `/consider:pareto` | +| "Create skill" | `/create-agent-skill` | Skill tool | +| "Create hook" | `/create-hook` | Skill tool | +| "Load context" | `/context:prime` | `/sc:load` | From 6b292c0ded5903ed865222d2eb6ae4660a47e79e Mon Sep 17 00:00:00 2001 From: kevin rajan Date: Tue, 2 Dec 2025 11:45:24 -0600 Subject: [PATCH 3/3] Add C(RAID) paradigm as foundational framework documentation MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Introduce C(RAID) - Continuous Research, Analysis, Integration, Deployment - as the operational paradigm for autonomous AI development, complementing SPARC methodology (inner execution loop) with continuous operational cycles (outer loop). New files: - claudedocs/03-vision/CRAID_PARADIGM.md: Full paradigm documentation - docs/paradigm/index.rst: Sphinx entry point for paradigm section Modified files: - docs/index.rst: Add "The Paradigm" as first documentation section - README.md: Add C(RAID) section with comparison table - docs/architecture/autonomous-pipeline-architecture.md: Add C(RAID) context - claudedocs/03-vision/README.md: Add C(RAID) as primary strategic theme πŸ€– Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude --- README.md | 20 + claudedocs/03-vision/CRAID_PARADIGM.md | 406 ++++++++++++++++++ claudedocs/03-vision/README.md | 20 +- .../autonomous-pipeline-architecture.md | 17 + docs/index.rst | 6 + docs/paradigm/index.rst | 9 + 6 files changed, 473 insertions(+), 5 deletions(-) create mode 100644 claudedocs/03-vision/CRAID_PARADIGM.md create mode 100644 docs/paradigm/index.rst diff --git a/README.md b/README.md index 74b196b..ea555d7 100644 --- a/README.md +++ b/README.md @@ -10,6 +10,26 @@ This project demonstrates advanced integration of five powerful frameworks to create a development environment where AI agents collaborate systematically, maintain perfect context across sessions, and deliver production-ready code through proven methodologies. +## The C(RAID) Paradigm + +**Evolve operates on C(RAID)** - an evolution of CI/CD designed specifically for autonomous AI development: + +``` +Traditional CI/CD: Code -> Build -> Test -> Deploy +C(RAID): Research -> Analysis -> Integration -> Deployment -> (feedback) -> Research +``` + +| Traditional CI/CD | C(RAID) Paradigm | +|-------------------|------------------| +| Starts with code (human wrote it) | Starts with research (AI must understand first) | +| Human-driven development cycles | AI-driven autonomous cycles | +| Integration happens AFTER development | Research and Analysis PRECEDE coding | +| Deployment is the end goal | Deployment feeds back into Research | + +**C(RAID) + SPARC**: C(RAID) defines the continuous operational paradigm (outer loop), while SPARC provides the systematic execution methodology (inner loop). Together they enable truly autonomous development at scale. + +> **[Read the full C(RAID) Paradigm documentation](docs/paradigm/index.rst)** + ## Why This Matters **Traditional AI development**: Ad-hoc prompts, lost context, inconsistent quality diff --git a/claudedocs/03-vision/CRAID_PARADIGM.md b/claudedocs/03-vision/CRAID_PARADIGM.md new file mode 100644 index 0000000..babe6b3 --- /dev/null +++ b/claudedocs/03-vision/CRAID_PARADIGM.md @@ -0,0 +1,406 @@ +# C(RAID): The Autonomous Development Paradigm + +**The foundational paradigm shift that enables truly autonomous AI development.** + +--- + +## Executive Summary + +**C(RAID)** stands for **Continuous Research, Analysis, Integration, Deployment** - an evolution of the traditional CI/CD paradigm designed specifically for autonomous LLM-based software development. + +While traditional CI/CD assumes human developers write code and then integrate it, C(RAID) recognizes that in autonomous AI development, **research and analysis must precede and continuously inform the development process**. + +``` +Traditional CI/CD: Code β†’ Build β†’ Test β†’ Deploy +C(RAID): Research β†’ Analysis β†’ Integration β†’ Deployment β†’ (feedback) β†’ Research +``` + +This isn't just an extension - it's a fundamental reconceptualization of how software gets built when AI agents are the primary developers. + +--- + +## The Paradigm Shift + +### Why CI/CD Falls Short for Autonomous Development + +Traditional **CI/CD (Continuous Integration / Continuous Deployment)** was designed for human-driven development: + +| Traditional CI/CD | Assumption | +|-------------------|------------| +| **Continuous Integration** | Humans write code, then integrate it | +| **Continuous Deployment** | Code is tested and deployed automatically | +| **Starting Point** | Code already exists (human wrote it) | +| **Knowledge Source** | Human expertise and documentation | + +This model assumes the hard problem is **integration and deployment** - getting code from multiple developers to work together and reach production reliably. + +### C(RAID): A New Starting Point + +Autonomous LLM-based development inverts this: + +| C(RAID) | Reality | +|---------|---------| +| **Continuous Research** | AI agents must gather knowledge before coding | +| **Continuous Analysis** | Requirements extraction and architecture matching | +| **Continuous Integration** | Multi-agent parallel implementation | +| **Continuous Deployment** | Automated validation with human gates | +| **Starting Point** | A concept, question, or research source | +| **Knowledge Source** | Web research, documentation, pattern recognition | + +**The hard problem becomes research and analysis** - understanding WHAT to build and HOW to build it correctly. + +--- + +## The Four Pillars of C(RAID) + +```mermaid +flowchart LR + subgraph CRAID["C(RAID) Continuous Cycle"] + R["πŸ”¬ Research"] + A["πŸ“Š Analysis"] + I["πŸ”§ Integration"] + D["πŸš€ Deployment"] + end + + R -->|Insights| A + A -->|Specifications| I + I -->|Artifacts| D + D -->|Feedback & Metrics| R + + style R fill:#e3f2fd,stroke:#1976d2 + style A fill:#fff3e0,stroke:#f57c00 + style I fill:#e8f5e9,stroke:#388e3c + style D fill:#fce4ec,stroke:#c2185b +``` + +### πŸ”¬ Continuous Research (CR) + +**Purpose:** Autonomous knowledge gathering and pattern recognition + +**What happens:** +- AI agents research concepts from multiple sources (videos, papers, blogs, documentation) +- Multi-hop investigation follows related concepts +- Pattern recognition identifies successful implementations +- Technology trends are monitored and analyzed + +**Key agents:** `researcher`, `deep-research-agent` + +**Output:** Structured knowledge ready for requirement extraction + +**Traditional equivalent:** A developer reading documentation and researching approaches (but done continuously and at scale) + +--- + +### πŸ“Š Continuous Analysis (CA) + +**Purpose:** Automated requirement extraction and architecture validation + +**What happens:** +- Research findings are transformed into specifications +- Existing architecture patterns are matched to requirements +- Quality and security implications are assessed +- Feasibility and complexity are estimated + +**Key agents:** `specification`, `code-analyzer`, `planner`, `goal-planner` + +**Output:** Product Requirements Documents (PRDs), architecture decisions, task decomposition + +**Traditional equivalent:** Product management and technical design (but automated and consistent) + +--- + +### πŸ”§ Continuous Integration (CI - Evolved) + +**Purpose:** Multi-agent parallel implementation with intelligent coordination + +**What happens:** +- Tasks are distributed to specialized agents +- Agents work in parallel on isolated Git worktrees +- Coordination happens through commits and shared memory +- TDD practices ensure quality at the unit level + +**Key agents:** `coder`, `backend-dev`, `mobile-dev`, `tester`, `reviewer` + +**Output:** Working code with tests in isolated branches + +**Traditional equivalent:** Development team sprint work (but parallelized and conflict-free) + +--- + +### πŸš€ Continuous Deployment (CD - Enhanced) + +**Purpose:** Automated validation with human approval gates + +**What happens:** +- Multi-agent code review (5+ specialized reviewers) +- Automated security scanning and performance benchmarking +- Progressive deployment (staging β†’ production) +- Metrics collection feeds back to Research phase + +**Key agents:** `production-validator`, `release-manager`, `security-manager`, `performance-benchmarker` + +**Output:** Production deployment with rollback capability + +**Traditional equivalent:** DevOps pipeline (but with AI-driven validation and feedback loops) + +--- + +## C(RAID) vs SPARC: Complementary Frameworks + +C(RAID) and SPARC are not competing frameworks - they operate at different levels of abstraction. + +```mermaid +flowchart TB + subgraph Outer["C(RAID) - Operational Paradigm (Outer Loop)"] + direction LR + CR["Continuous
Research"] --> CA["Continuous
Analysis"] + CA --> CI["Continuous
Integration"] + CI --> CD["Continuous
Deployment"] + CD -.->|Feedback| CR + end + + subgraph Inner["SPARC - Execution Methodology (Inner Loop)"] + direction LR + S["Specification"] --> P["Pseudocode"] + P --> Ar["Architecture"] + Ar --> Re["Refinement"] + Re --> Co["Completion"] + end + + CI -->|"Executes via"| Inner + Inner -->|"Produces for"| CD + + style Outer fill:#e8eaf6,stroke:#3f51b5 + style Inner fill:#fff8e1,stroke:#ffc107 +``` + +### SPARC: The Inner Loop (Execution) + +**SPARC** (Specification, Pseudocode, Architecture, Refinement, Completion) answers: +> "How do I build ONE thing systematically?" + +SPARC provides the discipline for each individual development cycle: +- **Specification** β†’ What exactly are we building? +- **Pseudocode** β†’ What's the algorithm/approach? +- **Architecture** β†’ How does it fit the system? +- **Refinement** β†’ TDD implementation with quality gates +- **Completion** β†’ Integration and deployment validation + +### C(RAID): The Outer Loop (Operations) + +**C(RAID)** answers: +> "How does development CONTINUOUSLY evolve?" + +C(RAID) provides the operational framework that spans multiple SPARC cycles: +- **Research** β†’ What SHOULD we build next? +- **Analysis** β†’ Is this the right approach? +- **Integration** β†’ Execute SPARC to build it +- **Deployment** β†’ Get it to production, gather feedback + +### The Relationship + +``` +C(RAID) Cycle 1: + Research β†’ "New caching approach from YouTube video" + Analysis β†’ "PRD: Distributed cache with consistent hashing" + Integration β†’ [SPARC: Specβ†’Pseudoβ†’Archβ†’Refineβ†’Complete] + Deployment β†’ Production, collect metrics + ↓ +C(RAID) Cycle 2: + Research β†’ "Metrics show cache misses, research solutions" + Analysis β†’ "PRD: Add cache warming strategy" + Integration β†’ [SPARC: Specβ†’Pseudoβ†’Archβ†’Refineβ†’Complete] + Deployment β†’ Production, metrics improve + ↓ +C(RAID) Cycle 3: ... +``` + +--- + +## C(RAID) in Practice: The Evolve Framework + +The Evolve framework implements C(RAID) through its autonomous pipeline: + +| C(RAID) Phase | Evolve Pipeline Phase | Duration | Key Tools | +|---------------|----------------------|----------|-----------| +| **Continuous Research** | Phase 1: Concept Extraction | 3-5 min | `/sc:research`, Tavily, WebFetch | +| **Continuous Analysis** | Phase 2: PRD Generation | 15-20 min | `/pm:prd-new`, `/sparc:architect` | +| **Continuous Integration** | Phase 3-4: Decomposition + Implementation | 2-5 hours | `/swarm:development`, `/sparc:coder` | +| **Continuous Deployment** | Phase 5: Validation & Deployment | 45 min | `/github:code-review-swarm`, `/github:pr-manager` | + +### Agent Mapping + +```mermaid +flowchart TB + subgraph Research["Continuous Research"] + R1["researcher"] + R2["deep-research-agent"] + end + + subgraph Analysis["Continuous Analysis"] + A1["specification"] + A2["code-analyzer"] + A3["planner"] + A4["goal-planner"] + end + + subgraph Integration["Continuous Integration"] + I1["coder"] + I2["backend-dev"] + I3["mobile-dev"] + I4["tester"] + I5["reviewer"] + end + + subgraph Deployment["Continuous Deployment"] + D1["production-validator"] + D2["release-manager"] + D3["security-manager"] + D4["cicd-engineer"] + end + + Research --> Analysis --> Integration --> Deployment + Deployment -.->|"Metrics feed back"| Research +``` + +--- + +## Benefits of C(RAID) + +### For Autonomous Development + +1. **Research-First Approach** + - Decisions are informed by current best practices + - Patterns are discovered, not assumed + - Technology choices are evidence-based + +2. **Continuous Learning** + - Deployment metrics inform research priorities + - Successful patterns are recognized and reused + - Failures trigger investigation cycles + +3. **Parallel Execution** + - Multiple agents work simultaneously + - File-level isolation prevents conflicts + - 3-8 agents achieve 2.8-4.4x speedup + +4. **Human-in-the-Loop** + - Approval gates at critical decisions + - Humans focus on strategy, not implementation + - AI handles routine validation + +### Measured Improvements + +| Metric | Traditional | C(RAID) | Improvement | +|--------|-------------|---------|-------------| +| Concept β†’ Working Code | 20-30 hours | 5-6 hours | **3.5-5.2x faster** | +| Code Coverage | 65% | 87% | **+22%** | +| Bug Rate | 0.8/100 LOC | 0.3/100 LOC | **-62%** | +| Human Intervention | 100% | <10% | **90% reduction** | + +--- + +## The Feedback Loop: What Makes C(RAID) "Continuous" + +The key insight of C(RAID) is that **deployment is not the end** - it's the beginning of the next research cycle. + +```mermaid +flowchart TB + subgraph Cycle1["Development Cycle"] + R1["Research
'New caching approach'"] + A1["Analysis
'PRD: Distributed cache'"] + I1["Integration
'Implement via SPARC'"] + D1["Deployment
'Production release'"] + end + + subgraph Feedback["Continuous Feedback"] + M["Metrics Collection"] + P["Performance Analysis"] + U["User Feedback"] + end + + subgraph Cycle2["Next Cycle"] + R2["Research
'Investigate cache misses'"] + end + + R1 --> A1 --> I1 --> D1 + D1 --> M + M --> P + P --> U + U --> R2 + + style Feedback fill:#f3e5f5,stroke:#7b1fa2 +``` + +**Examples of feedback-driven research:** + +- Cache miss rate high β†’ Research cache warming strategies +- Performance degradation β†’ Research optimization techniques +- Security vulnerability discovered β†’ Research mitigation patterns +- User complaints about UX β†’ Research design patterns + +--- + +## Implementing C(RAID) in Your Workflow + +### Quick Start + +```bash +# C(RAID) Cycle Example + +# 1. Continuous Research +/sc:research "https://www.youtube.com/watch?v=example" --research --think-hard + +# 2. Continuous Analysis +/pm:prd-new my-feature --source .claude/context/research.json +# Human reviews and approves PRD + +# 3. Continuous Integration +/pm:epic-oneshot my-feature --sync-github +/swarm:development --epic my-feature --agents 5 + +# 4. Continuous Deployment +/github:code-review-swarm --pr my-feature --reviewers 5 +/github:pr-manager merge my-feature --auto-deploy staging +# Human approves production deployment + +# Metrics collection begins, feeding next Research cycle +``` + +### Command Reference + +| C(RAID) Phase | Primary Commands | +|---------------|------------------| +| Research | `/sc:research`, `/automation:ai-pipeline:extract` | +| Analysis | `/pm:prd-new`, `/sparc:architect`, `/sc:design` | +| Integration | `/swarm:development`, `/sparc:coder`, `/pm:issue-start` | +| Deployment | `/github:code-review-swarm`, `/github:pr-manager` | + +--- + +## Conclusion + +C(RAID) represents the recognition that autonomous AI development requires a fundamentally different operational paradigm than human-driven development. + +**Traditional CI/CD** optimizes for integrating and deploying human-written code. + +**C(RAID)** optimizes for the complete autonomous development lifecycle: +- **Researching** what to build +- **Analyzing** how to build it +- **Integrating** the implementation +- **Deploying** with validation +- **Learning** from production feedback + +Combined with SPARC methodology for disciplined execution, C(RAID) provides the foundation for truly autonomous, continuously improving software development at scale. + +--- + +**See Also:** +- [Autonomous Pipeline Architecture](../01-architecture/autonomous-pipeline-architecture.md) +- [SPARC Methodology](../../.claude/agents/sparc/) +- [Agent Coordination Rules](../../.claude/rules/agent-coordination.md) +- [Command Routing Reference](../../.claude/rules/command-routing.md) + +--- + +**Navigate**: [← Vision](../03-vision/) | [Architecture β†’](../01-architecture/) diff --git a/claudedocs/03-vision/README.md b/claudedocs/03-vision/README.md index bf72fc9..e3e609b 100644 --- a/claudedocs/03-vision/README.md +++ b/claudedocs/03-vision/README.md @@ -2,28 +2,38 @@ **Purpose**: Strategic vision, concepts, and future direction for the project. +## The C(RAID) Paradigm + +**The foundational paradigm shift that enables truly autonomous AI development.** + +C(RAID) - Continuous Research, Analysis, Integration, Deployment - represents an evolution of traditional CI/CD designed specifically for autonomous LLM-based development. While CI/CD assumes human developers write code first, C(RAID) recognizes that AI agents must **research and analyze** before they can build effectively. + +> **See**: [CRAID_PARADIGM.md](./CRAID_PARADIGM.md) for the complete paradigm documentation. + ## Contents +- **CRAID_PARADIGM.md** - The C(RAID) paradigm: Continuous Research, Analysis, Integration, Deployment - **PROJECT_VISION.md** - Overall project vision and strategic direction ## What Belongs Here +- βœ… Paradigm-level conceptual frameworks (C(RAID)) - βœ… Strategic vision documents - βœ… Innovation proposals and concepts - βœ… Future direction planning -- βœ… Conceptual frameworks - βœ… Long-term strategic goals ### What Doesn't Belong -- ❌ Tactical feature planning (β†’ 04-planning/features/) -- ❌ Current implementation (β†’ 05-implementation/) -- ❌ Research findings (β†’ 02-research/) +- ❌ Tactical feature planning (-> 04-planning/features/) +- ❌ Current implementation (-> 05-implementation/) +- ❌ Research findings (-> 02-research/) ## Vision Themes Key strategic themes for the project: +- **C(RAID) Paradigm** - Continuous Research, Analysis, Integration, Deployment for autonomous AI development - **Multi-framework Integration** - Unified SuperClaude + CCPM + Claude Flow + Constitutional AI - **AI-Native Development** - Optimized for AI agent collaboration -- **Systematic Quality** - SPARC methodology and TDD practices +- **Systematic Quality** - SPARC methodology (inner execution loop) + C(RAID) (outer operational loop) - **Scalable Architecture** - Modular, maintainable, extensible --- diff --git a/docs/architecture/autonomous-pipeline-architecture.md b/docs/architecture/autonomous-pipeline-architecture.md index f630517..cef91e7 100644 --- a/docs/architecture/autonomous-pipeline-architecture.md +++ b/docs/architecture/autonomous-pipeline-architecture.md @@ -47,6 +47,23 @@ This document defines a comprehensive autonomous pipeline that transforms **rese --- +## C(RAID) Context + +This autonomous pipeline implements the **C(RAID) paradigm** - Continuous Research, Analysis, Integration, Deployment: + +| C(RAID) Phase | Pipeline Phase | Duration | Key Agents | +|---------------|----------------|----------|------------| +| **Continuous Research** | Phase 1: Concept Extraction | 3-5 min | researcher, deep-research-agent | +| **Continuous Analysis** | Phase 2: PRD Generation | 15-20 min | specification, planner, goal-planner | +| **Continuous Integration** | Phase 3-4: Decomposition + Implementation | 2-5 hours | coder, tester, task-orchestrator | +| **Continuous Deployment** | Phase 5: Validation & Deployment | 45 min | production-validator, reviewer | + +The pipeline represents one complete C(RAID) cycle. Deployment metrics and user feedback trigger the next Research phase, creating a continuous improvement loop. + +> **See Also**: [The C(RAID) Paradigm](../paradigm/index.rst) for the full paradigm documentation. + +--- + ## 1. Pipeline Overview ### 1.1 Five-Phase Autonomous Workflow diff --git a/docs/index.rst b/docs/index.rst index c1d3e66..addcc6b 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -3,6 +3,12 @@ Evolve: Autonomous AI Development Framework **An integrated framework combining SuperClaude behavioral modes, CCPM project management, and Claude Flow orchestration to enable truly autonomous, systematic software development at scale.** +.. toctree:: + :maxdepth: 2 + :caption: The Paradigm + + paradigm/index + .. toctree:: :maxdepth: 2 :caption: Getting Started diff --git a/docs/paradigm/index.rst b/docs/paradigm/index.rst new file mode 100644 index 0000000..98d6c7e --- /dev/null +++ b/docs/paradigm/index.rst @@ -0,0 +1,9 @@ +The C(RAID) Paradigm +==================== + +**C(RAID)** - Continuous Research, Analysis, Integration, Deployment - represents the foundational paradigm shift that enables truly autonomous AI development. + +This paradigm extends traditional CI/CD to include the research and analysis phases that are essential for autonomous LLM-based development, where AI agents must understand WHAT to build before they can build it. + +.. include:: ../../claudedocs/03-vision/CRAID_PARADIGM.md + :parser: myst_parser.sphinx_