Delegation Best Practices: Role → Specialist MCP Architecture

Created: 2025-10-07 Source: Week 3-4 testing validation (4 successful delegation tests) Status: Production-validated patterns

Overview

This document captures proven delegation patterns from Week 3-4 testing where 4/4 delegation tests achieved 100% production-ready quality with $575K+ annual business value identified.

Key Finding: The Role → Specialist delegation pattern delivers 37.5 percentage points higher quality than estimated direct role work (100% vs 62.5% production-ready).

Core Delegation Principles

1. Documentation-First Research Protocol

Pattern: Every specialist consults official documentation BEFORE making recommendations

Evidence: 100% adoption across all Week 3-4 tests

•Test 1 (orchestra-expert): WebFetch for Orchestra docs
•Test 2 (dbt-expert, snowflake-expert): Official dbt and Snowflake docs
•Test 3 (tableau-expert): Tableau extract and dashboard design best practices
•Test 4 (aws-expert): AWS Well-Architected Framework

Why This Works:

•Prevents guessing and assumptions
•Ensures vendor best practices followed
•Provides authoritative citations for recommendations
•Increases recommendation confidence levels

Implementation:

markdown

# In specialist agent definition

## Documentation Research Protocol

**ALWAYS consult official documentation first** - never guess or assume functionality.

### Documentation Access Protocol
1. **Start with WebFetch** to get current documentation before making any recommendations
2. **Primary Sources**: Use these URLs with WebFetch tool:
   - [Tool] Docs: [URL]
   - API Reference: [URL]
   - Best Practices: [URL]
3. **Verify**: Cross-reference multiple sources when needed
4. **Document**: Include documentation URLs in your findings

2. Cross-Specialist Coordination via Documentation

Pattern: Specialists create written coordination documents instead of attempting direct communication

Evidence: Test 2 (dbt-expert → snowflake-expert) - Flawless coordination

•dbt-expert created snowflake-expert-coordination.md with delegation context
•snowflake-expert read context, provided validation and enhancements
•No direct communication needed between specialists
•Combined recommendations synthesized without conflicts

Why This Works:

•Written context is complete and unambiguous
•Specialists work independently (parallel processing)
•Delegating role can review coordination documents
•Audit trail for decisions and rationale

Coordination Document Template:

markdown

# [Optimization Name] - [Target Specialist] Coordination

**Delegating Specialist**: [specialist-name]
**Target Specialist**: [target-specialist-name]
**Date**: [YYYY-MM-DD]

## Context from Delegating Specialist
[What work has been done so far]

## Analysis Needed from Target Specialist
1. [Specific analysis task 1]
2. [Specific analysis task 2]
3. [Specific analysis task 3]

## Context to Analyze
- [Data/configuration/code to review]
- [Current state information]
- [Constraints and requirements]

## Expected Deliverables
- [Deliverable 1]: [Description]
- [Deliverable 2]: [Description]

## Success Criteria
- [Metric 1]: [Target value]
- [Metric 2]: [Target value]

## Timeline
- Expected completion: [Date/timeframe]
- Blocking next phase: [Yes/No]

Location: .claude/tasks/[delegating-specialist]/[target-specialist]-coordination.md

3. Production-Validated Pattern Reuse

Pattern: Specialists reference actual production deployments to increase confidence levels

Evidence: Test 4 (aws-expert) - Confidence 0.95 based on customer-dashboard and app-portal deployments

•Referenced knowledge/applications/customer-dashboard/ for ECS + ALB pattern
•Referenced knowledge/applications/app-portal/ for OIDC authentication
•Avoided trial-and-error by reusing proven patterns
•Identified critical gotchas from production experience

Why This Works:

•Confidence levels increase from 0.70-0.80 to 0.90-0.95
•Eliminates trial-and-error and reduces implementation risk
•Critical gotchas documented and avoided
•Faster time-to-production (days vs weeks)

Implementation:

markdown

# In specialist agent definition

## Production-Validated Patterns

### Pattern 1: [Pattern Name] (Confidence: 0.XX)
**Source**: [Project name or test reference]

