---
name: "skill-time-plan"
type: skill
description: Plan Aled's time against his priorities. Use this whenever running the time-management routine, or when Aled asks how to spend his week, wants his time mapped to what matters, or feels overcommitted. Reads the current focus recommendation (the latest skill-plan output) and Aled's calendar, then proposes a weekly time allocation across the ventures and the work lanes — Aled's decisions and reviews, deep work, and relationship and pipeline time — flagging overcommitment and clashes. Proposes a plan; Aled decides and books. Never books or moves calendar events itself.
license: CC BY-NC-SA 4.0
---

# time-management

The time-planning skill. It takes what matters this week — the focus recommendation from `skill-plan` — and Aled's actual calendar, and proposes how the week's time should be spent across the ventures and the work lanes. It surfaces overcommitment and clashes before they bite. It proposes; Aled decides and books. Runs on the Linear and calendar connectors. Follows `convention-linear` and `core-operating-model` throughout.

**Ownership.** Owned by **Aide** (`A1-DE`), the Owner-serving agent (see `assistant-aide`, `core-fleet-roster`). The skill is **shareable** — the name is agnostic because time-planning is a function, not an owner, so any agent planning the Owner's time may load it. It was renamed from `skill-operator-time` (APP-431) once "operator" became a loaded canon term for a *vertical operator* (`operator-bara`), which the old name misleadingly implied. No behaviour changed in the rename.

**Where it sits in Aide.** Aide composes three skills: `skill-attention-sweep` finds and sizes the cycle's items needing Aled; **this skill** proposes how his time should be allocated across lanes and ventures against those priorities; `skill-time-block` places the specific holds inside the hold windows. This skill is the allocation layer — it decides *how much* of the week each lane and venture should claim; it does not itself book (that is `skill-time-block`).

## Trigger

Scheduled run roughly weekly, ahead of the week. Also on demand when Aled asks how to spend his week or feels overcommitted. Reads, never books.

## Behaviour

A run has three passes, in order.

### Pass 1 — Read priorities and the calendar

Read the current focus recommendation — the latest `skill-plan` output (this week's important-by-urgent set and the actions in Aled's lane). Then read Aled's calendar for the week via the calendar connector: what is already booked, how much is committed, and where the open time sits.

If no recent `skill-plan` output exists, note it and propose against milestone and priority directly, flagging that the focus recommendation is stale.

### Pass 2 — Allocate against the lanes

Propose how the open time should be spent, across two axes:

- **The ventures** — madebyneud, careerOS, A1, Mr Pritchard, the apps — weighted to where the strategy needs Aled this week.
- **The work lanes:**
  - **Decisions and reviews** — the gate work only Aled can do: approvals, merges signalled, briefs to decide from.
  - **Deep work** — the focused blocks where Aled himself builds or thinks.
  - **Relationship and pipeline** — the people time: conversations, networking, the pipeline that needs a human.

Match the allocation to the focus recommendation: the more a lane carries this week's important work, the more time it should claim.

**Standing lanes and the weekly/daily split (APP-625).** Beyond the three lanes above, the week carries **standing lanes** that are planned weekly and filled daily: the set `convention-hold-windows`' window table marks live, read by name from there and never listed here — the list this replaces named `work.Unblock` as a lane to fill, when it is Owner-filled and now carries no event after the 2026-10-05 retirement, plus "admin/networking" and "a reactive/overflow buffer", neither of which the table carries. Allocate **deep-focus** time at week granularity (it gets week-level protection and does not churn); leave the standing lanes as recurring capacity that `skill-time-block` fills day by day from Linear's actual state, rather than booking named tickets four days out. The allocation is a shape for the week, not a fixed ticket-by-ticket plan.

### Pass 3 — Flag and propose

Surface the friction:

