Zhachory1 Task Decomposition And Planning
Convert an approved goal or design into ordered, verifiable tasks. The output should let an implementer or experiment runner execute without re-deriving intent.
Core Principles
Plan after intent is approved. Do not decompose unstable goals; send unclear PRD/DD/metrics back to structured-doc-authoring, success-criteria-metrics, or agent-fleet /council when risk justifies it.
Make every task testable. Each task needs acceptance criteria and validation evidence.
Order by dependency and risk. Unblock learning and de-risk unknowns early.
Keep tasks atomic. Prefer one concern per task or PR. Split work when reviewability suffers.
Cap delivery. Default to at most two implementation PRs across all repositories for one issue. More requires explicit human approval; reviewability guidance never authorizes PR-stack expansion.
Escalate plan/design mismatch. If planning reveals design flaws, return to DD or framing instead of hiding changes in implementation.
Inputs
- approved PRD, DD, roadmap candidate, experiment proposal, or investigation goal.
- success criteria and metrics.
- constraints: timeline, owners, systems, dependencies, non-goals.
- preferred task granularity.
- run id for
run-telemetry.
Execution
Restate accepted scope. Capture goal, non-goals, and source artifacts.
Extract deliverables. Identify user-visible, system, data, test, docs, rollout, and observability outputs.
Map dependencies. Order prerequisites, external blockers, owner handoffs, and risky unknowns.
Set delivery budget. Count issue-wide implementation PRs across repositories. If plan exceeds two, defer excess work and invoke human-approval-gate with scope, smallest options, added cost/risk, and recommendation before creating another PR.
Create tasks. Write each task with context, exact outcome, acceptance criteria, validation, owner, and rollback or stop condition where relevant.
Add loop gates. Define when implementation, review, experiment, or roadmap loops stop, continue, or escalate.
Prepare handoff. Package plan for ship, ML run, roadmap owner, or investigation agent.
Emit telemetry. Record task count, dependency count, unresolved blockers, estimated effort, and plan confidence via run-telemetry.
Output Contract
# Task Plan
## Scope
- source artifacts:
- goal:
- non-goals:
- success criteria:
## Task Graph
- id:
title:
why:
depends on:
owner:
acceptance criteria:
validation:
risks:
stop condition:
handoff target:
## Execution Order
- wave:
tasks:
gate before next wave:
## Open Blockers
- blocker:
owner:
required decision:
## Loop Policy
- loop:
success gate:
budget cap:
delivery PR count:
approved delivery PR cap:
deferred work:
escalation:
delta-only rule:
Workflow Uses
plan-to-launch: plan writing beforeship.ml-experiments: experiment schedule, baselines, training runs, validation checks.roadmapping: dependency and capacity-aware sequencing.debug-investigation: evidence collection and hypothesis test plan when issue is complex.backprop: improvement hypothesis rollout plan.
Success Criteria
- every task has acceptance criteria and validation.
- dependencies are explicit.
- plan exposes blockers rather than burying them.
- delivery has no more than two issue-wide implementation PRs without explicit approval.
- task order reduces risk early.
- handoff target is clear.
run-telemetryevent emitted.
Common Failure Modes
Implementation hidden in planning. Fix by writing desired change and validation, not code details unless required by DD.
Task list without gates. Fix by adding stop/continue/escalate conditions.
Scope creep during decomposition. Fix by returning new requirements to PRD/DD approval.
Huge task. Fix by splitting into reviewable slices with independent evidence.
PR-stack expansion. Fix by deferring excess work and requesting explicit human approval; line limits are guidelines, not permission for more implementation PRs.
Self-Improvement
Track task types that repeatedly miss acceptance criteria, create rework, or block on hidden dependencies. Feed patterns into backprop to improve decomposition heuristics and default task granularity.