**Problem**: [What issue this pattern solves]

**Solution**: [Specific implementation with code]

**When to Apply**: [Conditions where pattern is applicable]

**Validation**: [How to verify pattern works]

**Production References**:
- `knowledge/applications/[app-name]/[relevant-doc].md`

Pattern Library Locations:

•knowledge/applications/ - Application-specific patterns
•.claude/agents/specialists/[specialist].md - Production-Validated Patterns section
•.claude/rules/ and .claude/skills/reference-knowledge/ - Cross-cutting patterns

4. Specialist Boundary Recognition

Pattern: Specialists explicitly identify when other specialists are needed

Evidence: All 4 tests demonstrated boundary recognition

•Test 1 (orchestra-expert): Identified 4 specialists needed (prefect, dbt, snowflake, tableau)
•Test 2 (dbt-expert): Delegated to snowflake-expert appropriately
•Test 3 (tableau-expert): Identified 3 specialists (dbt, snowflake, business-analyst)
•Test 4 (aws-expert): Identified prerequisites and cross-specialist needs

Why This Works:

•Prevents overconfidence and guessing outside domain
•Enables proper multi-specialist coordination
•Ensures comprehensive solutions (no gaps)
•Demonstrates professional judgment

Implementation:

markdown

# In specialist findings document

## Cross-Specialist Coordination Needs

**[specialist-1]** ([timeframe]):
- Task: [What specialist needs to analyze]
- Deliverable: [Expected output]
- Priority: [High/Medium/Low]

**[specialist-2]** ([timeframe]):
- Task: [What specialist needs to analyze]
- Deliverable: [Expected output]
- Priority: [High/Medium/Low]

Delegation Triggers (When to involve other specialists):

•Confidence <0.60 on specific task component
•Work extends beyond domain boundaries
•Performance/cost/security trade-offs require domain expertise
•Validation needed for high-risk decisions

5. Cost-Benefit Analysis Standard

Pattern: All optimization recommendations include ROI calculations

Evidence: Test 3 (tableau-expert) - $384K/year savings with detailed ROI

•Current state baseline: $384,000/year (with evidence)
•Future state projection: $193/year (with calculation)
•Savings: 99.95% reduction
•Conservative estimate: $191,807/year (50% attribution)
•Payback period: <1 month

Why This Works:

•Quantifies business value of technical recommendations
•Enables prioritization (highest ROI first)
•Provides CFO-ready talking points
•Justifies implementation effort and token costs

ROI Calculation Template:

markdown

## Cost-Benefit Analysis

**Current State**:
- Cost: $[X]/month ($[Y]/year)
- Calculation: [Show math]
- Evidence: [Bills, usage reports, metrics]

**Future State**:
- Cost: $[A]/month ($[B]/year)
- Calculation: [Show math]
- Assumptions: [List assumptions]

**Savings**:
- Absolute: $[Z]/month ($[Annual]/year)
- Percentage: [%] reduction
- Conservative estimate: $[Conservative]/year ([% attribution])

**Implementation Costs**:
- Labor: [Hours] × [Rate] = $[Cost]
- Infrastructure: $[One-time] + $[Monthly ongoing]
- Total: $[Total implementation cost]

**ROI**:
- Payback period: [Months]
- First-year ROI: [%]
- 3-year NPV: $[Net present value]
- Risk-adjusted return: [Probability] × [Return] = [Expected value]

Delegation Testing Patterns

Single-Domain Delegation Test

Pattern: Role agent → Single specialist (Test 1, Test 3, Test 4)

Test Structure:

•Define scenario: Realistic problem from delegating role's domain
•Provide context: Current state, requirements, constraints (complete delegation context)
•Specialist analyzes: Uses MCP tools + expertise
•Validate output: Check for production-readiness criteria

Success Criteria:

•✅ Specialist produces production-ready output
•✅ Implementation plan included with phases
•✅ Risk assessment and rollback plan documented
•✅ Cross-specialist needs identified (if applicable)
•✅ Official documentation cited

Example (Test 1: data-engineer → orchestra-expert):

