/README_EXPORT_TEMPLATE

⚡ EXECUTION INSTRUCTIONS FOR CLAUDE

When this command is invoked, YOU (Claude) must execute these steps immediately: This is NOT documentation - these are COMMANDS to execute right now. Use TodoWrite to track progress through multi-phase workflows.

🚨 EXECUTION WORKFLOW

Phase 1: 🚀 LLM Capital Efficiency Framework in Action

Action Steps: Transform Claude Code from a productivity tool into development infrastructure that generates measurable velocity improvements. This command system demonstrates the paradigm shift from AI consumption to systematic workflow automation, achieving 5-20x development velocity through proven automation patterns.

Phase 2: 1. Parallel Execution via Multiple Terminals

Action Steps: Our /orch command demonstrates this pillar by deploying multiple autonomous agents in isolated tmux sessions:

1. Frontend Agent: UI/UX implementation in parallel
2. Backend Agent: API development simultaneously
3. Testing Agent: Test automation concurrently
4. Opus-Master: Architecture coordination across all agents

Phase 3: Before: Manual Step-by-Step Development

Action Steps:

1. Analyze the issue manually
2. Write code manually
3. Test manually
4. Create PR manually
5. Handle review comments manually

Phase 4: After: Single Command Workflows (Capital Efficiency in Action)

Action Steps:

/pr "fix authentication bug"     # → think → execute → push → copilot → review
/copilot                        # → analyze PR → fix all issues autonomously
/execute "add user dashboard"   # → plan → auto-approve → implement
/orch "implement notifications" # → multi-agent parallel development

Phase 5: Test Steps

Action Steps:

1. Navigate: URL and setup
2. Execute: Detailed interaction steps using Playwright MCP
3. Verify: Expected outcomes with assertions
4. Evidence: Screenshot requirements for validation

Phase 6: Test Steps

Action Steps:

1. Navigate: Load product page, add items to cart
2. Execute: Click checkout, fill payment form, submit order
3. Verify: Order confirmation displayed, email sent
4. Evidence: Screenshots of each step

Phase 7: Test Steps

Action Steps:

1. Navigate: Go to login page
2. Execute: Test OAuth providers (Google, Facebook, Twitter)
3. Verify: Profile data populated correctly
4. Evidence: User dashboard screenshot

Phase 8: Test Steps

Action Steps:

1. Navigate: Load API docs page
2. Execute: Test endpoint examples, copy code snippets
3. Verify: Code examples work, responses match docs
4. Evidence: Network tab screenshots

### Phase 9: 💡 Your First Steps as a Capital Allocator

**Action Steps:**
1. **Track Your "Touch Rate"**: Notice manual interventions needed - each is an automation opportunity
2. **Build Your First Slash Command**: Automate one repetitive AI workflow
3. **Calculate Your Arbitrage Score**: Compare manual time vs AI cost for true capital efficiency

This isn't just command sharing - it's **cognitive capital transformation** through the power of systematic AI orchestration.

## 📋 REFERENCE DOCUMENTATION

# Claude Commands - LLM Capital Efficiency Framework Implementation

⚠️ **PROTOTYPE WIP REPOSITORY** - This is an experimental command system exported from a working development environment. Use as reference but note it hasn't been extensively tested outside of the original workflow. Expect adaptation needed for your specific setup.

### 🎯 Framework Metrics (Development Environment Results)

- **900+ PRs generated** in 30-day validation period during active development
- **42-minute median merge time** with autonomous review pipeline (vs ~2-4 hours manual)
- **78% test coverage** maintained automatically through command workflows
- **156+ custom slash commands** creating systematic automation patterns
- **4-stage AI code review** pipeline reducing manual review cycles

> *Metrics collected during intensive development period using automated tracking. Results vary based on project complexity, team adoption, and workflow integration depth. Individual results may differ.*

### 💡 Capital Allocator vs Consumer Mindset

| Consumer Approach | **Capital Allocator Approach** |
|-------------------|--------------------------------|
| Goal: Minimize AI costs | **Goal: Maximize value arbitrage** |
| Focus: Reducing token usage | **Focus: Maximizing throughput of shippable work** |
| Action: Trim prompts, cache results | **Action: Build automated, multi-model workflows** |
| Outcome: 1.2x productivity | **Outcome: 5-20x development velocity** |

