Effective Delegation Patterns

Overview

Master the art of delegation to specialized agents. Know what to delegate, how to structure tasks for agent success, and when to do work yourself for better outcomes.

Core principle: Effective delegation is about setting agents up for success through clear objectives, proper context, and appropriate scope.

When to Use

Use this skill when:

• Deciding whether to delegate a task or do it yourself
• Breaking down complex work into agent-friendly tasks
• Agent outputs are consistently missing the mark
• Unclear how much detail to provide
• Uncertain about appropriate scope for delegation
• Need to improve agent output quality

Symptoms of poor delegation:

• Agents frequently misunderstand requirements
• Multiple revision cycles for simple tasks
• Feeling like "it's faster to do it myself"
• Agent outputs don't integrate well
• Constant back-and-forth clarifications

The Delegation Decision Framework

When to Delegate

Delegate to agents when:

• Task is well-defined and specific
• Clear success criteria exist
• Agent has specialized knowledge you lack
• Task is time-consuming but straightforward
• Multiple similar tasks need doing
• You want to explore multiple approaches

Examples:

• ✅ "Write comprehensive tests for the auth module"
• ✅ "Research TikTok trends for fitness apps"
• ✅ "Optimize these database queries for performance"
• ✅ "Create 10 hero section variations using shadcnblocks"
• ✅ "Analyze user feedback from last month's release"

When to Do It Yourself

Keep for yourself when:

• Requires nuanced judgment calls
• High-level strategic decisions
• Deep context from previous conversations
• Exploratory work without clear end state
• Highly creative/subjective tasks
• Quick fixes (< 5 minutes)

Examples:

• ❌ Don't delegate: "Decide our product strategy"
• ❌ Don't delegate: "Make the design feel more premium" (too subjective)
• ❌ Don't delegate: "Fix this typo" (faster to do it)
• ❌ Don't delegate: "Explore what our competitors are doing" (too open-ended)

Task Breakdown Patterns

The SMART Delegation Pattern

Make tasks Specific, Measurable, Achievable, Relevant, Time-bound:

Bad delegation:

@frontend-developer make the app better

SMART delegation:

@frontend-developer improve dashboard load time from 3s to <1s by:
1. Implementing virtualization for the 1000-row table
2. Lazy loading the charts
3. Using React.memo for expensive components

Files: src/components/Dashboard.tsx, src/hooks/useAnalytics.ts
Success: Dashboard renders in <1s, all features still work

Breaking Down Complex Tasks

Original task: "Build a user authentication system"

Broken down for agents:

1. @backend-architect design auth API endpoints
   - POST /api/auth/signup
   - POST /api/auth/login
   - POST /api/auth/logout
   - GET /api/auth/me
   Success: API spec document with schemas

2. @ui-designer create auth UI designs
   - Login form
   - Signup form
   - Password reset flow
   Success: Figma designs or component specs

3. @frontend-developer implement auth UI
   Input: [designs from step 2]
   Use: shadcn/ui Form components
   Success: Working UI connected to API

4. @test-writer-fixer add auth test coverage
   Input: [implementation from step 3]
   Coverage: All auth flows, edge cases, errors
   Success: 90%+ coverage, all tests pass

Scope Boundaries

Define clear boundaries:

✅ Good scope:
"@frontend-developer create the UserProfile component
- Props: user object with {name, email, avatar, bio}
- Display avatar (circular, 64px)
- Show name (h2), email (muted text), bio (paragraph)
- Use shadcn/ui Card component
- Make responsive (stack on mobile)
File: Create new file at src/components/UserProfile.tsx"

❌ Bad scope:
"@frontend-developer work on user profiles"
(Too vague - what exactly?)

❌ Bad scope:
"@frontend-developer build the entire user system including profiles, settings, preferences, notifications, and privacy controls"
(Too broad - break into multiple tasks)

Context Preparation Levels

Level 1: Minimal Context (Quick Tasks)

Use for: Well-defined, isolated tasks

@test-writer-fixer add tests for src/utils/formatDate.ts

Expected: Full test coverage including edge cases

When it works:

• Pure functions
• No dependencies on other code
• Standard patterns
• Agent can read the file and understand

Level 2: Standard Context (Most Tasks)

Use for: Typical development tasks

@frontend-developer add dark mode toggle to Settings page

Context:
- File: src/app/settings/page.tsx
- Use our theme system (already set up with CSS variables)
- Toggle component from shadcn/ui
- Store preference in localStorage as 'theme'
- Apply theme by adding/removing 'dark' class on <html>

