primeline-ai/primeline-skills/delegation

Smart Delegation

Route tasks to the right agent at the right model tier. Stop wasting Opus tokens on file searches and Haiku tokens on architecture decisions.

Announce: "Using smart-delegation to route this task."

Quick Start

Before starting any task, score it:

Score >= 3 → Delegate to subagent
Score < 3  → Handle it yourself

Scoring (add up what applies):

Subtract:

Score >= 3? Delegate. Move on.

The Full System

Step 1: Score the Task

Run the scoring table above. If the score is negative or zero, do it yourself.

Step 2: Pick the Model

Match complexity to model. Don't overthink this.

Why not delegate 7+? Complex tasks need your full context window. Subagents start fresh with zero context - they'll miss critical connections.

Step 3: Pick the Agent Type

Step 4: Write the Prompt

Every delegation prompt needs 6 sections. No exceptions.

## 1. TASK
What to do. One sentence. Be specific.
 
## 2. EXPECTED OUTCOME
What the agent should return. Format, structure, length.
 
## 3. REQUIRED TOOLS
Which tools the agent should use. Be explicit.
 
## 4. MUST DO
Non-negotiable requirements. List each one.
 
## 5. MUST NOT DO
Guardrails. What the agent must avoid.
 
## 6. CONTEXT
File paths, patterns, constraints the agent needs to know.

Why 6 sections? Subagents have zero context about your project. The prompt IS their entire world. Vague prompts produce vague results.

Step 5: Set Effort Level

Step 6: Verify the Result

After every delegation, check:

• [ ] Does the result match EXPECTED OUTCOME?
• [ ] Were all MUST DO items addressed?
• [ ] Were all MUST NOT DO items respected?

No verification = task not complete. Trusting without checking is the #1 delegation failure.

When to Use

• Task scores >= 3 on the scoring table
• You're running low on context window (delegation saves ~90% of tokens vs doing it yourself)
• Multiple independent tasks can run in parallel
• The task is well-defined enough to describe in 6 sections

When NOT to Use

• Task involves secrets, credentials, or production systems
• User explicitly wants to see the process ("show me", "walk me through")
• Task requires deep cross-file reasoning with shared state
• You can't clearly define the expected outcome (if you can't describe it, don't delegate it)

Examples

Example 1: Delegating a Code Search

Score: Exploration (+3) + Independent (+2) = 5. Delegate.

## 1. TASK
Find all API endpoint definitions in the codebase.
 
## 2. EXPECTED OUTCOME
List of endpoints with: HTTP method, path, handler file, line number.
 
## 3. REQUIRED TOOLS
Grep, Glob, Read
 
## 4. MUST DO
-Search for route definitions (app.get, app.post, router.*, @app.route, etc.)
-Include both REST and GraphQL endpoints
-Report file path and line number for each
 
## 5. MUST NOT DO
-Don't modify any files
-Don't execute any code
 
## 6. CONTEXT
Project uses Next.js with API routes in src/app/api/

Agent: Explore | Model: Haiku | Effort: Low (3 turns)

Example 2: Delegating a Bug Investigation

Score: Exploration (+3) + 3+ files (+2) + Independent (+2) = 7. Delegate.

## 1. TASK
Investigate why the email signup form returns 500 on submit.
 
## 2. EXPECTED OUTCOME
Root cause analysis with: error location, why it fails, suggested fix.
 
## 3. REQUIRED TOOLS
Read, Grep, Glob, Bash (for checking logs only)
 
## 4. MUST DO
-Read the form component and its submit handler
-Read the API route that handles the submission
-Check for recent changes to related files (git log)
-Identify the exact line where the error originates
 
## 5. MUST NOT DO
-Don't modify any files
-Don't run the application
-Don't access any external services
 
## 6. CONTEXT
Form component: src/components/email-capture.tsx
API route: src/app/api/subscribe/route.ts
Error started after last deploy (2 days ago)

Agent: debugger | Model: Sonnet | Effort: Medium (6 turns)

Example 3: Parallel Delegation

Three independent tasks? Launch them simultaneously:

Task A: Search for unused imports     → Explore, Haiku, Low
Task B: Review auth middleware        → general-purpose, Sonnet, High
Task C: Find test coverage gaps       → general-purpose, Sonnet, Medium

All three run in parallel. You get results from all three before deciding next steps.

Anti-Patterns

Security Guardrails

Never delegate tasks involving:

• API keys, tokens, passwords, secrets
• Production database operations
• Deployment or release processes
• User data access or PII handling
• Payment or financial operations

These require your direct attention and the user's explicit approval.

With Starter System

If you have the Starter System installed:

• Use /remember to log delegation patterns that work well
• Check /context-stats before delegating - high context usage makes delegation more valuable
• Use /handoff to pass delegation insights to the next session

With Kairn (Course)

When Kairn is configured, delegation gains:

• Adaptive scoring - learns which tasks delegate well and which don't from your history
• Outcome tracking - records delegation success/failure to refine routing over time
• Cross-session patterns - "Last 5 times you delegated auth reviews to Sonnet, 4 succeeded"

Without Kairn: scoring is manual and each session starts fresh. Still valuable, just not adaptive.