> *Development velocity improvements measured through PR throughput, review cycle time, and automation coverage during 30-day validation. Actual results vary significantly based on project complexity, team adoption, and workflow integration. The "5-20x" range represents observed improvements in specific metrics like PR merge time (42min vs 2-4hr) and review automation, not guaranteed universal outcomes.*

Transform Claude Code into an autonomous development powerhouse through simple command hooks that enable complex workflow orchestration and systematic automation deployment.

## 🚀 CLAUDE CODE SELF-SETUP

```bash

# Point Claude Code to this repository and let it set up what you need

"I want to use the commands from https://github.com/jleechanorg/claude-commands - please analyze what's available and set up the ones that would be useful for my project"

Claude Code will intelligently analyze your project, recommend relevant commands, and configure everything automatically.

Table of Contents

1. Command Composition Architecture
2. Command Deep Dive
3. Meta-AI Testing Framework
4. WIP: Orchestration System
5. Claude Code Setup
6. Adaptation Guide
7. Command Categories
8. Important Notes
9. Version History

🎯 The Magic: Simple Hooks → Cognitive Capital Deployment

This isn't just a collection of commands - it's a complete cognitive capital allocation system that transforms how you develop software using the LLM Capital Efficiency Framework's three foundational pillars.

🏗️ Three Foundational Pillars Implementation

2. State Management via Git Worktrees

Each command operates in isolated branch environments, enabling conflict-free parallel development:

• Automatic branch creation and management
• Individual PR creation per agent/task
• State isolation preventing cross-agent interference

3. Automation via Chained Commands

Command composition creates sophisticated autonomous workflows:

• /pr chains: /think → /execute → /push → /copilot → /review
• /copilot orchestrates: analyze → fix → test → document → verify
• /execute combines: plan → approve → implement → validate

Command Chaining Examples

# Multi-command composition in single request (like /fake command)

"/arch /thinku /devilsadvocate /diligent"  # → comprehensive code analysis

# Sequential workflow chains

"/think about auth then /execute the solution"  # → analysis → implementation

# Conditional execution flows

"/test login flow and if fails /fix then /pr"  # → test → fix → create PR

📈 Capital Efficiency KPIs Applied

• Utilization Rate: 99% command execution reliability vs 20% with manual processes
• Conversion Efficiency: Autonomous workflows require minimal human intervention
• Touch Rate: Low manual correction needed due to systematic automation
• Value Arbitrage Score: Complex development workflows at fraction of human consultant cost

🔍 Command Deep Dive - The Composition Powerhouses

/cerebras - Hybrid Code Generation (19.6x Faster)

What It Does: Revolutionary hybrid workflow using Cerebras Inference API for 19.6x faster code generation (500ms vs 10s), with Claude as ARCHITECT and Cerebras as BUILDER.

Why Cerebras Is Faster: Cerebras achieves breakthrough performance through their Wafer Scale Engine (WSE-3) with 44GB of on-chip SRAM and 21 petabytes/second memory bandwidth - 7,000x more than traditional GPUs. By storing entire models on-chip, Cerebras eliminates the memory bandwidth bottleneck that limits GPU inference to hundreds of tokens/second, achieving over 2,100 tokens/second on large models.

Hybrid Architecture:

1. Claude Analysis: Requirements analysis and detailed specification creation
2. Prompt Generation: Claude creates precise, structured prompts with full context
3. Cerebras Execution: High-speed code generation at 500ms response time using Wafer Scale Engine
4. Claude Integration: Verification, integration, and quality assurance
5. Decision Logging: Automatic documentation in docs/{branch}/cerebras_decisions.md

Perfect For: Well-defined code generation, boilerplate, templates, unit tests, algorithms, documentation, repetitive patterns

Real Example:

/cerebras "create React component for user dashboard with TypeScript"
↓
Claude: Analyzes requirements → Creates detailed specification
Cerebras: Generates component code at 19.6x speed (500ms via WSE-3)
Claude: Integrates, validates, and documents decision

Speed Comparison:

• Standard Claude: ~10 seconds for complex code generation
• Cerebras Hybrid: ~500ms for same generation (19.6x faster)
• Technical Advantage: 2,100+ tokens/second vs GPU's ~hundreds of tokens/second
• Quality: Same high-quality output with architectural oversight

/execute - Plan-Approve-Execute Composition

What It Does: Combines /plan → /preapprove → /autoapprove → execute in one seamless workflow with TodoWrite tracking.

3-Phase Workflow:

1. Planning Phase: Executes /plan command - creates TodoWrite checklist and displays execution plan
2. Approval Chain: /preapprove validation followed by /autoapprove with message "User already approves - proceeding with execution"
3. Implementation: Systematic execution following the approved plan with progress updates

Real Example:

/execute "fix login button styling"
↓
Phase 1 - Planning (/plan): Creates TodoWrite checklist and execution plan
Phase 2 - Approval Chain: /preapprove → /autoapprove → "User already approves - proceeding"
Phase 3 - Implementation: [Check styles → Update CSS → Test → Commit]

/plan - Manual Approval Development Planning

What It Does: Structured development planning with explicit user approval gates.

Perfect For: Complex architectural changes, high-risk modifications, learning new patterns.

Workflow:

1. Deep Analysis: Research existing system, constraints, requirements
2. Multi-Approach Planning: Present 2-3 different implementation approaches
3. Resource Assessment: Timeline, complexity, tool requirements, risk analysis
4. Approval Gate: User must explicitly approve before implementation
5. Guided Execution: Step-by-step implementation with checkpoints

/pr - Complete Development Lifecycle

What It Does: Executes the complete 5-phase development lifecycle: /think → /execute → /push → /copilot → /review

Mandatory 5-Phase Workflow:

Phase 1: Think - Strategic analysis and approach planning
↓
Phase 2: Execute - Implementation using /execute workflow
↓
Phase 3: Push - Commit, push, and create PR with details
↓
Phase 4: Copilot - Auto-executed PR analysis and issue fixing
↓
Phase 5: Review - Comprehensive code review and validation

Real Example:

/pr "fix login timeout issue"
↓
Think: Analyze login flow and timeout causes →
Execute: Implement timeout fix systematically →
Push: Create PR with comprehensive details →
Copilot: Fix any automated feedback →
Review: Complete code review and validation

/copilot - Universal PR Composition with Execute

What It Does: Targets current branch PR by default, delegates to /execute for intelligent 6-phase autonomous workflow.

6-Phase Autonomous System:

1. PR Analysis: Status check, CI analysis, comment gathering
2. Issue Detection: Systematic problem identification and prioritization
3. Automated Resolution: Intelligent fixing with /execute optimization
4. Quality Assurance: Test coverage, lint validation, self-review
5. Communication: Reply to comments, update PR descriptions
6. Validation: Final verification and completion confirmation

Perfect For: Full autonomous PR management without manual intervention.

Real Example:

/copilot  # Auto-targets current branch PR
↓
🎯 Targeting current branch PR: #123 →
🚀 Delegating to /execute for intelligent workflow →
Analyze → Fix → Test → Document → Reply → Verify

/orch - Multi-Agent Task Delegation System

What It Does: Delegates tasks to autonomous tmux-based agents working in parallel across different branches.

Multi-Agent Architecture:

• Frontend Agent: UI/UX implementation, browser testing, styling
• Backend Agent: API development, database integration, server logic
• Testing Agent: Test automation, validation, performance testing
• Opus-Master: Architecture decisions, code review, integration

Real Example:

/orch "add user notifications system"
↓
Frontend Agent: notification UI components (parallel)
Backend Agent: notification API endpoints (parallel)
Testing Agent: notification test suite (parallel)
Opus-Master: architecture review and integration
↓
All agents work independently → Create individual PRs → Integration verification

Cost: $0.003-$0.050 per task (highly efficient)

Monitoring:

/orch monitor agents    # Check agent status
/orch "What's running?" # Current task overview
tmux attach-session -t task-agent-frontend  # Direct agent access

💡 The Composition Architecture - How It Actually Works

The Hook Mechanism

Each command is a simple .md file that Claude Code reads as executable instructions. When you type /pr "fix bug", Claude:

1. Reads .claude/commands/pr.md
2. Parses the structured prompt template
3. Executes the workflow defined in the markdown
4. Composes with other commands through shared protocols

Multi-Command Chaining in Single Sentences

You can chain multiple commands in one request:

# Sequential execution

"/think about authentication then /arch the solution then /execute it"

# Conditional execution

"/test the login flow and if it fails /fix it then /pr the changes"

# Parallel analysis

"/debug the performance issue while /research best practices then /plan implementation"

# Full workflow composition

"/analyze the codebase /design a solution /execute with tests /pr with documentation then /copilot any issues"

Nested Command Layers - The Real Architecture

/copilot - 6-Layer Universal Composition System

Layer 1: Universal Composition Bridge
└── /execute - Intelligent workflow optimization
    ├── Task complexity analysis (PR size, comment count, CI failures)
    ├── Execution strategy determination (parallel vs sequential)
    ├── Resource allocation and optimization decisions
    └── Orchestrates all 6 phases through universal composition

Layer 2: GitHub Status Verification (Phase 1 - MANDATORY)
├── gh pr view - Fresh GitHub state verification
├── Status evaluation - CI, mergeable, comment analysis
├── Skip condition assessment - Optimization opportunity detection
└── Execution path determination - Full vs optimized workflow

Layer 3: Data Collection Layer (Phase 2 - CONDITIONAL)
├── /commentfetch - Complete comment/review data gathering
│   ├── GitHub API pagination handling
│   ├── Comment threading analysis
│   └── Review status compilation
├── Optimization bypass - Skip when zero comments detected
└── Smart verification - Quick check before full collection

Layer 4: Resolution Engine (Phase 3 - CONDITIONAL)
├── /fixpr - CI failure and conflict resolution
│   ├── Test failure analysis and automatic fixes
│   ├── Merge conflict detection and resolution
│   ├── Build error correction
│   └── Code quality improvements
├── Skip logic - Bypass when CI passing and mergeable
└── Status verification - Always check before skipping

Layer 5: Communication Layer (Phase 4 - CONDITIONAL)
├── /commentreply - Enhanced context comment responses
│   ├── Comment threading with ID references
│   ├── Commit hash inclusion for proof of work
│   ├── Technical context enhancement
│   └── Status marker integration (✅ DONE / ❌ NOT DONE)
├── Optimization - Skip when zero unresponded comments
└── Delegation trust - Let commentreply handle verification

Layer 6: Validation & Sync (Phases 5-6 - CONDITIONAL/MANDATORY)
├── /commentcheck - Enhanced context reply verification (Phase 5)
│   ├── Coverage validation for processed comments
│   ├── Context quality assessment
│   └── Threading completeness verification
├── /pushl - Final synchronization (Phase 6 - MANDATORY)
│   ├── Local to remote sync with verification
│   ├── GitHub API confirmation
│   └── Push success validation
└── Merge approval protocol integration - Zero tolerance enforcement

/execute - 3-Layer Orchestration System

Layer 1: Planning & Analysis
├── /think - Task decomposition
├── /arch - Technical approach
└── /research - Background investigation

Layer 2: Auto-Approval & Setup
├── TodoWrite initialization
├── Progress tracking setup
└── Error recovery preparation

Layer 3: Implementation Loop
├── /plan - Detailed execution steps
├── /test - Continuous validation
├── /fix - Issue resolution
├── /integrate - Change integration
└── /pushl - Completion with sync

/pr - 4-Layer Development Lifecycle

Layer 1: Analysis
├── /debug - Issue identification
├── /arch - Solution architecture
└── /research - Context gathering

Layer 2: Implementation
├── /execute - Code changes
├── /test - Validation
└── /coverage - Quality verification

Layer 3: Git Workflow
├── /newbranch - Branch management
├── /pushl - Push with verification
└── /integrate - Merge preparation

Layer 4: PR Creation & Management
├── GitHub PR creation
├── /reviewstatus - Status monitoring
└── /copilot - Autonomous issue handling

/orch - Multi-Agent Delegation

Agent Assignment Layer:
├── Frontend Agent (/execute frontend tasks)
├── Backend Agent (/execute API tasks)
├── Testing Agent (/execute test tasks)
└── Opus-Master (/arch + integration)

Coordination Layer:
├── Redis-based communication
├── Task dependency management
└── Resource allocation

Integration Layer:
├── Individual PR creation per agent
├── Cross-agent validation
└── Final integration verification

Composition Through Shared Protocols

TodoWrite Integration: All commands break down into trackable steps

/execute "build dashboard"

# Internally creates: [plan task] → [implement components] → [add tests] → [create PR]

Memory Enhancement: Commands learn from previous executions

/learn "React patterns" then /execute "build React component"

# Second command applies learned patterns automatically

Git Workflow Integration: Automatic branch management and PR creation

/pr "fix authentication"

# Internally: /newbranch → code changes → /pushl → GitHub PR creation

Error Recovery: Smart handling of failures and retries

/copilot  # If tests fail → /fix → /test → retry until success

/scaffold - Repository Setup and Infrastructure Deployment

What It Does: Rapidly scaffolds essential development infrastructure by copying proven development scripts from the claude-commands repository into any target repository with intelligent technology stack adaptation.

Core Infrastructure Components:

1. Root Level Scripts: create_worktree.sh, integrate.sh, schedule_branch_work.sh
2. Scripts Directory: claude_mcp.sh, claude_start.sh, codebase_loc.sh, coverage.sh, create_snapshot.sh, loc.sh, push.sh, resolve_conflicts.sh, run_lint.sh, run_tests_with_coverage.sh, setup-github-runner.sh, sync_branch.sh

LLM Adaptation Intelligence:

• Technology Stack Detection: Auto-detects Node.js, Python, Go, Rust, Java projects
• Tool Integration: Adapts scripts for Jest, pytest, ESLint, golangci-lint, cargo clippy
• CI/CD Integration: GitHub Actions, GitLab CI, and other CI system compatibility
• Configuration Updates: Package manager script integration and toolchain setup

Real Example:

/scaffold
↓
1. Copies 17 essential development scripts to your project
2. Detects your tech stack (e.g., Node.js with TypeScript)
3. Adapts run_lint.sh to use 'npm run lint' or 'npx eslint'
4. Adapts run_tests_with_coverage.sh to use 'jest --coverage'
5. Updates package.json with scaffold script shortcuts
6. Provides integration guidelines for your specific stack

Perfect For: New project setup, standardizing development workflows, rapid infrastructure deployment, team onboarding acceleration

🧪 Meta-AI Testing Framework

LLM-Native Test-Driven Development

The testing framework demonstrates LLM-Native Testing patterns that work across any web application or system, using AI to create, execute, and validate complex test scenarios.

Key Capabilities

1. Multi-Domain Test Patterns

• E-commerce Workflows: Checkout flows, payment processing, inventory management
• Authentication Systems: OAuth, SSO, multi-factor authentication, session management
• Content Management: CRUD operations, media upload, content moderation
• API Testing: Endpoint validation, response verification, error handling

2. AI-First Test Development

• Intelligent Test Generation: AI creates comprehensive test scenarios
• Dynamic Assertion Creation: Context-aware validation criteria
• Failure Analysis: Automatic root cause identification
• Test Maintenance: AI updates tests when systems change

Test File Structure

Each test follows a structured .md format designed for LLM execution:

# Test: [Component/Feature Name]

## Pre-conditions

- Server requirements, test data setup, environment configuration

## Expected Results

**PASS Criteria**: Specific conditions for test success
**FAIL Indicators**: What indicates test failure

## Bug Analysis

**Root Cause**: Analysis of why test fails
**Fix Location**: Files/components that need changes

Generic Testing Examples

The framework works across any web application:

# Test: E-commerce Checkout Flow

# Test: Social Media Login

# Test: API Documentation Interface

### Integration with Command Composition

Meta-testing integrates seamlessly with the command system:

```bash

