name: "delegating-work"
description: "Create a Delegation Pack (delegation brief, decision rights, context handoff, check-in cadence, review plan, debrief). Use for delegation, letting go, empowering reports, and avoiding micromanagement."

Delegating Work

Scope

Covers
- Delegating a specific project/problem/decision to a direct report (or cross-functional owner)
- Transferring context without control (clear outcomes + guardrails, not step-by-step instructions)
- Setting decision rights, check-in cadence, and “in-the-details” quality reviews without micromanaging

When to use
- “Help me delegate this project/task to someone on my team.”
- “I’m holding onto too much / I need to give away my Lego.”
- “I’m worried I’m micromanaging—how do I stay in the details but empower ownership?”
- “Draft a delegation brief + decision rights + check-in plan.”

When NOT to use
- The work is primarily a performance problem (use coaching/feedback workflows instead)
- You need to decide what work to do (prioritization/scope first)
- You lack a clear outcome, constraints, or success criteria (do a quick problem-definition first)

Inputs

Minimum required
- The work item to delegate (project/problem/decision) + why now
- Desired outcome (definition of done) + success metrics or acceptance criteria
- Constraints/non-negotiables (timeline, budget, quality bar, policies, stakeholders)
- Delegatee context (role, current load, experience level, growth goals if relevant)

Missing-info strategy
- Ask up to 5 questions from references/INTAKE.md.
- If details are unavailable, proceed with explicit assumptions and label unknowns.

Outputs (deliverables)

Produce a Delegation Pack (Markdown in-chat, or files if requested) in this order:
1) Delegation brief (outcome, context, constraints, stakeholders, timeline)
2) Decision rights + guardrails (what they can decide, escalation triggers, review points)
3) Context handoff pack (links, background, “known gotchas”, example outputs)
4) Execution cadence (check-ins, update format, what “good” looks like)
5) Review plan (how to be in the details without telling them how to do it)
6) Debrief plan (learning capture + ownership updates)
7) Risks / Open questions / Next steps (always included)

Templates: references/TEMPLATES.md

Workflow (8 steps)

1) Frame the delegation decision

• Inputs: Work item + why now; constraints.
• Actions: Define the outcome, the “why” (business context), and what must not change (non-negotiables). Decide what “good” looks like.
• Outputs: Draft Delegation Brief (top section).
• Checks: The outcome is measurable/testable (someone can say “done” unambiguously).

2) Pick the owner + choose the autonomy level

• Inputs: Candidate owner(s); their experience and growth goals.
• Actions: Select the delegatee. Set an explicit autonomy level (e.g., “propose + I approve” vs “you decide, inform me”). Call out which parts are “on assignment” vs “high flexibility.”
• Outputs: Owner + autonomy statement + boundaries.
• Checks: Both of you can repeat: “What decisions are yours vs mine?”

3) Transfer context (not instructions)

• Inputs: Background docs; prior decisions; stakeholders; constraints.
• Actions: Provide full context so the owner can connect the dots. Share the “why”, the tradeoffs, and known pitfalls. Avoid prescribing the exact path.
• Outputs: Context Handoff Pack.
• Checks: Owner can explain the problem, constraints, and success criteria in their own words.

4) Define decision rights + guardrails

• Inputs: Non-negotiables; risks; stakeholders.
• Actions: Write decision rights, escalation triggers, and review points. Set “red lines” (quality, policy, safety, customer impact).
• Outputs: Decision Rights + Guardrails.
• Checks: Escalation triggers are specific (not “if it feels risky”).

5) Align on plan + milestones (owner-led)

• Inputs: Draft Delegation Brief + guardrails.
• Actions: Ask the owner to propose a plan, milestones, and tradeoffs. Act as a thought partner: ask questions instead of giving the answer.
• Outputs: Milestone plan + first-week plan.
• Checks: Plan has milestones tied to outcomes, not just activities.

6) Set the execution cadence

• Inputs: Timeline; team routines; stakeholder needs.
• Actions: Set check-in frequency, update format, and what you want to see (risks, decisions, asks). Establish how you’ll “refuse to rule” unless a trigger is hit.
• Outputs: Cadence + Update Template.
• Checks: Check-ins focus on outcomes/risks/decisions, not task-by-task status.

7) Review in the details without micromanaging

• Inputs: Work artifacts; review points.
• Actions: Review output quality via artifacts (docs, specs, results) and criteria. When the team is struggling with the right problems, step back. When it’s the wrong problem, intervene with clarity on outcome/guardrails.
• Outputs: Review notes + decisions (approve/adjust/escalate).
• Checks: Feedback is framed as “quality bar + constraints” (not “do it my way”).

8) Close the loop (debrief + “give away the Lego”)

• Inputs: Final deliverable; what happened; learnings.
• Actions: Debrief what worked/what didn’t, update ownership maps, and explicitly acknowledge the new owner. Capture improvements to templates/guardrails.
• Outputs: Debrief notes + next delegation candidates.
• Checks: Ownership is durable (not “it snaps back to you” after delivery).

Quality gate (required)

• Run references/CHECKLISTS.md and score with references/RUBRIC.md.
• Always include: Risks, Open questions, Next steps.

Examples

Example 1: “Delegate discovery + recommendation for improving onboarding activation to my PM.”
Expected: delegation brief, decision rights (what PM decides vs escalates), context pack (data + constraints), weekly cadence, review plan for the final recommendation doc.

Example 2: “Delegate building a lightweight internal tool to an engineer, but I’m worried about security/compliance.”
Expected: guardrails + escalation triggers, clear non-negotiables, review points for design + launch readiness, and a debrief plan.

Boundary example: “Delegate ‘make the company strategy better.’”
Response: require a narrower outcome (decision to support, artifacts, time box) before producing the Delegation Pack.