Success: Toggle works, theme persists across sessions

When it works:

• Standard features
• Existing patterns to follow
• Clear requirements
• Agent needs some guidance

Level 3: Rich Context (Complex Tasks)

Use for: Complex, high-stakes, or novel tasks

@backend-architect optimize our real-time chat system

Background:
Currently using webhook polling every 2 seconds. Users experience lag and server costs are high ($500/mo). Need sub-second updates for 10k concurrent users.

Current implementation:
- Files: src/api/chat/route.ts, src/hooks/useChat.ts
- Database: Postgres on Supabase
- Currently: REST API with polling

Constraints:
- Must work with existing Postgres DB
- Budget: <$200/mo for real-time infrastructure
- Compatibility: Web + mobile web (React)

Requirements:
1. Sub-second message delivery
2. Typing indicators
3. Read receipts
4. Works with 10k concurrent users

Research these options and recommend:
- WebSockets vs Server-Sent Events vs Supabase Realtime
- Implementation plan
- Cost estimate
- Migration strategy from current polling

Success: Detailed recommendation with pros/cons and implementation plan

When it works:

• Novel problems
• Multiple valid approaches
• High complexity
• Significant decisions involved

Output Quality Verification

The 3-Question Review

After every agent output, ask:

1. Does it solve the right problem?

• Addresses the core objective?
• Requirements met?
• Nothing important missing?

2. Is the quality acceptable?

• Technically correct?
• Best practices followed?
• Maintainable code/design?
• Performance acceptable?

3. Does it integrate well?

• Fits with existing patterns?
• Compatible with our stack?
• Documented appropriately?

When to Accept vs Request Revisions

Accept when:

• Core requirements met
• Quality is "good enough" for current stage
• Alternative approach but still valid
• Minor style differences acceptable

Request revision when:

• Core requirement missed
• Technical correctness issues
• Security vulnerabilities
• Performance below acceptable
• Doesn't follow project patterns

Accept with notes:

• Works but could be better
• Tech debt for later cleanup
• Document the limitation
• Plan future improvement

Revision Request Pattern

Effective revision requests:

✅ Good:
"@frontend-developer this is close but needs these changes:

1. Use shadcn/ui Select instead of custom dropdown (consistency)
2. Add error state handling for failed API calls
3. Mobile view breaks at 768px - stack elements vertically

Keep: The layout structure and color scheme are perfect"

❌ Bad:
"Not quite right, please redo"
(No specific guidance)

❌ Bad:
"Change everything to use a completely different approach"
(Should have specified upfront)

Delegation Anti-Patterns

Anti-Pattern	Why It Fails	Better Approach
The Vague Brief	"Make it better"	Specific metrics and changes
The Everything Dump	"Build the entire app"	Break into specific components
The Assumption	Assume agent knows context	Provide relevant background
The Perfectionist	Micro-manage every detail	Trust specialist expertise
The Abdicator	Zero guidance or review	Clear objectives + review outputs
The Switcher	Change requirements mid-task	Finalize scope before delegating
The Rescuer	Take over when agent struggles	Help agent succeed, don't replace

Effective Delegation Recipes

Recipe 1: New Component Development

Step 1: Prepare
- Decide component purpose
- Gather design requirements
- Identify similar existing components

Step 2: Delegate with context
"@frontend-developer create [component name]

Purpose: [what it does]
Props: [define interface]
Behavior: [interactions]
Style: [design specs or reference existing component]
Location: [file path]

