delegation — best practices for cone/scoop delegation

PHILOSOPHY

The scoops do the heavy lifting. The cone orchestrates and synthesizes. Before starting any non-trivial task, ask: can this be parallelized? The default should be delegation, not "just do it yourself."

WHEN TO DELEGATE

Delegate to scoops when:

Multiple independent sources need processing (e.g., scraping 3 websites → 3 scoops).
The task is time-consuming — research, file generation, complex builds.
The work is expressible as a clear, self-contained brief with defined inputs and outputs.
Parallelism would reduce wall-clock time (independent work items that don't depend on each other).

WHEN TO DO IT YOURSELF

The cone should handle work directly when:

It's a single quick lookup or small edit — spawning a scoop costs more than doing it.
The task requires real-time adaptation based on intermediate results.
The overhead of writing a self-contained brief exceeds the work itself.
The task requires access to the cone's conversation context that can't be summarized.

When in doubt, delegate. A slightly over-delegated workflow is better than a cone doing everything sequentially.

PARALLEL SCOOP PATTERNS

Spawn multiple scoops for independent work items. Each scoop works in parallel — the cone is notified as each finishes.

# Research 3 competing products in parallel
scoop_scoop("product-a", prompt="Research Product A. Write findings to /shared/product-a.md")
scoop_scoop("product-b", prompt="Research Product B. Write findings to /shared/product-b.md")
scoop_scoop("product-c", prompt="Research Product C. Write findings to /shared/product-c.md")
# Cone waits, then synthesizes all three into a comparison

# Build + test in parallel
scoop_scoop("implement", prompt="Implement feature X in /shared/src/...")
scoop_scoop("test-plan", prompt="Write test cases for feature X to /shared/tests/...")
# After both finish, cone integrates and runs final verification

WRITING GOOD BRIEFS

Scoops cannot see the cone's conversation. Every feed_scoop prompt must be fully self-contained. Include:

Full context — background, goals, constraints. Don't assume the scoop knows anything.
All data — file paths, URLs, code snippets, specifications. Copy them in.
Clear deliverables — what to produce, in what format, written where.
Output location — always specify where results go (e.g., /shared/results.md).

Bad brief:

feed_scoop("researcher", "Look into that API we discussed and summarize it.")

Good brief:

feed_scoop("researcher", "Research the Stripe Billing API.
- Read the docs at https://stripe.com/docs/billing
- Focus on: subscription lifecycle, proration, metered billing
- Write a summary to /shared/stripe-billing-research.md
- Include code examples for creating a subscription with Node.js
- Note any rate limits or gotchas for production use.")

RESULT SYNTHESIS

Pulling results together, resolving conflicts, and making final recommendations — that's the cone's job. After scoops complete:

Read all scoop outputs from /shared/.
Identify overlaps, contradictions, or gaps across scoop results.
Merge findings into a coherent response or deliverable.
Make final decisions that require cross-cutting judgment.
Present the synthesized result to the user.

Never just concatenate scoop outputs. The cone adds value by integrating, prioritizing, and drawing conclusions that no individual scoop could reach alone.

SCOOP LIFECYCLE MANAGEMENT

Drop scoops after synthesis is complete and their results have been consumed. But respect these rules:

Never drop a scoop that owns an active sprinkle — it must stay alive to handle follow-up interactions and lick events.
Never drop a scoop with work in progress — dropping mid-task loses all context.
Never drop a scoop with active webhooks or cron tasks.
Do drop scoops promptly after synthesis — idle scoops waste memory.

SPRINKLE DELEGATION

The cone NEVER writes .shtml files or runs sprinkle commands directly. All sprinkle work is delegated via feed_scoop. The scoop owns the sprinkle for its entire lifetime — creation, updates, and lick event handling.

# Correct: delegate sprinkle work to a scoop
scoop_scoop("dashboard", prompt="You own the sprinkle 'dashboard'.
1. Read /workspace/skills/sprinkles/style-guide.md
2. Build a dashboard showing metrics X, Y, Z
3. Write to /shared/sprinkles/dashboard/dashboard.shtml
4. Run: sprinkle open dashboard
5. Stay ready for lick events and follow-up instructions.")

# Wrong: cone writing shtml directly
write_file("/shared/sprinkles/dashboard/dashboard.shtml", "...")  # NEVER DO THIS

LICK DELEGATION

The cone NEVER handles lick events directly. When a lick event arrives (webhook, cron, or sprinkle interaction), the cone routes it to the appropriate scoop via feed_scoop. The scoop that owns the sprinkle or registered the webhook/cron is the one that should process the event.

DECISION CHECKLIST

Before starting a task, run through this:

Can the work be split into independent pieces? → Parallel scoops.
Is it a single quick action? → Do it yourself.
Does it involve sprinkles or licks? → Always delegate.
Is the brief easy to write self-contained? → Delegate.
Would you need to pass your entire conversation as context? → Do it yourself.