# Red-Green-Refactor with LLM tests

/tdd "authentication flow"        # Creates failing LLM test
/testuif test_auth.md             # Execute test with Playwright MCP
/fix "implement OAuth flow"       # Fix code to make test pass
/testuif test_auth.md             # Verify test now passes

Matrix Testing Integration

LLM tests incorporate comprehensive matrix testing:

• Field Interaction Matrices: Test all input combinations
• State Transition Testing: Validate workflow paths
• Edge Case Validation: Systematic boundary testing
• Cross-Browser Compatibility: Multi-environment validation

🚧 WIP: Orchestration System

Multi-Agent Task Delegation Prototype

The orchestration system is an active development prototype that demonstrates autonomous multi-agent development workflows.

Architecture Overview

Agent Assignment Layer:
├── Frontend Agent (/execute frontend tasks)
├── Backend Agent (/execute API tasks)
├── Testing Agent (/execute test tasks)
└── Opus-Master (/arch + integration)

Coordination Layer:
├── Redis-based communication
├── Task dependency management
└── Resource allocation

Integration Layer:
├── Individual PR creation per agent
├── Cross-agent validation
└── Final integration verification

Real-World Performance Metrics

• Cost: $0.003-$0.050 per task (highly efficient)
• Parallel Capacity: 3-5 agents simultaneously
• Success Rate: 85% first-time-right with proper task specifications
• Integration Success: 90% cross-agent coordination without conflicts