Example usage: [show how it'll be used]"

Step 3: Review
- Check against requirements
- Test functionality
- Verify integration

Step 4: Iterate if needed
- Specific feedback
- One round of revisions ideal

Recipe 2: Performance Optimization

Step 1: Gather data
"@performance-benchmarker profile [feature/page]
Measure: Load time, runtime performance, bundle size"

Step 2: Review findings
[Identify bottlenecks]

Step 3: Delegate fixes
"@frontend-developer optimize based on these findings:
[specific bottlenecks from benchmarker]

Target: Reduce load time from 3s to <1s"

Step 4: Verify
"@performance-benchmarker verify improvements"

Recipe 3: Feature with Tests

Step 1: Implement
"@frontend-developer add [feature]
[standard delegation with clear requirements]"

Step 2: Test
"@test-writer-fixer add comprehensive tests for [feature]

Cover:
- Happy path
- Error cases: [list specific scenarios]
- Edge cases: [list known edge cases]
- Integration with [other components]

Target: 90%+ coverage"

Step 3: Verify
Check tests actually run and pass

Scope Management

The Goldilocks Principle

Too small:

❌ "@frontend-developer add a div"
(Faster to do yourself)

Too large:

❌ "@frontend-developer build the entire e-commerce platform"
(Overwhelming, unclear, will miss requirements)

Just right:

✅ "@frontend-developer create the product card component
- Image, title, price, rating, add-to-cart button
- Use shadcn/ui Button and Card
- Responsive (grid on desktop, stack on mobile)
- File: src/components/ProductCard.tsx"

Scope Sizing Guide

Task Size	Delegation	Example
Tiny (<5 min)	Do yourself	Fix typo, adjust padding
Small (15-30 min)	Delegate with minimal context	Single component, simple feature
Medium (1-3 hours)	Delegate with standard context	Feature with tests, API endpoint
Large (4-8 hours)	Break into multiple delegations	Multi-component feature
Huge (1+ days)	Must break down	Full authentication system

Common Delegation Failures & Fixes

Failure 1: "Agent didn't understand what I wanted"

Root cause: Unclear objectives or missing context

Fix:

Before: "@frontend-developer improve the dashboard"

After: "@frontend-developer reduce dashboard load time from 3.2s to <1s

Current issues:
- Loading all 1000 rows at once
- Not using React.memo for expensive calculations
- Large bundle size (500KB)

Files: src/components/Dashboard.tsx, src/hooks/useData.ts

Implement:
1. Virtualization for table (react-virtual)
2. Memoize calculations
3. Code split heavy components

Success: <1s load, all features work, Lighthouse score >90"

Failure 2: "Output doesn't match our patterns"

Root cause: Agent doesn't know your conventions

Fix:

Before: "@frontend-developer add a button"

After: "@frontend-developer add a submit button

Use our patterns:
- shadcn/ui Button component (@mention: src/components/ui/button.tsx)
- Primary variant for main actions
- Follow existing form pattern (@mention: src/components/LoginForm.tsx)

Style: Match the existing forms in the app"

Failure 3: "Agent went way beyond scope"

Root cause: Unclear boundaries

Fix:

Before: "@backend-architect improve our database"

After: "@backend-architect add index to optimize the /api/users query

Current problem: Query takes 2.3s with 50k users
File: src/db/schema.prisma

Add index to email and createdAt fields
Do NOT refactor existing queries
Do NOT change schema structure
Do NOT add new features

Success: Query <100ms, migrations ready"

Failure 4: "Agent output needed many revisions"

Root cause: Insufficient upfront clarity

Fix: Add to initial request:

• Specific acceptance criteria
• Examples of what "done" looks like
• Files to reference for patterns
• Explicit constraints

Delegation Checklist

Before delegating:

• Is this worth delegating? (>15 min task)
• Which specialist agent is best?
• What exactly needs to be done? (specific objective)
• What context does the agent need? (files, background, constraints)
• What are the success criteria? (how to know it's done)
• What are the boundaries? (what NOT to do)

After receiving output:

• Does it solve the right problem?
• Is quality acceptable?
• Does it integrate with existing work?
• Are there unintended side effects?
• Is it maintainable?

If revision needed:

• Specific about what needs changing
• Acknowledge what's good
• Provide examples or references
• One focused round of feedback

Advanced Delegation Techniques

Progressive Refinement

Start broad, narrow progressively:

Round 1 (Exploration):
"@backend-architect research options for real-time chat:
- WebSockets vs SSE vs Supabase Realtime
- Pros/cons of each
- Cost estimates
- Implementation complexity

Output: Recommendation with reasoning"

Round 2 (Detailed Design):
"@backend-architect design WebSocket implementation (based on your recommendation)
- Architecture diagram
- API contract
- Database schema changes
- Error handling approach

Output: Detailed design doc"

Round 3 (Implementation):
"@backend-architect implement WebSocket chat based on: [design doc]
Files: [specific files]
Timeline: MVP functionality first, optimizations later"

Parallel Delegation

Maximize throughput:

Single message, multiple independent tasks:

@frontend-developer create UserCard component [specs]
@backend-architect add /api/users endpoint [specs]
@test-writer-fixer add tests for utils/validation.ts
@ui-designer create onboarding flow mockups

[All work happens in parallel]
[Review all outputs]
[Integrate]

Delegation with Constraints

Explicitly state limits:

"@ai-engineer add Claude API integration for summarization

Constraints:
- Budget: $50/month max (use cost tracking)
- Latency: <2s response time
- Model: Start with Haiku, upgrade to Sonnet if quality insufficient
- Scope: ONLY summarization, no chat features yet

Do NOT:
- Add chat interface
- Implement user conversation history
- Add embedding/search features

Success: Working summarization API that meets budget and latency"

Context Preparation Templates

For New Feature Implementation

@[agent] implement [feature name]

**Purpose:** [Why this feature exists]

**User story:** As a [user type], I want to [action] so that [benefit]

**Acceptance criteria:**
- [ ] [Specific requirement 1]
- [ ] [Specific requirement 2]
- [ ] [Specific requirement 3]

**Technical specs:**
- Files: [where code should go]
- Tech: [specific libraries/frameworks to use]
- Patterns: [reference similar existing code]

**Out of scope:**
- [What not to include]

**Success criteria:** [How to verify it's done]

For Bug Fixes

@[agent] fix [bug description]

**Bug:** [What's broken]

**Steps to reproduce:**
1. [Step 1]
2. [Step 2]
3. [Expected vs actual behavior]

**Affected files:** [likely locations]

**Root cause (if known):** [hypothesis]

**Constraints:**
- Minimal changes to existing code
- Must not break [related feature]
- Maintain backward compatibility

**Success:** Bug fixed, tests prove it, no regressions

For Research Tasks

@[agent] research [topic]

**Context:** [Why we need this research]

**Questions to answer:**
1. [Specific question 1]
2. [Specific question 2]
3. [Specific question 3]

**Scope:**
- Focus on [specific aspect]
- Prioritize [what matters most]
- Time limit: [1 hour of research]

**Output format:**
- Summary (3-5 bullet points)
- Recommendation with reasoning
- Links/sources for further reading

**Success:** Clear recommendation with actionable next steps

Output Quality Standards

Minimum Acceptable Quality

All agent outputs must:

• Address the core objective
• Be technically correct
• Follow project conventions
• Include necessary documentation
• Be ready to integrate (or clearly mark as draft)

When to Push Back

Immediate pushback needed:

• Security vulnerabilities
• Performance regressions
• Breaking changes without migration
• Ignored explicit constraints
• Missing core requirements

How to push back effectively:

"@[agent] this output has a critical issue:

[Specific problem]

This violates: [constraint/requirement]

Please revise to: [specific change needed]

Keep: [what was good about the output]"

Delegation Efficiency Metrics

Track your delegation effectiveness:

Green flags (effective delegation):

• First output meets 80%+ of requirements
• One round of revisions max
• Agent outputs integrate smoothly
• Faster than doing it yourself
• Learning new techniques from agent outputs

Red flags (ineffective delegation):

• 3+ revision rounds
• Feeling frustrated with agent
• Outputs consistently off-target
• Spending more time managing than doing
• Constantly providing same context

If you see red flags: Review this skill and improve your delegation patterns

Common Scenarios

Scenario 1: "I don't know which agent to use"

Solution: Use the decision tree in coordinating-specialized-agents skill

Scenario 2: "Agent output is good but not quite right"

Solution: One clear revision request with specifics

Scenario 3: "Agent keeps missing the same thing"

Solution: You're not providing that context upfront - add it to future requests

Scenario 4: "Faster to do it myself"

Solution: Either task is too small to delegate, or you're not delegating effectively (review this skill)

Scenario 5: "Agent went in wrong direction"

Solution: Stop early, redirect with clearer objectives rather than waiting for completion

Best Practices Summary

Do:

• ✅ Choose the right specialist agent
• ✅ Provide clear, specific objectives
• ✅ Include relevant context and files
• ✅ Define success criteria upfront
• ✅ Set explicit boundaries
• ✅ Review outputs promptly
• ✅ Give specific, actionable feedback
• ✅ Acknowledge what works well

Don't:

• ❌ Delegate tiny tasks (<5 min)
• ❌ Use vague descriptions
• ❌ Assume agent has full context
• ❌ Keep changing requirements
• ❌ Ignore agent outputs
• ❌ Give vague feedback
• ❌ Forget to review quality
• ❌ Delegate strategic decisions

The Bottom Line

Effective delegation formula:

Right Agent
+ Clear Objective
+ Proper Context
+ Defined Boundaries
+ Quality Review
= High-Quality Output in Less Time

Poor delegation wastes both your time and the agent's capabilities. Master these patterns and you'll accomplish more, faster, with better quality.