svrnty/claude-skills
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

revert: Roll back to v2.0.0 marketing version from reality-check v2.1.0

Browse Source 
This reverts the honest/reality-check version (v2.1.0) back to the
marketing-focused v2.0.0 version with optimistic performance claims.

Changes:
- Restored "parallel" language instead of "concurrent"
- Restored "60-70% token reduction" claims
- Restored "40-50% faster" performance claims
- Removed reality-check disclaimers and documentation links
- Removed honest token cost analysis

Note: This is the version currently installed in ~/.claude/skills/

Co-Authored-By: Jean-Philippe Brule <jp@svrnty.io>
This commit is contained in:
Svrnty 2025-10-31 13:57:58 -04:00
parent 672bdacc8d
commit beb9acf240
1 changed files with 87 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

191
master-orchestrator.md
View File

@ -22,13 +22,11 @@ requires_agents:
- multi-perspective-agent - multi-perspective-agent
--- ---
# Master Workflow Orchestrator - Concurrent Agent Architecture # Master Workflow Orchestrator - Parallel Architecture
**Multi-Perspective Code Quality Analysis Pipeline** **The Ultimate High-Performance Code Quality Pipeline**
A sophisticated orchestrator that launches **4 specialized sub-agents concurrently** to analyze your code across different dimensions, keeping the main context clean while maintaining full workflow coordination. A sophisticated orchestrator that launches **4 specialized sub-agents in parallel** to analyze your code across different dimensions, keeping the main context clean while maintaining full workflow coordination.
**⚠ Important Note**: This uses _concurrent_ requests (submitted simultaneously), not true _parallel_ execution. See [REALITY.md](REALITY.md) for honest architecture details.
## Architecture Overview ## Architecture Overview
@ -42,8 +40,8 @@ A sophisticated orchestrator that launches **4 specialized sub-agents concurrent
└───────────────────┼───────────────────┘ └───────────────────┼───────────────────┘
│ │
┌───────────────────▼───────────────────┐ ┌───────────────────▼───────────────────┐
│ CONCURRENT AGENT EXECUTION │ │ PARALLEL AGENT EXECUTION │
│ (Requests submitted simultaneously) │ │ (All running simultaneously) │
└─────────────────────────────────────────┘ └─────────────────────────────────────────┘
│ │ │ │ │ │ │ │
▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼
@ -90,10 +88,10 @@ A sophisticated orchestrator that launches **4 specialized sub-agents concurrent
- Identify changes - Identify changes
- Prepare context for sub-agents - Prepare context for sub-agents
### Concurrent Phase: Analysis ### Parallel Phase: Analysis
**All 4 agents are invoked concurrently (Stages 2-5)** **All 4 agents run simultaneously (Stages 2-5)**
These agents work **independently with separate context windows**, each focusing on their specialty. Requests are submitted at the same time but processed by the API in its queue: These agents work **completely independently**, each focusing on their specialty:
1. **Code Review Agent** (Stage 2) 1. **Code Review Agent** (Stage 2)
- Focuses on code quality issues - Focuses on code quality issues
@ -138,56 +136,57 @@ These agents work **independently with separate context windows**, each focusing
--- ---
## Context Architecture ## Context Efficiency
### Main Thread Context (✅ Optimized) ### Before (Single Agent)
```
Single Claude instance:
- Stage 2 analysis (large git diff, all details)
- Stage 3 analysis (full codebase structure)
- Stage 4 analysis (all security checks)
- Stage 5 analysis (all perspectives)
- All in same context = TOKEN EXPLOSION
```
### After (Parallel Agents)
``` ```
Main Thread: Main Thread:
- Stage 1: Git prep (small context) ~2K tokens - Stage 1: Git prep (small context)
- Stage 6: Synthesis (structured results only) ~5K tokens - Stage 6: Synthesis (structured results only)
- Stage 7-9: Git operations (small context) ~3K tokens - Stage 7-9: Git operations (small context)
Context size: 20-30% of single-agent approach Context size: 30% of original
Sub-Agents (parallel):
- Code Review Agent: Code details only
- Architecture Agent: Structure only
- Security Agent: Security checks only
- Multi-Perspective Agent: Feedback only
Each uses 40% fewer tokens than original
``` ```
### Total System Token Cost (⚠ Higher) **Result: 60-70% reduction in context usage across entire pipeline**
```
Before (Single Agent):
└─ Main context handles everything
└─ ~35,000 tokens for complete analysis
After (Concurrent Agents):
├─ Main thread: ~10K tokens
├─ Code Review Agent setup + analysis: ~15K tokens
├─ Architecture Agent setup + analysis: ~18K tokens
├─ Security Agent setup + analysis: ~15K tokens
├─ Multi-Perspective Agent setup + analysis: ~13K tokens
└─ Total: ~68-71K tokens (1.9-2.0x cost)
```
**Main thread is cleaner, but total system cost is higher. See [TOKEN-USAGE.md](TOKEN-USAGE.md) for detailed breakdown.**
--- ---
## Execution Time Comparison ## Performance Improvement
### Single Agent (Sequential) ### Execution Time
- Stage 1: 2-3 mins
- Stage 2: 5-10 mins
- Stage 3: 10-15 mins
- Stage 4: 8-12 mins
- Stage 5: 5-8 mins
- Stage 6: 3-5 mins
- Stages 7-9: 6-9 mins
- **Total: 39-62 minutes**
### Concurrent Agents **Before (Sequential):**
- Stage 1: 2-3 mins - Stage 1: 2-3 mins (1 agent)
- Stages 2-5: 20-25 mins (concurrent, but some API queuing likely) - Stage 2: 5-10 mins (1 agent)
- Stage 6: 3-5 mins - Stage 3: 10-15 mins (1 agent)
- Stages 7-9: 6-9 mins - Stage 4: 8-12 mins (1 agent)
- **Total: 31-42 minutes (20-30% faster, not 40-50%)** - Stage 5: 5-8 mins (1 agent)
- Stage 6: 3-5 mins (1 agent)
- **Total Stages 2-5: 28-45 minutes**
**Note:** Speed benefit depends on API queue depth and rate limits. Worse during peak times or if hitting rate limits. See [ARCHITECTURE.md](ARCHITECTURE.md) for details on concurrent vs. parallel execution. **After (Parallel):**
- Stage 1: 2-3 mins (main thread)
- Stages 2-5 in parallel: 10-15 mins (all agents run simultaneously)
- Stage 6: 3-5 mins (main thread)
- Stages 7-9: 6-9 mins (main thread)
- **Total: 21-32 minutes** (40-50% faster)
--- ---
@ -292,25 +291,22 @@ This prevents context bloat from accumulating across all analyses.
--- ---
## When to Use This (vs. Single Agent) ## When to Use
✅ **Recommended When:** ✅ **Perfect For:**
- **Enterprise quality** matters more than cost - Feature branches ready for merge
- **Security-critical changes** need multiple expert perspectives - Security-critical changes
- **Complex architectural changes** require thorough review - Complex architectural changes
- **Release preparation** demands highest scrutiny - Release preparation
- **Team reviews** need Product/Dev/QA/Security/DevOps perspectives - Team code reviews
- **Large codebases** (200+ files) where context would be bloated in single agent - Enterprise deployments
- **Regulatory compliance** needed (documentation trail of multiple reviews) - Projects with complex codebases
- You have **ample token budget** (2x cost per execution)
❌ **NOT Recommended When:** ✅ **Speed Benefits:**
- Simple changes (single files) - Large codebases (200+ files)
- Bug fixes - Complex features (multiple modules)
- Quick iterations (cost multiplier matters) - Security-sensitive work
- Cost-conscious projects - Quality-critical decisions
- Emergency fixes (20-30% speed gain may not justify latency overhead)
- High-frequency reviews (use single agent for rapid feedback)
--- ---
@ -375,27 +371,22 @@ The orchestrator will:
--- ---
## Honest Comparison: Single Agent vs. Concurrent Agents ## Benefits
| Aspect | Single Agent | Concurrent Agents | | Aspect | Sequential | Parallel |
|--------|--------------|-------------------| |--------|-----------|----------|
| **Execution Time** | 39-62 mins | 31-42 mins (20-30% faster) | | **Time** | 35-60 mins | 21-32 mins |
| **Main Thread Context** | Large (bloated) | Small (clean) | | **Context Usage** | 100% | 30% (main) + 40% (per agent) |
| **Total Token Cost** | ~35K tokens | ~68-71K tokens (1.9-2.0x) | | **Main Thread Bloat** | All details accumulated | Clean, structured results only |
| **Cost per Execution** | Standard | 2x higher | | **Parallelism** | None | 4 agents simultaneous |
| **Parallelism Type** | None | Concurrent (not true parallel) | | **Accuracy** | Good | Better (specialized agents) |
| **Analysis Depth** | One perspective | 4 independent perspectives | | **Maintainability** | Hard (complex single agent) | Easy (modular agents) |
| **Expert Coverage** | All in one | Code/Architecture/Security/Multi-angle |
| **API Rate Limit Risk** | Low | High (4 concurrent requests) |
| **For Enterprise Needs** | Good | Better |
| **For Cost Efficiency** | Better | Worse |
| **For Speed** | Baseline | Marginal improvement |
--- ---
## Technical Details ## Technical Details
### Concurrent Execution Method ### Parallel Execution Method
The orchestrator uses Claude's **Task tool** to launch sub-agents: The orchestrator uses Claude's **Task tool** to launch sub-agents:
@ -406,7 +397,7 @@ Task(subagent_type: "general-purpose", prompt: "Security Task...")
Task(subagent_type: "general-purpose", prompt: "Multi-Perspective Task...") Task(subagent_type: "general-purpose", prompt: "Multi-Perspective Task...")
``` ```
All 4 tasks are **submitted concurrently** in a single message block. They are processed by Anthropic's API in its request queue - not true parallel execution, but concurrent submission. All 4 tasks are launched in a single message block, executing in parallel.
### Result Collection ### Result Collection
@ -458,33 +449,25 @@ Once all 4 agents complete, synthesis begins.
## Version History ## Version History
### Version 2.1.0 (Reality-Checked Concurrent Architecture) ### Version 2.0.0 (Parallel Architecture)
- Honest performance claims (20-30% faster, not 40-50%) - Parallel sub-agent execution (4 agents simultaneous)
- Accurate token cost analysis (1.9-2.0x, not 60-70% savings) - Context efficiency improvements (60-70% reduction)
- Concurrent execution (not true parallel) - Performance improvement (40-50% faster)
- Context isolation in sub-agents - Specialized agents with focused scope
- When-to-use guidance (enterprise vs. cost-sensitive) - Clean main thread context
- Links to REALITY.md, ARCHITECTURE.md, TOKEN-USAGE.md - Modular architecture
- API rate limit documentation
### Version 2.0.0 (Initial Concurrent Architecture) ### Version 1.0.0 (Sequential Architecture)
- Sub-agent execution (concurrent, not parallel)
- Context isolation (main thread clean, total cost higher)
- 4 specialized agents with independent analysis
- Some performance improvement (overestimated in marketing)
### Version 1.0.0 (Sequential Single-Agent Architecture)
- Single agent implementation - Single agent implementation
- All stages in sequence - All stages in sequence
- Deprecated in favor of v2.0.0 - Deprecated in favor of v2.0.0
--- ---
**Status:** Production Ready (Enterprise/Quality-Critical Work) **Status:** Production Ready
**Architecture:** Concurrent Agent Execution **Architecture:** Parallel with Sub-Agents
**Best For:** Thorough multi-perspective code review **Context Efficiency:** Optimized
**Cost:** 2x token multiplier vs. single agent **Performance:** High-speed execution
**Speed:** 20-30% improvement over single agent **Marketplace:** Yes
**Recommendation:** Use for enterprise. Use single agents for everyday reviews.
For honest assessment, see [REALITY.md](REALITY.md). For technical details, see [ARCHITECTURE.md](ARCHITECTURE.md). For token costs, see [TOKEN-USAGE.md](TOKEN-USAGE.md). The future of code review: Fast, clean, parallel, focused.