Double Diamond methodology

What is Double Diamond?

The Double Diamond is a structured methodology for moving from problem to solution through four distinct phases. Claude Octopus adapts this framework from the UK Design Council to software development, adding quality gates and multi-AI orchestration.

Other multi-AI tools give you infrastructure to build workflows on. Claude Octopus gives you the workflows.

The four phases

Discover
Define
Develop
Deliver

🔍 Discover - Divergent exploration

Goal: Research broadly and gather diverse perspectivesCommand: /octo:discover or octo research XWhat happens:

Codex and Gemini run parallel research queries
Each provider brings unique perspective:
- Codex: Technical implementation details
- Gemini: Ecosystem research and alternatives
Claude synthesizes findings into unified report

Example:

/octo:discover OAuth 2.0 patterns for multi-tenant SaaS

Typical output:

Multi-source research synthesis
Comparative analysis of approaches
Ecosystem best practices
Security considerations

Duration: 30-60 seconds
Cost: $0.02-0.04

🎯 Define - Convergent scoping

Goal: Converge on clear problem definition and requirementsCommand: /octo:define or octo define XWhat happens:

Codex defines core problem statement (2-3 sentences)
Gemini defines success criteria (3-5 measurable goals)
Gemini defines constraints and boundaries
Gemini synthesizes into unified requirements

Sequential execution ensures coherent problem definitionExample:

/octo:define requirements for user authentication system

Typical output:

Clear problem statement
Measurable success criteria
Known constraints
Non-goals and boundaries
Requirements document

Duration: 1-2 minutes
Cost: $0.02-0.04

🛠️ Develop - Divergent implementation

Goal: Explore multiple implementation approaches and merge best elementsCommand: /octo:develop or octo build XWhat happens:

Codex proposes implementation approach A
Gemini proposes implementation approach B
Claude merges best elements from both
Quality gate checks 75% consensus threshold
If passed: Proceed; If failed: Revise and retry

Example:

/octo:develop user authentication with JWT tokens

Quality gate criteria:

Subtask success rate ≥ 75%
Agreement score across providers
No critical conflicts

Typical output:

Implementation plan
Code structure
Architecture decisions
Test strategy

Duration: 3-7 minutes
Cost: $0.04-0.10

✅ Deliver - Convergent validation

Goal: Adversarial review and go/no-go decisionCommand: /octo:deliver or octo review XWhat happens:

Codex reviews code quality and patterns
Gemini reviews security and edge cases
Claude synthesizes validation report
Quality score determines recommendation

Example:

/octo:deliver review authentication implementation

Validation thresholds:

Score	Status	Recommendation
≥ 90%	PASSED	Ship it
75-89%	WARNING	Ship with caution
< 75%	FAILED	Do not ship

Typical output:

Code quality assessment
Security findings
Performance concerns
Go/no-go recommendation
Remediation steps

Duration: 2-5 minutes
Cost: $0.02-0.06

Quality gates

Quality gates enforce standards between phases and prevent low-quality work from advancing.

Gate mechanics

Consensus threshold

Default: 75% agreement across providers Configurable: Set CLAUDE_OCTOPUS_QUALITY_THRESHOLD environment variable

# Raise bar to 85%
export CLAUDE_OCTOPUS_QUALITY_THRESHOLD=85

# Lower to 60% for exploratory work
export CLAUDE_OCTOPUS_QUALITY_THRESHOLD=60

Lowering the quality threshold below 75% may allow more work through, but reduces confidence in consensus.

Gate failure handling

When a quality gate fails, Claude Octopus can:

Analyze failure

Identify which subtasks failed and why

Revision loop

Retry with updated approach (up to 3 attempts)

Human escalation

Present findings to user for decision

Abort

Stop workflow if unresolvable

When to use each phase

Use Discover when:

Starting a project
You need broad research before making decisions

Exploring options
You want to understand the landscape of solutions

Learning patterns
You need to understand best practices and ecosystem

Comparing approaches
You want multi-perspective analysis of alternatives

Use Define when:

Scope is unclear
You have a vague idea but need clear requirements

Requirements needed
You need structured success criteria

Planning architecture
You need to clarify boundaries and constraints

Building consensus
You need agreement on problem definition

Use Develop when:

Implementing features
You’re ready to build with clear requirements

Multiple approaches
You want to explore implementation alternatives

Complex integration
You need coordinated multi-provider implementation

Quality matters
You want quality gates during development

Use Deliver when:

Code review
You need adversarial review before shipping

Security audit
You want security-focused validation

Performance check
You need to validate performance characteristics

Ship decision
You need go/no-go recommendation

Full workflow: Embrace

Run all four phases sequentially with /octo:embrace: Example:

/octo:embrace build user authentication with OAuth 2.0

What happens:

Discover researches OAuth patterns and best practices
Define scopes requirements and success criteria
Develop implements with quality gates
Deliver validates security and performance

Duration: 5-15 minutes
Cost: $0.10-0.30

Autonomy modes

Claude Octopus supports three autonomy modes for multi-phase workflows:

Supervised
Semi-autonomous
Autonomous

Supervised mode

Behavior: Ask for approval before each phaseUse when:

