delegation-best-practices

name	delegation-best-practices
description	Reference for Role to Specialist delegation patterns with MCP architecture, including quality validation, coordination protocols, and proven patterns
user-invocable	false

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:

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

# [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:

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

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

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

1. Define scenario: Realistic problem from delegating role's domain
2. Provide context: Current state, requirements, constraints (complete delegation context)
3. Specialist analyzes: Uses MCP tools + expertise
4. 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:

1. Specialist A analyzes: Provides domain expertise, identifies need for Specialist B
2. Specialist A creates coordination doc: Context for Specialist B delegation
3. Specialist B analyzes: Reads coordination doc, provides validation/enhancement
4. 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:

1. Identify coordination needs: Which specialists required
2. Parallel delegation: Independent specialist work (when no dependencies)
3. Sequential delegation: Dependent specialist work (when needed)
4. 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):

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

1. Root Cause Analysis
2. Solution Design
3. Implementation Plan (phased)
4. Cost-Benefit Analysis (with ROI)
5. Risk Assessment (with mitigation)
6. Rollback Plan
7. Cross-Specialist Coordination (if needed)
8. 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:

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

{% 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:

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)

1. analytics-engineer delegates to dbt-expert
2. dbt-expert analyzes, creates snowflake-expert coordination doc
3. dbt-expert completes initial recommendations
4. snowflake-expert reads coordination doc, validates and enhances
5. 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:

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

Example (Good delegation context from Test 2):

{
  "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):

{
  "task": "Make fct_sales_daily faster"
}

During Delegation (Validation)

Role agent should:

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

After Delegation (Synthesis & Execution)

Role agent must:

1. Synthesize recommendations: Combine multiple specialist inputs into unified plan
2. Make final decisions: Choose between alternative recommendations if provided
3. Execute implementation: Follow specialist plan, document deviations
4. Validate outcomes: Measure actual vs predicted results
5. 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:

1. Production-validated patterns: Solutions that worked in production
2. Specialist confidence updates: Update confidence levels based on actual outcomes
3. Cross-specialist coordination success: Document what worked well
4. 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):

1. Delegation success rate: % of delegations producing production-ready output
2. Time-to-recommendation: Specialist response time (target: <30 minutes)
3. Implementation success rate: % of specialist recommendations that work in production
4. Cost savings identified: $ value per specialist consultation
5. 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):

"Optimize the database"

Solution: Use structured delegation context template

{
  "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):

## 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):

## 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):

1. Documentation First: Consult official docs before making recommendations (prevents guessing)
2. Complete Context: Provide current state, requirements, constraints (enables quality analysis)
3. Recognize Boundaries: Delegate when confidence <0.60 or expertise beneficial (prevents overconfidence)
4. Coordinate Specialists: Use written coordination docs for cross-specialist work (enables synthesis)
5. 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.