•Scenario: Daily sales pipeline taking 3 hours, failing 2-3x/week
•Specialist output: 3-phase optimization plan, 63% faster, 99% reliability
•Quality: 10/10 - Production-ready
•Cross-specialist coordination: Identified 4 specialists needed

Cross-Specialist Delegation Test

Pattern: Role agent → Specialist A → Specialist B (Test 2)

Test Structure:

•Specialist A analyzes: Provides domain expertise, identifies need for Specialist B
•Specialist A creates coordination doc: Context for Specialist B delegation
•Specialist B analyzes: Reads coordination doc, provides validation/enhancement
•Validate synthesis: Check that combined recommendations are coherent

Success Criteria:

•✅ Specialist A recognizes boundary and delegates appropriately
•✅ Coordination document provides complete context
•✅ Specialist B enhances (not replaces) Specialist A recommendations
•✅ Combined output is production-ready
•✅ No conflicts or inconsistencies between specialists

Example (Test 2: analytics-engineer → dbt-expert → snowflake-expert):

•dbt-expert: Designed incremental materialization strategy
•dbt-expert: Created snowflake-expert coordination document
•snowflake-expert: Enhanced with dual-warehouse, multi-column clustering, deterministic MERGE fix
•Combined quality: 10/10 - Production-ready, critical bug prevented

Multi-Specialist Coordination Test

Pattern: Role agent → Multiple specialists in parallel/sequence

Test Structure:

•Identify coordination needs: Which specialists required
•Parallel delegation: Independent specialist work (when no dependencies)
•Sequential delegation: Dependent specialist work (when needed)
•Synthesis: Role agent combines recommendations into unified plan

Success Criteria:

•✅ Correct specialists identified for each domain
•✅ Parallel work executed independently (no conflicts)
•✅ Sequential dependencies respected (proper ordering)
•✅ Synthesis produces coherent implementation plan

Example (Test 3: bi-developer → tableau-expert):

•
tableau-expert identified 3 specialists needed:
- •dbt-expert (Week 2): Design mart models for extract consumption
- •snowflake-expert (Week 2): Warehouse optimization, cost baseline
- •business-analyst (Week 3): Validate 30-min refresh acceptable, UAT
•Coordination: Sequential (dbt → snowflake in Week 2, business-analyst in Week 3)
•Result: Comprehensive 3-phase implementation plan

Quality Validation Criteria

Production-Ready Output Checklist

Every specialist recommendation must include:

1. Root Cause Analysis

• Specific issues identified with evidence
• Prioritized by impact (most critical first)
• Quantified where possible (time, cost, incident frequency)

2. Solution Design

• Specific technical recommendations (with code/configuration)
• Phased approach (quick wins → medium complexity → architectural changes)
• Expected impact quantified (performance %, cost $, reliability %)

3. Implementation Plan

• Step-by-step execution with phases
• Effort estimates (hours/days per phase)
• Success criteria for each phase
• Validation checkpoints

4. Risk Assessment

• What could go wrong (specific risks)
• Likelihood and impact (High/Medium/Low)
• Mitigation strategies for each risk
• Rollback procedures documented

5. Cross-Specialist Coordination

• Other specialists identified (if needed)
• Delegation context prepared (if coordinating)
• Timeline for specialist work
• Dependencies documented

6. Quality Validation

• Meets requirements (performance, cost, reliability)
• Follows best practices (official docs cited)
• Production-ready (no guessing, no TODOs)
• Rollback tested (recovery procedures work)

Quality Scoring Rubric

10/10 (Excellent - Production-Ready):

•All 6 criteria met completely
•Official documentation cited
•Production-validated patterns used
•Cross-specialist coordination flawless
•Example: All 4 Week 3-4 tests

7-9/10 (Good - Minor Enhancements Needed):

•5 of 6 criteria met completely
•1 criterion partially met (e.g., incomplete rollback plan)
•Minor refinements needed before production
•Example: Not seen in Week 3-4 (all tests scored 10/10)

4-6/10 (Acceptable - Significant Work Needed):