- **Overcommitment** — the week is already fuller than the priorities can fit; name what would have to give.
- **Overcommitment vs elapsed capacity (APP-829).** When the run fires mid-week, count only the hold capacity **still ahead** at run time — windows already elapsed (a Monday morning gone by a Wednesday-afternoon run) are not capacity the week failed to absorb, and reading them as such inflates the signal. Distinguish *genuine overcommitment* (demand exceeds the week's **full** live capacity — a real signal for Atlas) from *elapsed capacity* (demand exceeds only what **remains** because the run fired late — a run-timing artefact), and never report the second as the first. Re-timing the weekly loader to fire at cycle start (Monday AM) is the structural fix and is an Owner config action, not a canon change.
- **Clashes** — booked time that collides, or that pulls against the week's stated focus.
- **Gaps** — important work in the focus recommendation with no time allocated to it.

Produce the time plan (below), posted for Aled and assigned to him. Aled decides and books — this skill never books, moves, or declines a calendar event itself. When Aide runs the full loop, the allocation this pass proposes is handed to `skill-time-block`, which places the concrete holds inside the hold windows for Aled's confirmation.

## The adaptation layer (APP-599)

Aide reads what Aled actually closed each day — `skill-time-block`'s daily pass reads Linear's real state before rebooking (APP-625) — but reading outcomes is not the same as learning from them. This section is the retrospective pass that turns that read-back into adjusted sizing and sequencing, together with the fixed, evidence-graded heuristics it is allowed to adjust and the reject-list that fences them. It lives here, in the allocation home, so it is read **before anyone edits the sizing or sequencing heuristics**. Companions carry only pointers: `skill-attention-sweep` emits the retrospective read, `skill-time-block` applies the placement rules below, and `assistant-aide` states the retrospective step in the loop.

### The retrospective pass

On a **two-week pattern — or one week where the signal is stark** (e.g. every deep-work block untouched), read outcomes back across runs and **propose** an adjustment to how the week is sized and sequenced. A block "worked" is judged on **Done-state transitions plus decisions cleared** (sign-offs, unblocking comments, answers that release other work) — **never Done alone**: measuring only Done biases Aide toward booking closeable work over consequential work, inverting the impact objective. Derive the outcome read fresh each run from Linear's state history (the daily leg already does this), which keeps Aide read-only.

### Objectives, ordered: impact → switching → volume

Pick the impactful work, arrange it to minimise switching, use volume only to break ties. **Impact is Atlas's, never Aide's** — Atlas derives it from project value and passes the ranking down; Aide never re-ranks, it only sequences already-prioritised work. **Dependency, stated rather than asked:** until Atlas produces a real ranking — its cascade is unfinished (APP-520, APP-756, MRP-19, A1-229) — the impact term is **unavailable**, and Aide sequences on **switching → volume only, and says so**. It must **not** substitute Linear priority for impact (priority is urgency, not impact) and must **not** build an interim impact proxy; stand Atlas up properly instead.

### Propose the change, never self-tune — and keep this distinct from the booking autonomy

Aide reports what it learned and proposes the adjustment; the change to a heuristic is Aled's — the heuristics stay legible rather than drifting. This is **distinct from** bounded auto-hold (APP-828): auto-hold lets Aide *book* unattended within its envelope; it does **not** license Aide to silently change *how it decides where to book*. Do not conflate the two in any wording — a future pass must not read the auto-hold grant as licence to self-tune the heuristics.

### Sizing and allocation heuristics (each with its evidence grade)

- **Commit meaningfully below capacity.** Booking to ~98% of capacity is the worst operating point — queueing wait scales with ρ/(1−ρ), and the planning fallacy guarantees spill (**STRONG for the direction; WEAK for any specific number**). Do not adopt an invented "80%" figure; let the learning loop find the level.
- **Apply ~1.3× to long items only.** The software-overrun multiplier applies to longer items; short tasks are *over*-estimated, so blanket-multiplying a 15m decision makes Aide wrong the other way (**STRONG for the boundary condition**).
- **Consider generative/creative work off-peak, analytic/decision work at peak.** Insight work may benefit from a non-optimal hour; analytic work does not (**MODERATE, thinly replicated — a hypothesis for the loop to test, not an assumption**).
- **Batch by cognitive mode, not by venture** — deciding / reviewing / making are the batching units; "mixing cost" from several live task-sets exceeds individual switch cost (**STRONG in the lab; but the generalisation to hour-scale knowledge work is a literature gap — treat as Aide's first testable hypothesis**). `skill-time-block` applies this as its primary placement axis, venture secondary within a block.

### What failed the adversarial pass — do not build on any of this

Named explicitly so no future session quietly reintroduces it, and so the drain does not re-derive it: **the "23 minutes 15 seconds to refocus" figure** (from a 2006 interview, not a paper; a scheduling interval mis-read as a recovery cost); **"multitasking costs 40% of productive time"** (a press-release gloss, not a finding); **ego depletion / decision fatigue** (failed a 23-lab preregistered replication — no "do decisions early because willpower depletes" rule survives); **chronotype-matched scheduling**; **the 90-minute ultradian work cycle**; **Pomodoro's 25 minutes**; **52/17**; **the 4-hour deep-work ceiling**; **Parkinson's law as a technique**; **evenly-spaced deadlines**; **any specific buffer percentage**; and **"no-meeting days raise productivity 71%"**. Time-blocking's *performance* benefit is also unproven — the evidenced mechanism underneath calendar blocking is **implementation intentions** (specifying when/where/what raises follow-through, **STRONG**), which is why `skill-time-block` names the specific ticket and next action in each entry.

**Evidence hygiene.** Where a rule rests on inference rather than measurement — mode-vs-venture batching (literature gap), the utilisation level (no evidenced number), off-peak creative work (thinly replicated) — say so, and make those the first things the learning loop tests. Recording *why* a heuristic is there, with its grade, is what stops a future session replacing it with folklore.

**Strongest learning signal (from APP-898).** A block the Owner has **moved** is the strongest evidence of his placement preference available — an explicit, in-the-moment correction, far better than inferring preference from what eventually closed. The retrospective pass should consume the moved-block record that `skill-time-block`'s block-identity read produces (APP-898), weighting an observed move above an inferred outcome.

## Time plan

**Present the time plan to Aled in the run's proposal — do not post it to Linear when running inside Aide.** Aide is read-only on Linear (APP-739 / APP-686), so the plan is surfaced for Aled to read and act on, not written to the os.Claude project. (Run standalone by a surface that holds Linear write scope, it may post; inside Aide it does not.) The plan shape:

```
[time-management] Week of [date]

Against this week's focus ([n] priorities from skill-plan):

By lane:
• Decisions and reviews — [proposed time] — [what it covers]
• Deep work — [proposed time] — [what it covers]
• Relationship and pipeline — [proposed time] — [what it covers]

By venture:
• [venture] — [proposed time] — [why this week]

Flags:
? Overcommitted — [what would have to give]
? Clash — [what collides]
? Gap — [important work with no time]

Proposed shape:
[a sketch of the week — blocks suggested, not booked]
```

## Guardrails

- Never books, moves, reschedules, or declines a calendar event. Reads the calendar; proposes a plan; Aled books (or `skill-time-block` proposes the holds for his confirmation).
- Proposes only — the plan is for Aled to decide from. The adaptation layer **proposes** heuristic changes; it never silently self-tunes (distinct from the auto-hold booking grant — APP-599 / APP-828).
- Names overcommitment honestly rather than fitting everything in on paper.
- Never writes code, opens a PR, or touches the delivery loop.
- Aled is the gate. The allocation is proposed; Aled decides and books it.

## Setup

- Deployed as a **Cowork scheduled task** (cloud) via a loader config — `task-aide-loop` reads this skill (Aide's weekly loop composes skill-attention-sweep, skill-time-plan and skill-time-block). Connectors: Linear and calendar.
- Cadence: roughly weekly, ahead of the week (or on demand when Aled asks).
- Routine prompt: Run the time-management skill.

Owned by Aide (A1-DE); shareable.

On finish, run skill-ops-retro capture on this run's friction: **search the Pulse queue first and add the evidence to a same-root note if one exists, otherwise file a new FRICTION note** for the drain pass to assess, in capture step 3's literal shape — team Apps, project os.Claude, `FRICTION:` title, labels `task` + `work:configuration` + `PUL-5E`, Backlog, unassigned — filing the friction, never the run report.