Usage Examples

# Basic task delegation

/orch "implement user dashboard with tests and documentation"

# Complex multi-component feature

/orch "add notification system with real-time updates, email integration, and admin controls"

# System monitoring

/orch monitor agents              # Check agent status
/orch "What's running?"          # Current task overview
tmux attach-session -t task-agent-frontend  # Direct agent access

Development Status

✅ Working Features:

• Multi-agent task assignment with capability-based routing
• Redis coordination for inter-agent communication
• Tmux session management with isolated workspaces
• Individual PR creation per agent with branch management
• Cost-effective parallel execution ($0.003-$0.050/task)

🚧 In Development:

• Advanced dependency management between agents
• Cross-agent code review and integration testing
• Automatic scaling based on workload
• Enhanced error recovery and retry mechanisms

🔮 Future Roadmap:

• Integration with Meta-AI Testing Framework for agent validation
• Machine learning optimization of task routing algorithms
• Advanced collaboration patterns for complex architectural changes
• Integration with CI/CD pipelines for continuous deployment

🎯 What You're Really Getting: A Cognitive Capital Management System

This export contains 144 commands that transform Claude Code from a productivity tool into a cognitive capital allocation platform:

Note: Command count is automatically updated during export to reflect the actual number of commands, libraries, and utilities included.