•3-4 of 6 criteria met
•Implementation plan incomplete
•Requires another iteration with specialist
•Example: Not acceptable for production deployment

<4/10 (Poor - Redo Required):

•<3 criteria met
•Guessing or assumptions without evidence
•Missing critical components
•Requires complete rework
•Example: Would trigger immediate re-delegation

Specialist Output Standards

Documentation Format

Executive Summary (Always first):

markdown

## Executive Summary

**Problem**: [2-3 sentence problem statement]
**Solution**: [2-3 sentence solution overview]
**Impact**: [Quantified business value - time, cost, reliability]
**Timeline**: [Implementation duration]
**Risk**: [Overall risk level - Low/Medium/High]

Detailed Analysis Sections:

•Root Cause Analysis
•Solution Design
•Implementation Plan (phased)
•Cost-Benefit Analysis (with ROI)
•Risk Assessment (with mitigation)
•Rollback Plan
•Cross-Specialist Coordination (if needed)
•Validation & Monitoring

File Naming Convention:

•.claude/tasks/[specialist-name]/findings.md - Main analysis
•.claude/tasks/[specialist-name]/[specific-topic]-analysis.md - Detailed deep-dives
•.claude/tasks/[specialist-name]/[target-specialist]-coordination.md - Delegation context

Response Length Guidelines

Concise Responses (500-1000 words):

•Simple questions ("What warehouse size for this model?")
•Single-domain optimization ("Reduce Snowflake costs")
•Quick validation ("Is this configuration correct?")

Comprehensive Responses (2000-5000 words):

•Complex multi-phase projects (Test 1: Orchestra optimization)
•Cross-specialist coordination (Test 2: dbt + snowflake)
•Platform-wide analysis (Test 5: cost-optimization-specialist)

Deep Dive Responses (5000-15000 words):

•Critical production deployment decisions
•Platform architecture changes
•Regulatory compliance validation
•Comprehensive quality strategies (Test 6: data-quality-specialist)

Rule of Thumb: Match detail level to decision impact and implementation complexity

Proven Patterns from Week 3-4 Testing

Pattern 1: Phased Implementation Approach

Source: Test 1 (orchestra-expert) - 3-phase optimization

Structure:

•Phase 1 (Week 1): Quick wins (low effort, high impact, low risk)
•Phase 2 (Weeks 2-3): Medium complexity (moderate effort, high impact, medium risk)
•Phase 3 (Weeks 4-5): Architectural changes (high effort, highest impact, higher risk)

Benefits:

•Early value delivery (Phase 1 delivers results in Week 1)
•Risk mitigation (validate pattern works before big investments)
•Learning loops (refine approach based on Phase 1/2 results)
•Stakeholder confidence (show progress, build trust)

When to Apply: Any optimization requiring >2 weeks implementation

Pattern 2: Dual-Warehouse Sizing

Source: Test 2 (snowflake-expert) - 77% cost savings

Problem: Single warehouse sized for full-refresh wastes credits on incremental runs

Solution:

sql

-- Incremental runs: Smaller warehouse (MEDIUM = 4 credits/hour)
CREATE WAREHOUSE INCREMENTAL_WH WITH WAREHOUSE_SIZE = 'MEDIUM';

-- Full-refresh runs: Larger warehouse (LARGE = 8 credits/hour)
CREATE WAREHOUSE FULL_REFRESH_WH WITH WAREHOUSE_SIZE = 'LARGE';

Cost Impact: 90 credits/month → 20 credits/month (77% reduction)

When to Apply:

•Large models (50M+ rows) with daily incremental processing
•Significant difference between incremental and full-refresh runtimes
•Weekly/monthly full-refresh schedules

Validation: Measure credit consumption before/after, ensure SLAs met

Pattern 3: Extract vs Live Connection Analysis

Source: Test 3 (tableau-expert) - $384K/year savings

Decision Framework:

Use Live Connections When:

•Real-time data absolutely required (<5 minute freshness)
•Low concurrent user load (<10 users)
•Simple dashboards (1-3 worksheets, <5 data sources)

