Better Execute · Working Plan

Task & Project Management Strategy

The companion working document to the essay "Why Strategy and Execution Are About To Diverge." This is the actual planning artifact produced in a single afternoon — feature comparison, gap analysis, strategic synthesis, phased LOE plan, 4-week sprint, risks, and open questions. Reproduced here as published.

1. Where DCE actually stands today

DCE has a credible strategy-execution backbone but a thin task surface.

Strong

• VTO → CompanyPriority → NinetyDayProject (Rocks) → Milestones → Todos chain, with Scorecard/Measurable linkage
• Meeting → Decision → Topic → Todo flow
• Agent proposal model with trigger / evidence / confidence and human approval gates
• PlanDependency model spans PLAN ↔ MILESTONE ↔ TODO (queryable but not enforced)
• Quarterly cadence baked in, not retrofitted
• Org label customization ("Rock" vs "90-Day Project" vs "Sprint")

Thin

• Todo is a single-assignee, two-state (PENDING / COMPLETE) row
• No comments, no attachments, no subtasks, no custom fields, no recurrence, no time estimate
• Only list views anywhere — no Kanban, calendar, or timeline
• PlanDependency exists but isn't enforced (can complete a blocked task)
• No notifications, no @mentions, no inbox, no saved views, no bulk ops
• No event for: comment added, attachment uploaded, dependency blocked, time logged

That's the honest starting line.

2. Asana's feature surface (what we're really comparing against)

That's the surface area "Asana-quality" implies. Don't try to match it 1:1. Match the floor, then leapfrog where agents matter.

3. Gap analysis — classified

Table stakes (cannot be a "task hub" without these)

1. Subtasks on todos (or unify Todo into the same tree as Project/Milestone)
2. Comments + @mentions on todo, project, milestone, topic
3. File attachments (todo, project, comment) — likely S3-compatible blob layer
4. Notifications — in-app inbox + email digest, eventually push
5. Multiple assignees / followers on tasks
6. Multi-view rendering: Kanban (by status), Calendar (by due date), at minimum
7. Recurring todos ("every Mon", "every 1st of quarter")
8. Personal "My Work" inbox unified across todos, milestones I own, meeting prep, agent proposals awaiting my approval
9. Bulk operations + search (full-text on description, multi-select, bulk reassign/reschedule)

LOE: ~8–12 engineering weeks if scoped tightly.

Parity must-haves (well-known patterns)

10. Custom fields (per-org, per-project) — text/number/select/date/person. Schema today has zero. Biggest single data-model addition.
11. Saved views / filters with shareable URLs
12. Dependency enforcement — PlanDependency exists; UI must surface "blocked by X" and warn on completion
13. Templates for projects + todos
14. Forms for intake — DCE already has intake-style flows for proposals; extend
15. Workload view (per-owner capacity)
16. Mobile-responsive task list

LOE: ~10–14 weeks. Custom fields alone is 3–4 weeks done well.

Reach-but-defensible (Asana ceiling features)

17. Timeline / Gantt with dependency visualization and critical-path
18. Portfolios (cross-project rollups by theme/initiative — generalize CompanyPriority)
19. Rules engine (no-code automation)
20. Rich reporting / dashboards (universal query → chart)
21. Skip: Proofing / image annotation — not core to leadership execution
22. Skip: Time tracking — doesn't fit ICP unless customer demand spikes

LOE: ~12–16 weeks for 17–20.

4. The strategic wedge: why DCE wins, not by being Asana

Asana model: Humans manage work. AI is a sidebar that suggests when invited.

DCE model: Humans and agents co-manage work. The agent canvas is a peer of the human canvas, not a feature of it.

Five capabilities Asana cannot easily copy because they assume an agent-native data model and a human-approval governance loop:

Wedge 1 — Continuously curated personal Inbox

Not "your tasks sorted by due date." An agent-curated daily brief:

• "8 tasks blocked — 3 are blocking your Q2 Rock; here's the proposed escalation"
• "Meeting recap from Tuesday produced 12 candidate todos; I've drafted them, routed to owners, here are the 4 you should personally approve"
• "Your scorecard for Sales Velocity missed for the 3rd week — most likely root-cause project is Outbound Motion; its Rock is at 47% with 3 weeks left"

Asana can build a daily summary. They cannot build agent-mediated routing of work-to-attention with strategic causality without DCE's strategy-plan model.

Wedge 2 — Strategy-causal task graph

Every todo can answer: what Rock does this serve? what Priority? what VTO section? what scorecard measurable? The graph already exists in DCE; today it's read-only and human-traversed. Make it agent-traversed and bidirectionally inferred:

• Agent reads a meeting transcript → proposes a todo and its causal link to a Rock or scorecard miss.
• Closing a todo can propose updating Rock confidence or completionPct.
• Missing a scorecard can propose status changes on dependent projects.

Asana has Goals; they don't have evidence-graded causal links between meeting decisions, scorecard misses, and individual todos.

Wedge 3 — Proposal-driven mutation as the default write path