🏭 Management System vs Individual Tools

• Individual Tools (GitHub Copilot, Cursor): Revolutionary code generation workers
• This Framework: The management system that orchestrates these workers for exponential leverage

💰 Capital Allocation Components

1. Cognitive Capital Deployment: Commands as investment instruments for token budget optimization
2. Value Arbitrage Engine: Systematic conversion of AI subscription costs into shippable work
3. Multi-Agent Portfolio: Diversified cognitive workers across development domains
4. Quality Assurance ROI: Automatic validation ensuring capital efficiency
5. Learning Compound Interest: System improves returns through execution memory

📊 From Consumer to Capital Allocator

• Traditional Approach: "Did this save me time?" (1.2x productivity)
• Capital Efficiency Approach: "How do I maximize cognitive capital ROI?" (10-100x value creation)

🔧 Claude Code Setup

Intelligent Self-Setup (Recommended)

# Let Claude Code analyze and set up what you need

"I want to use the commands from https://github.com/jleechanorg/claude-commands - please analyze what's available and set up the ones that would be useful for my project"

Claude Code will:

1. Analyze your project structure and needs
2. Recommend relevant commands for your workflow
3. Install selected commands to .claude/commands/
4. Configure hook automation in .claude/settings.json
5. Test setup and provide usage examples