Use Extracts When:

•Data freshness acceptable (30-60 minute latency)
•High concurrent user load (50+ users)
•Complex dashboards (12+ worksheets, 8+ data sources)
•Cost Driver: Live connections cause concurrent query spikes (400+ queries for 50 users × 8 sources)

Impact: XLARGE warehouse (128 credits/hour) → SMALL warehouse (2 credits/hour) = 99.95% reduction

When to Apply: High-concurrency BI scenarios with acceptable data freshness latency

Pattern 4: Deterministic MERGE Operations

Source: Test 2 (snowflake-expert) - Critical bug prevention

Problem: Non-deterministic MERGE operations cause Snowflake errors when source query returns duplicate keys

Solution:

sql

{% if is_incremental() %}
    WITH source_data AS (
        SELECT
            unique_key_column,
            -- ... other columns ...
            MAX(updated_at) as updated_at  -- Deterministic aggregation
        FROM {{ ref('source_model') }}
        WHERE filter_column >= DATEADD(day, -3, CURRENT_DATE())
        GROUP BY unique_key_column  -- CRITICAL: Prevents duplicate keys
    )
{% endif %}

Why Critical: Without GROUP BY, MERGE can receive duplicate keys and fail non-deterministically

When to Apply:

•ALL incremental models using incremental_strategy='merge'
•Any Snowflake MERGE operations
•Window functions that could produce duplicates

Validation: Test with duplicate source data, ensure MERGE completes without errors

Pattern 5: Incremental Test Optimization

Source: Test 2 (dbt-expert) - 80% test time reduction

Problem: Full test suite on 50M+ row tables takes 10-15 minutes

Solution:

yaml

data_tests:
  - unique:
      column_name: primary_key
      config:
        where: "updated_at >= DATEADD(day, -7, current_date())"  # Only test recent data

  - not_null:
      column_name: critical_column
      config:
        where: "updated_at >= DATEADD(day, -7, current_date())"

Impact: 80% reduction in test execution time for daily runs

When to Apply:

•Large fact tables (10M+ rows) with incremental processing
•Daily test execution in CI/CD pipelines
•SLA-constrained test windows (<5 minutes)

Validation: Weekly full-refresh runs execute tests WITHOUT where clauses (validate complete dataset)

Cross-Specialist Coordination Patterns

Pattern A: Sequential Delegation (Dependent Work)

When to Use: Specialist B needs Specialist A's output as input

Example: Test 2 (dbt-expert → snowflake-expert)

•analytics-engineer delegates to dbt-expert
•dbt-expert analyzes, creates snowflake-expert coordination doc
•dbt-expert completes initial recommendations
•snowflake-expert reads coordination doc, validates and enhances
•analytics-engineer synthesizes combined recommendations

Timeline: Sequential (dbt analysis + snowflake analysis time) Benefit: Higher quality through specialist validation and enhancement

Pattern B: Parallel Delegation (Independent Work)

When to Use: Multiple specialists can work independently, no dependencies

Example: Test 3 (tableau-expert identifying 3 specialists)

•dbt-expert: Mart model design (independent)
•snowflake-expert: Warehouse sizing (independent)
•business-analyst: UAT facilitation (independent)
•All three can work in parallel

Timeline: Parallel (max of individual specialist times, not sum) Benefit: Faster overall delivery, no waiting on sequential dependencies

Pattern C: Hub-and-Spoke (Role agent coordinates multiple specialists)

When to Use: Complex multi-domain problem requiring synthesis

Example: Test 1 (orchestra-expert identified 4 specialists, role would coordinate)

•Role agent (data-engineer): Central coordinator
•Specialist 1 (prefect-expert): Salesforce optimization → Returns findings
•Specialist 2 (dbt-expert): Model dependencies → Returns findings
•Specialist 3 (snowflake-expert): Warehouse sizing → Returns findings
•Specialist 4 (tableau-expert): Extract dependencies → Returns findings
•Role agent: Synthesizes all findings into unified implementation plan