DCE's AgentProposal (with trigger, evidence, confidence, human approval) is already the right abstraction. Extend it to all significant agent-generated changes — task creation from transcripts, re-prioritization, dependency inference, capacity reallocation. Customers get AI that doesn't go rogue: every change has an audit trail.

Per-agent authority bands become a settings concept: "Execution Agent: auto-apply proposals at confidence > 0.9 on stale-project nudges; require approval on status changes." A concrete admin feature with a clean security story.

Wedge 4 — Meeting-native work creation

Meeting Coach already does live transcript → guarded-LLM analysis. Extend to a post-meeting work pipeline: transcript → decisions → topics → proposed todos with owners + dependencies + linked Rocks → routed for approval. Asana has Zoom/Loom integrations but nothing close to in-flow work generation tied to a strategy plan.

Wedge 5 — Predictive Rock health

Already have confidence on NinetyDayProject and quarterly cadence. Add agent-driven trend analysis:

• "Outbound Motion trending to 72% completion at quarter end based on milestone velocity; recommend dropping milestone X or moving to next quarter"
• "Owner has 3 Rocks at AT_RISK; capacity score suggests reassigning #2"

The strategic execution coach every leadership team wishes they had. Asana's Goals are passive; DCE's would be predictive and proposal-generating.

5. Recommended strategy (one paragraph)

Ship the table-stakes floor (Phase 0–1) so leadership teams can genuinely live in DCE without an Asana tab open. Skip Asana's depth ceiling (timeline, rules, proofing) until customer demand is concrete. Pour the differentiation budget into the agent-native wedge — Inbox, causal graph, proposal-as-default, meeting-native work creation, Rock health. Position is not "Asana with strategy"; position is "the strategic execution OS where agents and humans co-manage the work, with audit trail." The thing Asana can't easily copy isn't a feature — it's the governance model DCE already has.

Critical guardrail: every parity feature must avoid making DCE generic. Custom fields, for example, must ship in a way that strengthens — not dilutes — the strategy linkage (custom fields are first-class on NinetyDayProject and surface on agent proposals so agents can read/write them).

6. Phased LOE plan

Sizing assumes 1 senior engineer + Cursor/Claude assistance, full-stack, full-time-equivalent.

Phase 0 — Credibility floor (~8–10 weeks)

• Subtasks on Todo (or unify Todo + Milestone into a generic Item tree) — 2w
• Comments + @mentions on Todo, Project, Topic, Milestone — 1.5w
• File attachments via S3-compatible blob — 1w
• Notification system (in-app inbox + daily email digest) — 2w
• Kanban board view + Calendar view on Todos and Projects — 2w
• Personal "My Work" page consolidating todos, milestones, meetings, proposals — 1w
• Bulk select + search — 0.5w

Phase 1 — Parity (~10–14 weeks)

• Custom fields (per-org, per-target-type, indexed for filter/search) — 3–4w
• Saved views / filters with shareable URLs — 1.5w
• Dependency enforcement + visual indicators — 1w
• Recurring todos — 1w
• Templates (Project + Todo) — 1.5w
• Forms (extend existing intake patterns) — 1.5w
• Workload view — 1w

Phase 2 — Reach (~10–14 weeks, opportunistic)

Don't build pre-emptively; build when a paying customer points at one.

• Timeline / Gantt with dependency viz — 3–4w
• Portfolios (generalize CompanyPriority aggregation) — 2w
• Rules engine — 3–4w (consider whether agent proposals already cover the use case)
• Universal reporting / dashboards — 3w

Phase 3 — Agent wedge (parallel from week 1; never "done")

• Wedge 1 — Curated Inbox — first version ~4w
• Wedge 2 — Causal graph traversal in agents — ~3–4w
• Wedge 3 — Authority bands on proposals — ~2w
• Wedge 4 — Meeting-to-work pipeline — ~4–5w
• Wedge 5 — Predictive Rock health — ~4w

Total ballpark

• Floor + parity (Phase 0+1): ~5 months to be credible
• Wedge (Phase 3): another ~3–4 months to be differentiated; can run in parallel

7. Risks to watch

1. Don't make DCE generic. Phase 1 custom-fields work is the highest drift risk. Design custom fields to strengthen strategy linkage (visible to agent proposals; filterable in causal queries), not to enable arbitrary org schemas.
2. Customer-driven sequencing. Customer signal can reorder this list — likely "notifications" and "comments" get pulled forward, "Kanban" pushed back. Sequence based on customer signal, not internal priors.
3. The wedge is the moat, not the parity work. If 6 months go into matching Asana feature-for-feature and zero into the wedge, DCE arrives at "worse Asana." Reverse the temptation: fund the wedge first if forced to choose.
4. Don't skip the data-model question on subtasks. Cleanest model is "Todo and Milestone are both Items with parent_id, polymorphic-by-context." Schema unification now is much cheaper than later.
5. Agent authority-bands feature is more important than it looks. It's the answer to every "I don't trust AI to do that" objection in sales calls.

8. 4-Week Todo Hub Sprint (immediate plan)

Constraint: 1 senior dev + Cursor/Claude, ~4 weeks. Every line must be foundation for the long-term wedge — not throwaway.