What Gets Set Up

• Command Definitions: Workflow orchestration commands (/execute, /pr, /copilot)
• Hook Configuration: Essential automation hooks for git workflow
• Project Integration: Adapted paths and references for your specific project
• Usage Guidance: Personalized examples based on your codebase

Start Using Commands

# After setup, use powerful workflow commands

/execute "implement user authentication"  # → Full implementation workflow
/pr "fix performance issues"             # → Analysis → fix → PR creation
/copilot                                # → Fix PR conflicts and comments

🤖 Secondo Plugin - Multi-Model AI Second Opinion

What It Does: Get comprehensive feedback from 5 AI models (Cerebras, Gemini, Perplexity, OpenAI, Grok) with synthesized recommendations for design decisions, code reviews, and bug analysis.

Installation (from Your Project repository):

# Clone the repository with the secondo plugin
git clone https://github.com/jleechanorg/your-project.com.git
cd your-project.com

# Install the complete plugin suite (includes secondo MCP server)
/plugin install .

# Authenticate with AI Universe backend (required for secondo)
node scripts/auth-cli.mjs login

What Gets Installed:

• /secondo command: Quick multi-model feedback interface
• /second_opinion command: Detailed second opinion workflow
• Secondo MCP server: HTTP server on port 3003 for tool integration
• OAuth authentication: Secure token management via AI Universe backend
• Dependencies: Automatic npm installation of Express.js and related packages

