Window Planning — Shape the Day Backwards From the Drain

The one idea

A high-leverage day is not a list of tasks fit into free time — it is a finish-line win with the day reverse-engineered to feed it. You name the big outcome first, then work backwards: what must the focused block produce to make the drain possible, and what must the low-attention blocks unblock to make the focused block possible. And time is typed by attention bandwidth, not just availability — a two-hour block with kids and a two-hour block at the terminal are not the same capacity, so they don’t get the same work.

Name the win first; reverse-engineer the day to feed it. Each window holds only the work its attention-bandwidth allows.

This is the operationalization of an older rule — schedule by cognitive mode, not by task. That rule named the window-types; this skill makes them a daily shape by pinning them to a single finish-line deliverable.

When to reach for this

• You have a known set of windows ahead (tonight, tomorrow, a travel week) and want to land something material rather than make incremental progress on everything.
• The windows are unequal — some are phone-only/with-kids, some are focused terminal time, one is a locked drain. (Equal blocks don’t need this; the value is in the typing.)
• You’re tempted to just write a to-do list and start at the top. That’s the drift path; this is the replacement.

The anatomy — the moves that make it work

1. Win-first, backwards-planned. Define the finish-line win before anything else, then work backwards through the blocks. The win is the spec; earlier blocks exist only to make it reachable. Why: forward planning fills time with whatever’s next; backwards planning subordinates the whole day to one outcome, so nothing in the day is busywork.

2. Type each window by attention bandwidth, not just availability. The three native types: async / low-attention (with kids, phone-only) → copy-paste side quests + pre-scoped minimal-question build prompts; terminal / high-attention → focused build; locked drain → short, 0–100%, one big win. Why: treating a distracted block and a focused block as interchangeable capacity either wastes the focused one on async-able work or tries to force focused work into a window that can’t hold it.

3. Feeders must earn their slot by unblocking the next block. Low-attention blocks aren’t filler — they run the research/scoping side quests that de-risk and scope the high-attention block, which in turn sets up the drain. Always ask explicitly: “what side quest in the async window unblocks the focused window?” Why: this is what makes early blocks load-bearing instead of decorative — each one removes a discovery/decision tax that would otherwise eat the expensive window.

4. The grid: candidate wins, scored, recommended, paused. Before committing the day, generate a menu of finish-line wins, score each against your backlog framework (effort, user-visible value, does-it-speed-future-development, what it teaches, plus blast radius and lane), lead with a recommendation, and stop for a single-number pick. Why: choosing the wrong win wastes the whole day’s structure. The grid makes the highest-stakes decision — what’s worth a full day — explicit, scored, and yours. It’s maker-checker applied to the day itself.

5. Drain both model pools, not just one. A five-hour premium window maxes to 100% while the cheaper pool sits untouched — that’s unused capacity. Route draftable work (first passes, scoping, drafts) to the cheaper pool; reserve the premium pool for the iterate-and-ship pass. Why: two credit pools is two resources; leaving one full is leaving capacity on the table. This is draft-cheap / iterate-expensive applied at the schedule level, not just the task level.

6. Efficiency rules embedded in every step. Short targeted responses; multiple-choice on every fork; multiple-choice whenever the assistant is unsure which “root” you’re at. Why: in a finite window, a clarification loop or a wall of prose is spent budget. Forks-as-buttons keep decisions cheap and the window moving.

7. Park future-state worries with an expiry — don’t solve them now. Capture the worry (the travel/resilience scenario, the thing that might break next week) to the backlog with a do-not-explore-now tag and an event-based retire trigger (“before Thursday”). Why: an unparked worry derails the current window; a parked one with a trigger is off your mind AND won’t be forgotten. Scaffold-with-expiry pointed at anxiety.

8. Memorialize the run as a meta-task, deferred to the wrap. Flag that the approach itself will be captured, but don’t interrupt the work to do it — surface it near handoff with a few candidate slices. Why: process documentation mid-flow is a tax; at the wrap it’s free and the run is fresh.

Candidate multipliers — confirm which were real

Honest framing: this is the plan that produced an outsized result, not the execution log. These are the moves worth betting drove the outperformance — mark which actually moved it, because that’s the signal for what to keep load-bearing vs. trim:

• Backwards-from-the-win meant zero busywork — every block visibly fed the next.
• Attention-typing meant the focused window wasn’t burned on work the async window could have absorbed.
• Side-quest-as-feeder meant the focused block opened with its discovery tax already paid.
• The grid forced the “what’s worth a whole day” decision up front, so the day committed to a scored win instead of drifting toward one.
• Dual-pool routing meant the cheaper pool absorbed the draft load instead of sitting idle.

Refinements already visible

• Tier the grid like you tier the backlog. Ten scored options is expensive. Once the families of wins are known, a 3–5 option grid keyed to lanes likely captures 90% of the value at a fraction of the cost. Reserve the full ten for genuinely open days.
• Set the reserve from the work, not a round number. “Save 30–50% usage” is a guess. Size the reserve from what the focused block actually needs to produce for the drain.
• Make the block-type → work-type mapping a lookup, not a re-derivation. (async → [research, scoping, pre-scoped build prompt]; terminal → [build, fire-test, stage-the-drain-prompt]; drain → [one locked win]). Stop re-deriving it each day.
• Enter the drain with the prompt already written. The locked hour is exactly the place to arrive with the build prompt built (the cc-build-prompts move) so the window is pure execution. Stage the drain’s prompt during the focused block. A drain that opens on scoping has already lost a chunk of its hour.
• Pre-mortem the drain. Before the locked window, name the one thing most likely to blow the hour — a clarification loop, a known deploy-friction blocker — and neutralize it upstream in the focused block.

The deeper principle (the transfer)

This is capacity planning pointed at your own week. Time is the scarce resource; you allocate it by work-type, set a reserve, and reverse-engineer from the deliverable. Materiality shows up again: the size of the win sets the depth of the planning (a drain-worthy win earns the full grid; a side quest doesn’t). It is also exactly how you shape an agent fleet’s day — high-attention human-in-the-loop windows for design and review, low-ceremony autonomous windows for laned one-shots, a reserve held back, all reverse-engineered from the deliverable that has to ship.

The deliverable is the plan; the day is the reverse-engineering.

Template (skeleton)

FINISH-LINE WIN (define FIRST): <the one outcome this day exists to produce>
  Lane: <one-shot|bounded|design> · Blast radius: <L|M|H> · Drain window: <start–end, 0-100%>

GRID (only if the win isn't obvious):
  3–5 candidates if families are known, up to 10 if the day is genuinely open. Each scored:
    Effort(low=good) · User value · Speeds future dev · Teaching · Blast radius · Lane
  → lead with a recommendation → PAUSE for a single number.

WINDOWS (type each by attention bandwidth, then assign work it can hold):
  ┌ async / low-attention   (<times>, phone / with-kids)
  │   → copy-paste side quests + pre-scoped minimal-question build prompts
  │   → MUST unblock the focused block — name the unblock explicitly
  ├ terminal / high-attention   (<times>)
  │   → focused build + fire-tests
  │   → STAGE the drain's build prompt here; size the reserve from THIS block's work
  └ locked drain   (<times>, 0-100%)
      → enter with the prompt already written; one win; pure execution

MODEL-POOL ROUTING: draftable passes → the cheaper pool; iterate-and-ship → premium.
PARKING LOT: capture future-state worries with a do-not-explore tag + event-based retire trigger.
PRE-MORTEM (drain only): name the one thing most likely to blow the hour; neutralize it upstream.
MEMORIALIZE: flag the meta-capture; do it at the wrap, not mid-flow.

Anti-patterns — the day that drifts

• Forward-planning into free time → the day fills with whatever’s next instead of feeding one win.
• Treating all free blocks as equal capacity → the focused window gets burned on async-able work, or focused work gets shoved into a distracted one.
• Filler side quests → low-attention blocks that don’t unblock anything are just motion.
• Skipping the grid on a drain-worthy day → the day commits to a win nobody scored.
• Leaving the cheaper pool idle → unused capacity; the premium pool does work the second pool could have absorbed.
• Entering the drain without the prompt written → the locked hour spends its budget on scoping instead of shipping.
• Solving the future-state worry now → an unparked anxiety derails the present window.

Provenance

Evolved from an older rule — schedule by cognitive mode, not by task — into a concrete daily shape: a finish-line win, reverse-engineered through attention-typed windows, with feeder side quests, a scored grid, and dual-pool drain. The operator’s read after the first run: it worked about twice as well as expected. The candidate multipliers and the visible refinements are flagged in-skill on purpose, so the next run keeps what was load-bearing and trims what wasn’t — calibration-earned, like everything else.