The picks (in priority order)

1. "My Work" inbox page — surface my open todos + milestones I own + meetings I prep + proposals awaiting me, sorted/grouped (overdue/today/this-week/blocked). Wedge alignment: v0 surface for Wedge 1 (Curated Inbox). Start with rule-based ranking; agent-curation drops in later behind the same UI.
2. Comments + @mentions on Todo (polymorphic so it extends to Project, Topic, Milestone later). Wedge alignment: same Comment model becomes where agents post evidence later. Polymorphic with authorType (USER | AGENT) baked in from day one.
3. Extend the existing Notification model + add @mention events + daily email digest — the Notification model and NotificationType enum, the bell, and the existing producer paths all exist. Add new NotificationType values for @mention, comment activity, and todo events; wire the agent event bus and the new comment events into those producers. Build the daily email digest as a new cron route that reads from the same Notification table. Do not introduce a parallel notification schema. Wedge alignment: curated-inbox wedge inherits the existing primitive; daily email digest reuses existing cron infra.
4. Subtasks on Todo — parentTodoId self-referential relation; flat one-level depth fine for v1. Wedge alignment: cheapest down-payment on eventual Item-tree unification.
5. Kanban (Board) view on Todos — drag-to-change status; expand the Todo status enum from PENDING | COMPLETE to PENDING | IN_PROGRESS | BLOCKED | COMPLETE. Wedge alignment: BLOCKED is the status dependency-enforcement needs later; expand the enum once.
6. Bulk multi-select + Cmd+K quick-add modal.

Explicitly NOT in this sprint

• Custom fields (3–4 weeks alone)
• File attachments (S3/blob infra burns a week before any UX)
• Recurring todos (not in the daily pain top 3)
• Calendar view (Kanban + My Work covers more pain per week)
• Multi-assignee (semantics tricky — followers? notifications?)
• Templates, forms, saved views (Phase 1)

Week-by-week shape

Week 1 — schema + plumbing

• Migrations: Comment (polymorphic targetType/targetId, authorType USER|AGENT), Todo.parentTodoId, Todo.status enum expansion + backfill, plus new NotificationType enum values (MENTION, COMMENT_ON_OWNED_TODO, TODO_DUE_SOON, etc.) extending the existing Notification model — not a new model.
• Reuse existing producers; add producer hooks for the new event types.
• Wire agent event bus → existing Notification rows for the new event types.
• Update seeds.

Week 2 — My Work + Kanban

• /dashboard/my-work page: rule-ranked feed, grouped by overdue/today/week/blocked, with proposals-awaiting-me as top section
• Kanban view toggle on /dashboard/todos. Drag = status change.
• Subtask UI on Todo detail (inline checklist; complete-parent guard if subtasks open)

Week 3 — collaboration

• Comments component on Todo detail with @mention picker (org members)
• @mention → Notification
• Notification inbox UI (top-bar bell + dropdown + full page)
• Quick-add Cmd+K modal

Week 4 — polish + wedge sliver + bulk ops

• Daily email digest (new cron route, fail-closed on CRON_SECRET, Postmark template)
• "My Work" gets a strategy-priority bump: todos transitively linked to an active Rock or scorecard miss rank higher — first taste of Wedge 2 (causal graph) using only data that already exists
• Bulk select + complete/reschedule/reassign
• QA, manual walkthrough, release notes (internal + customer)

Risks & guardrails for the sprint

• Polymorphic Comment model must be designed once correctly (targetType/targetId, authorType baked in). Schema review is week-1's most important hour. Note: Notification is not a new model — extend the existing one; do not duplicate or reshape its schema.
• Status enum migration: every existing Todo defaults to PENDING; safe but explicit migration script required.
• Don't make DCE generic — every UI label stays DCE-native. "My Work" not "My Tasks." Status names follow DCE terminology.
• Customer interference: don't start Week 1 in the middle of an active customer rollout.
• Cron secret discipline: new digest cron must validate CRON_SECRET and fail-closed (existing policy).
• Plan-tier gating: ship all of this on every tier. These are floor features, not premium.

What you get at the end of week 4

A user logs in, lands on My Work, sees a strategy-ranked list of what they should care about today, drags todos across a Kanban board, comments and @-mentions colleagues, gets a notification when something happens, breaks big todos into subtasks, and reads a daily digest in their inbox. Agent proposals already in the system surface naturally inside My Work as actionable cards.

A categorical upgrade in feel — and every line of it is foundation for the wedge:

• Comment.authorType for agent comments later
• Existing Notification primitive (extended, not duplicated) for curated-inbox wedge
• Subtask self-ref for item-tree unification later
• BLOCKED status for dependency enforcement later
• Strategy-ranked My Work as Inbox v0

9. Open questions to resolve before kickoff

• Customer signal: which of these picks do active customers actually push on first?
• Item-tree schema unification: do we commit to it now (longer Week 1) or live with parentTodoId for v1?
• Notification delivery channel: in-app + email this sprint; Slack/Teams Phase 1?
• Comment authorship for agents: design the UX now even if we don't ship agent comments until Wedge 2?