---
name: window-planning
description: "Shape a day of unequal time-blocks backwards from one finish-line win. Types each window by attention bandwidth rather than availability, makes low-attention blocks earn their slot by unblocking the next one, and enters the locked window with the build prompt already written. Reach for it when the windows ahead are unequal and you want to land something material instead of making incremental progress on everything."
---

# 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.