Workflow Commands
Claude Octopus implements the Double Diamond methodology through four core workflow phases. Each phase can be run independently or as part of the complete/octo:embrace workflow.
Double Diamond Phases
The Double Diamond methodology divides work into four distinct phases:Phase 1: Discover (Probe)
Phase 1: Discover (Probe)
Divergent thinking - Broad exploration and research
- Multi-perspective research using Claude + Gemini + Codex
- Explore problem space and gather options
- Identify patterns, best practices, and trade-offs
- Generate comprehensive understanding before narrowing
Phase 2: Define (Grasp)
Phase 2: Define (Grasp)
Convergent thinking - Narrow down and clarify scope
- Build consensus on requirements using multi-AI analysis
- Lock in scope and boundaries
- Clarify problem statement and constraints
- Define success criteria and edge cases
Phase 3: Develop (Tangle)
Phase 3: Develop (Tangle)
Divergent thinking - Generate multiple implementation approaches
- Multiple AI perspectives on implementation
- Code generation and technical patterns
- Quality gate validation (75% consensus threshold)
- Security checks and best practices enforcement
Phase 4: Deliver (Ink)
Phase 4: Deliver (Ink)
Convergent thinking - Validate and finalize
- Multi-AI validation and review
- Security audit (OWASP compliance)
- Edge case analysis and testing
- Final quality synthesis and recommendations
/octo:embrace - Full Workflow
Complete Double Diamond workflow from research to delivery.
Syntax
What It Does
Runs all four phases sequentially:- Discover - Multi-provider research
- Define - Consensus building on approach
- Develop - Implementation with quality gates
- Deliver - Final validation and review
Options
Control execution flow:
supervised- Pause after each phase for approval (default)semi-autonomous- Only pause on quality gate failuresautonomous- Run all 4 phases without intervention
Project scope from clarifying questions:
small- Single component or small additionmedium- Multiple components, moderate complexitylarge- System-wide changes or new subsystemfull- Complete application or major architecture
Interactive Questions
Before execution, Claude asks 3 clarifying questions:- Scope: What’s the project size? (small/medium/large/full)
- Focus Areas: What needs attention? (architecture/security/performance/UX)
- Autonomy: How much oversight? (supervised/semi-auto/autonomous/manual)
Examples
When to Use
Use embrace for:
- Complex features requiring research → implementation
- High-stakes projects needing validation
- Features where you want multiple AI perspectives
- When you need structured quality gates
- Simple bug fixes or edits
- Quick research-only tasks (use
/octo:discover) - Code review only (use
/octo:deliver)
Quality Gates
The develop phase includes automatic validation:- 75% consensus threshold across AI providers
- Security checks (OWASP Top 10)
- Best practices verification
- Performance considerations
Results
Artifacts saved to:/octo:discover (Probe)
Discovery phase - Multi-AI research and exploration.
Syntax
Alias:
/octo:probe - Alternative name from Double Diamond methodologyWhat You Get
- Multi-AI research (Claude + Gemini + Codex + Perplexity)
- Comprehensive analysis of options and trade-offs
- Best practice identification
- Implementation considerations
- Technical patterns and ecosystem overview
Interactive Questions
- Depth: How deep should research go? (quick/moderate/comprehensive/deep)
- Focus: Primary area? (technical/best-practices/ecosystem/trade-offs)
- Output: Format preference? (detailed-report/summary/comparison/recommendations)
Examples
When to Use
- Starting a new feature
- Researching technologies or patterns
- Exploring design options
- Understanding problem space
- Gathering requirements
Natural Language Triggers
Auto-activates when you say:- “research”, “investigate”, “explore”
- “probe”, “study”, “analyze”
- “learn about”, “understand”
/octo:define (Grasp)
Definition phase - Clarify and scope with multi-AI consensus.
Syntax
Alias:
/octo:grasp - Alternative name from Double Diamond methodologyWhat You Get
- Multi-AI consensus on requirements
- Clear problem statement
- Scoped requirements with boundaries
- Edge case identification
- Constraint analysis
- Technical requirements definition
Examples
When to Use
Use define when you need:
- Requirements clarification: “Define requirements for X”
- Scope boundaries: “What exactly does X need to do?”
- Problem understanding: “Help me understand the problem with Y”
- Consensus building: Multiple AI perspectives on the approach
- Implementation (use
/octo:develop) - Research (use
/octo:discover) - Review (use
/octo:deliver)
Natural Language Triggers
Auto-activates when you say:- “define”, “clarify”, “scope”
- “what exactly”, “help me understand”
- “requirements for”, “boundaries of”
/octo:develop (Tangle)
Development phase - Build with multi-AI implementation and quality gates.
Syntax
Alias:
/octo:tangle - Alternative name from Double Diamond methodologyWhat You Get
- Multi-AI implementation (Claude + Gemini + Codex)
- Multiple implementation approaches
- Quality gate validation (75% consensus)
- Security checks (OWASP compliance)
- Best practices enforcement
- Performance considerations
Quality Gates
Automatic validation includes:- Consensus threshold: 75% agreement across AI providers
- Security: OWASP Top 10 compliance checks
- Best practices: Industry-standard patterns
- Performance: Scalability and efficiency review
Examples
When to Use
Use develop when you need:
- Building: “Build X” or “Implement Y”
- Creating: “Create Z feature”
- Code generation: “Write code to do Y”
- Multiple implementation perspectives
- Simple code edits (use Edit tool)
- Reading or reviewing code (use Read/review)
- Trivial single-file changes
Natural Language Triggers
Auto-activates when you say:- “build”, “create”, “implement”
- “develop”, “code”, “write”
- “make” (with specific target)
/octo:deliver (Ink)
Delivery phase - Review, validate, and test with multi-AI quality assurance.
Syntax
Alias:
/octo:ink - Alternative name from Double Diamond methodologyWhat You Get
- Multi-AI validation (Claude + Gemini + Codex)
- Security audit (OWASP compliance, vulnerability detection)
- Code quality review
- Edge case analysis
- Performance evaluation
- Comprehensive recommendations
Audit Coverage
Security Audit
Security Audit
- OWASP Top 10 vulnerabilities
- Authentication/authorization flaws
- Input validation and sanitization
- SQL injection and XSS risks
- Cryptography and data protection
Code Quality
Code Quality
- Design patterns and architecture
- Code complexity and maintainability
- Error handling
- Test coverage
- Documentation quality
Performance
Performance
- Scalability issues
- Inefficient algorithms
- Resource usage
- Caching opportunities
- Database query optimization
Edge Cases
Edge Cases
- Boundary conditions
- Error scenarios
- Race conditions
- Concurrency issues
- Input validation gaps
Examples
When to Use
Use deliver when you need:
- Review: “Review X” or “Code review Y”
- Validation: “Validate Z implementation”
- Testing: “Test the feature”
- Quality check: “Check if X works correctly”
- Implementation (use
/octo:develop) - Research (use
/octo:discover) - Requirements (use
/octo:define)
Natural Language Triggers
Auto-activates when you say:- “review”, “validate”, “check”
- “audit”, “inspect”, “verify”
- “test”, “quality check”
Workflow Comparison
| Command | Phase | Thinking | Multi-AI | Duration | Output |
|---|---|---|---|---|---|
/octo:discover | 1 | Divergent | Yes | 2-5 min | Research synthesis |
/octo:define | 2 | Convergent | Yes | 1-3 min | Requirements doc |
/octo:develop | 3 | Divergent | Yes | 3-8 min | Implementation |
/octo:deliver | 4 | Convergent | Yes | 2-5 min | Validation report |
/octo:embrace | 1-4 | Both | Yes | 8-20 min | Complete delivery |
Phase Dependencies
Next Steps
Try the Full Workflow
Start with
/octo:embrace for a complete featureSystem Commands
Configure your environment and providers