Workflow Commands

Double Diamond methodology phases and full lifecycle workflows

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)

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)

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)

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)

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

/octo:embrace "<natural language description>"
/octo:embrace build user authentication system
/octo:embrace create payment processing feature

What It Does

Runs all four phases sequentially:

1. Discover - Multi-provider research
2. Define - Consensus building on approach
3. Develop - Implementation with quality gates
4. Deliver - Final validation and review

Options

--autonomy · string · default: "supervised"

Control execution flow:

• supervised - Pause after each phase for approval (default)
• semi-autonomous - Only pause on quality gate failures
• autonomous - Run all 4 phases without intervention

--scope · string

Project scope from clarifying questions:

• small - Single component or small addition
• medium - Multiple components, moderate complexity
• large - System-wide changes or new subsystem
• full - Complete application or major architecture

Interactive Questions

Before execution, Claude asks 3 clarifying questions:

1. Scope: What’s the project size? (small/medium/large/full)
2. Focus Areas: What needs attention? (architecture/security/performance/UX)
3. Autonomy: How much oversight? (supervised/semi-auto/autonomous/manual)

Examples

Supervised Mode (Default)

/octo:embrace "implement OAuth authentication"
# Pauses after each phase for review and approval

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

Don’t use for:

• 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:

~/.claude-octopus/results/
  ├── probe-synthesis-<timestamp>.md     # Discover phase
  ├── grasp-consensus-<timestamp>.md      # Define phase
  ├── tangle-validation-<timestamp>.md    # Develop phase
  └── delivery-<timestamp>.md             # Deliver phase

---

/octo:discover (Probe)

Discovery phase - Multi-AI research and exploration.

Syntax

/octo:discover "<research topic>"
/octo:discover OAuth security patterns
/octo:probe database architectures for multi-tenant SaaS

Alias: /octo:probe - Alternative name from Double Diamond methodology

What 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

1. Depth: How deep should research go? (quick/moderate/comprehensive/deep)
2. Focus: Primary area? (technical/best-practices/ecosystem/trade-offs)
3. Output: Format preference? (detailed-report/summary/comparison/recommendations)

Examples

Quick Overview

/octo:discover "OAuth 2.0 authentication flows"
# 1-2 min surface-level scan

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

/octo:define "<problem or feature>"
/octo:define requirements for user authentication
/octo:grasp scope of notification system

Alias: /octo:grasp - Alternative name from Double Diamond methodology

What You Get

• Multi-AI consensus on requirements
• Clear problem statement
• Scoped requirements with boundaries
• Edge case identification
• Constraint analysis
• Technical requirements definition

Examples

Clarify Requirements

/octo:define "what does the payment system need to do?"
# Multi-AI consensus on functional requirements

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

Don’t use for:

• 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

/octo:develop "<implementation task>"
/octo:develop build user authentication
/octo:tangle implement OAuth 2.0 flow

Alias: /octo:tangle - Alternative name from Double Diamond methodology

What 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

Standard Implementation

/octo:develop "build JWT authentication middleware"
# Multi-AI implementation with quality gates

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

Don’t use for:

• 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

/octo:deliver "<validation task>"
/octo:deliver review authentication implementation
/octo:ink validate API security

Alias: /octo:ink - Alternative name from Double Diamond methodology

What 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

• OWASP Top 10 vulnerabilities
• Authentication/authorization flaws
• Input validation and sanitization
• SQL injection and XSS risks
• Cryptography and data protection

Code Quality

• Design patterns and architecture
• Code complexity and maintainability
• Error handling
• Test coverage
• Documentation quality

Performance

• Scalability issues
• Inefficient algorithms
• Resource usage
• Caching opportunities
• Database query optimization

Edge Cases

• Boundary conditions
• Error scenarios
• Race conditions
• Concurrency issues
• Input validation gaps

Examples

Security Review

/octo:deliver "review authentication for security vulnerabilities"
# Comprehensive security audit with OWASP compliance

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”

Don’t use for:

• 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 feature

System Commands

Configure your environment and providers