version: "1.0.1" name: "delegating-work" description: "Create a Delegation Pack (brief, decision rights, context handoff, check-in cadence, debrief)."

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)
• You need to coach a PM's professional development over weeks (use coaching-pms)
• You need to manage up or influence your own manager's decisions (use managing-up)
• You need to design a 1:1 meeting cadence or agenda (use running-effective-1-1s)
• You need to coordinate across teams without a clear delegation hierarchy (use cross-functional-collaboration)

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.

Boundary example (neighbor redirect): "My PM needs coaching on strategic thinking over the next quarter." Response: this is a development/coaching engagement, not a one-time delegation. Use coaching-pms for a multi-week growth plan with practice reps and assessment.

Anti-patterns

1. Delegation-as-abdication — Handing off work with no context, guardrails, or check-ins, then blaming the delegatee when it fails. Every delegation must include decision rights and a review cadence.
2. Rubber-stamp autonomy — Saying "you own it" but then overriding every decision. If you set autonomy levels, honor them; intervene only when escalation triggers are hit.
3. Context hoarding — Sharing the task but withholding the "why", prior decisions, or stakeholder constraints. The delegatee cannot reason independently without full context transfer.
4. Milestone-free drift — Delegating with no check-in cadence or milestones, leading to a big-bang surprise at the deadline. Always define execution cadence upfront.
5. Snap-back ownership — After the project ends, the manager silently takes back ownership instead of making it durable. The debrief must explicitly confirm ongoing ownership.