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:
- Delegation brief (outcome, context, constraints, stakeholders, timeline)
- Decision rights + guardrails (what they can decide, escalation triggers, review points)
- Context handoff pack (links, background, “known gotchas”, example outputs)
- Execution cadence (check-ins, update format, what “good” looks like)
- Review plan (how to be in the details without telling them how to do it)
- Debrief plan (learning capture + ownership updates)
- 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.