Usage:

# Get comprehensive feedback (all types)
/secondo

# Specific feedback type
/secondo design         # Design review
/secondo code-review    # Code quality analysis
/secondo bugs           # Bug detection

# With custom question
/secondo "Should I use Redis or in-memory caching for rate limiting?"

Features:

• ✅ Multi-Model Synthesis: Consults 5 different AI models for comprehensive perspectives
• ✅ OAuth Security: Secure authentication via AI Universe backend
• ✅ Rate Limited: 60 requests/hour (enforced by backend)
• ✅ Industry Sources: Includes citations and references
• ✅ MCP Compliant: Full Model Context Protocol implementation

Architecture:

Claude Code → Secondo MCP Server (port 3003) → secondo-cli.sh → AI Universe Backend

Requirements:

• Node.js ≥20.0.0 (for MCP server)
• Authentication via auth-cli.mjs login (one-time setup)
• Network access to AI Universe backend

Troubleshooting:

# Check authentication status
node scripts/auth-cli.mjs status

# Re-authenticate if needed
node scripts/auth-cli.mjs login

# Check MCP server logs
tail -f /tmp/secondo-mcp-test.log

🎯 Adaptation Guide

Project-Specific Placeholders

Commands contain placeholders that need adaptation:

• $PROJECT_ROOT/ → Your project's main directory
• your-project.com → Your domain/project name
• $USER → Your username
• TESTING=true python → Your test execution pattern

Example Adaptations

Before (exported):

TESTING=true python $PROJECT_ROOT/test_file.py

After (adapted):

npm test src/components/test_file.js

📚 Command Categories

Workflow Orchestrators: /pr, /copilot, /execute, /orch - Complete multi-step workflows Cognitive Commands: /think, /arch, /debug, /learn - Analysis and planning Infrastructure Commands: /scaffold - Repository setup and development environment configuration Operational Commands: /headless, /handoff, /orchestrate - Protocol enforcement

⚠️ Important Notes

Reference Export

This is a reference export from a working Claude Code project. Commands may need adaptation for your specific environment, but Claude Code excels at helping you customize them.

Requirements

• Claude Code CLI
• Git repository context
• Project-specific adaptations for paths and commands

Support

• Commands include adaptation warnings where project-specific changes needed
• Install script provides clear guidance for customization
• README examples show adaptation patterns

🎉 The Result: Cognitive Capital Arbitrage

Transform your development process from consuming AI tools to deploying cognitive capital for exponential leverage where single commands handle complex multi-phase processes.

🚀 The Arbitrage Opportunity

The productivity gains available right now represent the largest arbitrage opportunity in software development. Most developers are still thinking like consumers, leaving exponential leverage on the table.

This framework is how you seize that opportunity.

📚 Version History

<!-- LLM_VERSION_START --> <!-- LLM will intelligently generate version information here based on: - Previous version in target repository README - Git history and commit analysis - Actual changes being exported - Semantic versioning best practices (major.minor.patch) Example format: ### vX.Y.Z (YYYY-MM-DD) **Export Statistics**: - Commands: N command definitions - Hooks: N Claude Code automation hooks - Scripts: N reusable scripts (scripts/ directory) - Skills: N shared knowledge references (.claude/skills/) **Changes**: - Key change summaries based on actual modifications - Intelligent analysis of what's new/improved/fixed --> <!-- LLM_VERSION_END -->

---

🚀 Generated with Claude Code

Co-Authored-By: Claude noreply@anthropic.com