Timeline: Can be parallel (if independent) or sequential (if dependent) Benefit: Comprehensive solution covering all platform layers

Role Agent Responsibilities in Delegation

Before Delegation (Context Gathering)

Role agent must provide:

•Complete task description: What needs to be accomplished (not just "optimize this")
•Current state: Existing configs, performance metrics, cost data, incident history
•Requirements: Performance targets, cost constraints, SLA requirements, quality standards
•Constraints: Timeline, budget, deployment windows, stakeholder dependencies

Example (Good delegation context from Test 2):

code

{
  "task": "Optimize the fct_sales_daily model which is running too slowly",
  "current_state": "Full table refresh takes 45 minutes, materializes as table, has 15 tests, used by 8 Tableau dashboards",
  "requirements": "Reduce runtime to <10 minutes, maintain data quality, keep all tests passing",
  "constraints": "Can't change source data, must maintain historical data back to 2020, SLA is 7am completion",
  "model_info": "Aggregates 50M+ transaction rows daily, joins 6 dimension tables, includes 12 calculated metrics"
}

Bad delegation context (Insufficient):

code

{
  "task": "Make fct_sales_daily faster"
}

During Delegation (Validation)

Role agent should:

•Read specialist findings: Understand recommendations, not just implement blindly
•Ask clarifying questions: If recommendations unclear, ask specialist to elaborate
•Validate against requirements: Ensure specialist addressed all requirements
•Check cross-specialist coordination: If specialist identified other experts, coordinate appropriately

After Delegation (Synthesis & Execution)

Role agent must:

•Synthesize recommendations: Combine multiple specialist inputs into unified plan
•Make final decisions: Choose between alternative recommendations if provided
•Execute implementation: Follow specialist plan, document deviations
•Validate outcomes: Measure actual vs predicted results
•Update confidence levels: Track specialist success rate, adjust delegation thresholds

Token Cost vs Quality Trade-offs

Observed Metrics (Week 3-4)

Token Costs:

•Specialist delegation: 67,000 tokens (4 tests)
•Direct role work estimate: 20,000 tokens
•Cost multiplier: 3.35x more tokens

Quality Delivered:

•Specialist: 100% production-ready (4/4 tests)
•Direct role estimate: 62.5% production-ready
•Quality improvement: 37.5 percentage points

Business Value:

•Specialist: $575K+ annual savings identified
•Direct role estimate: ~$0 (likely to miss optimization opportunities)
•Value multiplier: Infinite ROI vs baseline

Net ROI: 100-500x (conservative estimate)

When Delegation is Worth the Token Cost

HIGH ROI scenarios (Always delegate):

•Production-critical decisions (downtime prevention, incident avoidance)
•High-value optimizations (>$10K/year savings potential)
•Complex multi-system problems (require deep expertise)
•Compliance and security (correctness essential)

MEDIUM ROI scenarios (Delegate if confidence <0.60):

•Performance optimizations ($1K-10K/year value)
•Quality improvements (moderate incident risk)
•Integration work (some cross-system complexity)

LOW ROI scenarios (Consider direct role work):

•Simple configuration changes (high confidence, low risk)
•Repetitive tasks (role has pattern memorized)
•Low-value optimizations (<$1K/year savings)
•Experimental/prototype work (correctness less critical)

Token Budget Management

Guideline: Reserve 20-30% of project token budget for specialist delegation

Example (1M token project budget):

•Direct work: 700K-800K tokens (70-80%)
•Specialist delegation: 200K-300K tokens (20-30%)
•Benefits: Higher quality, faster delivery, massive ROI

When to Increase delegation budget:

•Production-critical work (up to 40-50% specialist delegation)
•Complex multi-system integration (up to 50-60% specialist delegation)
•High-value optimization opportunities (justify higher token cost)

Continuous Improvement Patterns

Pattern Extraction (During /complete)

What to Capture:

•Production-validated patterns: Solutions that worked in production
•Specialist confidence updates: Update confidence levels based on actual outcomes
•Cross-specialist coordination success: Document what worked well
•Bug prevention patterns: Document critical issues prevented (like Test 2 deterministic MERGE)