Learning the workflow
High-stakes projects
Cost-conscious development

Example:

🔍 Discover complete. Results in ~/.claude-octopus/results/discover.md

Continue to Define phase? (y/n)

Semi-autonomous mode

Behavior: Continue automatically unless quality gate failsUse when:

Trusted workflow
Medium confidence
Human available for escalations

Example:

✅ Quality gate passed (82% consensus)
🛠️ Proceeding to Develop phase...

⚠️ Quality gate failed (68% consensus)
Human review needed. Continue? (y/n)

Autonomous mode

Behavior: Run all four phases without interruptionUse when:

Well-understood problem
High confidence
Dark Factory mode

Example:

/octo:factory "build a CLI that converts CSV to JSON"

# Runs all phases autonomously:
# 1. Discover patterns
# 2. Define requirements
# 3. Develop implementation
# 4. Deliver with tests
# 5. Holdout testing
# 6. Satisfaction scoring

State persistence

Double Diamond workflows persist state across sessions:

State files

.octo/
├── STATE.md            # Current phase, status, progress
├── decisions.json      # Architectural decisions
└── context/
    ├── discover.md     # Phase 1 findings
    ├── define.md       # Phase 2 requirements
    ├── develop.md      # Phase 3 implementation
    └── deliver.md      # Phase 4 validation

Phase tracking

STATE.md structure:

current_phase: 3
phase_position: "Development"
status: "in_progress"
last_updated: "2026-03-04T15:30:00Z"
quality_gates:
  discover: "passed"
  define: "passed"
  develop: "in_progress"
  deliver: "pending"

Context preservation

Each phase reads context from prior phases:

# Define phase reads Discover findings
discover_context=$(state-manager.sh get_context "discover")

# Develop phase reads Define requirements  
define_context=$(state-manager.sh get_context "define")

# Deliver phase reads full project history
all_decisions=$(state-manager.sh get_decisions "all")

State persists across context clears (Claude Code v2.1.63+ plan mode). Workflows automatically restore context from files.

Comparison with other methodologies

Methodology	Phases	Quality Gates	Multi-AI
Claude Octopus Double Diamond	4 (Discover, Define, Develop, Deliver)	Yes (75% threshold)	Yes (3 providers)
Waterfall	5-7	Minimal	No
Agile	Iterative	Story-level	No
Design Thinking	5 (Empathize, Define, Ideate, Prototype, Test)	Minimal	No

Best practices

Start with Discover

Don’t skip research phase, even if you think you know the answer. Multi-AI perspectives often reveal blind spots.

Define before Develop

Clear requirements save time and reduce rework. A good Define phase prevents scope creep during Develop.

Respect quality gates

If a quality gate fails, investigate why. Forcing work through gates undermines the methodology.

Use Deliver for all ships

Adversarial review catches issues before production. The small upfront cost prevents expensive bugs.

Next steps

Multi-AI orchestration

Learn how three providers coordinate and reach consensus

Workflows

Explore workflow patterns and composition

Get started

Install Claude Octopus and run your first workflow

Commands reference

Browse all 39 available commands

Get Started

Core Concepts

Guides

Double Diamond methodology

What is Double Diamond?

The four phases

🔍 Discover - Divergent exploration

🎯 Define - Convergent scoping

🛠️ Develop - Divergent implementation

✅ Deliver - Convergent validation

Quality gates

Gate mechanics

Consensus threshold

Gate failure handling

When to use each phase

Use Discover when:

Use Define when:

Use Develop when:

Use Deliver when:

Full workflow: Embrace

Autonomy modes

Supervised mode

Semi-autonomous mode

Autonomous mode

State persistence

State files

Phase tracking

Context preservation

Comparison with other methodologies

Best practices

Next steps

Multi-AI orchestration

Workflows

Get started

Commands reference

Build docs developers (and LLMs) love

Get Started

Core Concepts

Guides

​What is Double Diamond?

​The four phases

​🔍 Discover - Divergent exploration

​🎯 Define - Convergent scoping

​🛠️ Develop - Divergent implementation

​✅ Deliver - Convergent validation

​Quality gates

​Gate mechanics

​Consensus threshold

​Gate failure handling

​When to use each phase

​Use Discover when:

​Use Define when:

​Use Develop when:

​Use Deliver when:

​Full workflow: Embrace

​Autonomy modes

​Supervised mode

​Semi-autonomous mode

​Autonomous mode

​State persistence

​State files

​Phase tracking

​Context preservation

​Comparison with other methodologies

​Best practices

​Next steps

Multi-AI orchestration

Workflows

Get started

Commands reference

Build docs developers (and LLMs) love

What is Double Diamond?

The four phases

🔍 Discover - Divergent exploration

🎯 Define - Convergent scoping

🛠️ Develop - Divergent implementation

✅ Deliver - Convergent validation

Quality gates

Gate mechanics

Consensus threshold

Gate failure handling

When to use each phase

Use Discover when:

Use Define when:

Use Develop when:

Use Deliver when:

Full workflow: Embrace

Autonomy modes

Supervised mode

Semi-autonomous mode

Autonomous mode

State persistence

State files

Phase tracking

Context preservation

Comparison with other methodologies

Best practices

Next steps