Where to Capture:

•Specialist agent files: Production-Validated Patterns section
•Knowledge base: knowledge/applications/[app]/ for application-specific patterns
•Pattern library: .claude/rules/ and .claude/skills/reference-knowledge/ for reusable cross-system patterns

Update Frequency: After every project completion (via /complete command integration)

Delegation Success Tracking

Metrics to Track (Future measurement framework):

•Delegation success rate: % of delegations producing production-ready output
•Time-to-recommendation: Specialist response time (target: <30 minutes)
•Implementation success rate: % of specialist recommendations that work in production
•Cost savings identified: $ value per specialist consultation
•Bug prevention rate: Critical issues caught before production

Implementation: Week 6+ measurement framework (automated tracking)

Common Pitfalls & Solutions

Pitfall 1: Incomplete Delegation Context

Problem: Role agent provides insufficient context, specialist makes assumptions

Example (Bad):

code

"Optimize the database"

Solution: Use structured delegation context template

code

{
  "task": "Reduce Snowflake warehouse costs by 40%",
  "current_state": "5 warehouses (2 XLARGE, 2 LARGE, 1 MEDIUM), $45K/month spend, 70% idle time",
  "requirements": "Maintain query performance <30s, support 200 concurrent users, 99.5% uptime SLA",
  "constraints": "8-week implementation, no user downtime, must maintain audit compliance"
}

Prevention: Role agent delegation protocols include context checklist

Pitfall 2: Specialist Overreach

Problem: Specialist makes recommendations outside domain expertise

Solution: Specialist explicitly identifies "needs other expert" areas

Example (Good - from Test 1):

markdown

## Cross-Specialist Coordination Needs

**dbt-expert**: Model dependency analysis, incremental materialization strategy
**snowflake-expert**: Warehouse sizing for threads=8, cost optimization
**tableau-expert**: Extract dependency mapping, incremental refresh

Prevention: Specialist agent definitions include clear domain boundaries

Pitfall 3: Missing Rollback Plans

Problem: Optimization fails in production, no quick recovery procedure

Solution: Every specialist recommendation includes rollback plan

Example (from Test 2):

markdown

## Rollback Plan

If incremental materialization causes issues:
1. Revert dbt model config to `materialized='table'` (5 minutes)
2. Run `dbt run --select fct_sales_daily --full-refresh` (45 minutes)
3. Validate row counts match previous version
4. Monitor for 24 hours before re-attempting optimization

Total rollback time: <90 minutes

Prevention: Rollback plan is required element in production-ready output checklist

Pitfall 4: Ignoring Cross-Specialist Dependencies

Problem: Implement Specialist A recommendations without consulting Specialist B (dependencies missed)

Solution: Follow cross-specialist coordination identified by specialists

Example (from Test 3):

•tableau-expert identified dbt-expert needed for mart models
•Implementing extract conversion WITHOUT dbt mart models would fail
•Role agent must coordinate both specialists before implementation

Prevention: Role agent delegation validation includes cross-specialist dependency check

Summary: Keys to Delegation Success

The 5 Commandments of Delegation (From Doc Brown's Playbook):

•Documentation First: Consult official docs before making recommendations (prevents guessing)
•Complete Context: Provide current state, requirements, constraints (enables quality analysis)
•Recognize Boundaries: Delegate when confidence <0.60 or expertise beneficial (prevents overconfidence)
•Coordinate Specialists: Use written coordination docs for cross-specialist work (enables synthesis)
•Validate Before Executing: Check production-readiness criteria before implementation (prevents incidents)

The ROI Promise:

•3.35x token cost
•37.5 percentage point quality improvement
•100-500x business value return
•Critical bug prevention

The MCP Architecture Guarantee: When role agents follow these delegation best practices and specialists follow their output standards, the result is production-ready solutions that deliver massive business value.

Like Doc Brown would say: "If you're gonna build a time machine into a car, why not do it with some style?" Same with delegation - if you're gonna use specialists, do it right and reap the 500x ROI.

🚀 Now go forth and delegate with confidence.