← AI-pair numerics

Gantt & critical path: the schedule that has to reconcile

Ten tasks, a web of dependencies, a deadline. The pretty bar chart is the easy part — the real output is the critical path and the float, and they're not opinions: they're forced by the network. Crash the wrong task and the finish date doesn't budge.

1. The brief

A project — build and ship a test rig — is a set of tasks with durations and finish-to-start dependencies. You need three things a manager actually uses: when does it finish, which tasks are critical (a day late on these is a day late shipping), and how much float the rest have (slack before they become critical). All three fall straight out of the network by the critical-path method — a forward pass and a backward pass — and none of them is up for debate once the durations are set.

2. Why this is an afternoon, not a week

Hand Claude the task list and dependencies and it builds the CPM model and the Gantt in one pass: earliest/latest start and finish for every task, the critical path, the float, the finish date. What it can't decide for you is whether the durations are honest and the dependencies are real — and that's the whole game. The arithmetic is the part you can check; the estimates are the part you must own.

3. The Gantt

Click a bar to select a task, then drag its duration. Critical tasks are red; everything else is blue with a faint float tail showing its slack. Watch the critical path re-route and the finish date move as you push durations around.

Project schedule — bars = earliest start→finish, faint tail = float

Try it: the long pole is Procure. Drag its duration down and the finish improves — until about day 32 (around 8 days of Procure), where it stops, because the Elec design → Fab PCB → Assemble path takes over as critical. Crashing a task only buys time while it stays on the critical path. That's the single most expensive lesson in scheduling, and the network hands it to you for free.

4. Verification — the schedule reconciles

A schedule isn't a drawing; it's a system of constraints, and a sound one is internally consistent. The CPM gives you four checks no Gantt prettiness can fake.

Rung 1 — the two passes meet. Forward gives earliest start/finish; backward gives latest. Float = latest − earliest, and it can't be negative.
Pass: every float ≥ 0 — the schedule is feasible.
Fail here: a negative float means the deadline is earlier than the critical path is long. The plan is impossible as drawn, no matter how confident the bar chart looks.
Rung 2 — critical path = longest path = finish date. The critical tasks form an unbroken chain from start to end, and its length equals the project duration.
Pass: the red chain's total duration equals the finish day. If your “critical path” is shorter than the finish, you mislabeled it.
Rung 3 — crashing obeys float. Shortening a critical task helps only until a parallel path becomes critical; shortening a task with float does nothing to the finish.
Pass: drag a high-float task's duration — the finish doesn't move. Drag the long pole — it moves, then stalls. The float predicted exactly that.
Rung 4 — deadline feasibility. Finish ≤ deadline, or equivalently the critical path has non-negative float against it.
Pass: the finish marker sits left of the deadline line. If not, the honest move is to re-estimate or re-scope — not to recolor the chart.

5. Hints

Hint 1 — the critical path is computed, not chosen

Managers love to declare a task “critical” because it feels important. CPM says critical means zero float — a slip here slips the whole project. Compute it; don't nominate it. The two often disagree, and the network is right.

Hint 2 — float is where your management leverage lives

A task with 10 days of float can absorb a 10-day delay for free. Don't expedite it; don't even watch it closely. Spend your attention — and your overtime budget — on the zero-float chain. Float tells you exactly where not to spend effort.

Hint 3 — crashing has a cliff

Shortening the critical path works until a second path catches up; past that point you're paying to crash a task that no longer controls the finish. After any change, re-run CPM and look at which chain is critical now — it moves.

Hint 4 — what to ask for
PromptHere are the tasks with durations and finish-to-start dependencies. Run the critical-path method: compute ES/EF/LS/LF and total float for every task, the critical path, and the project finish. Render a Gantt with the critical path highlighted and float shown. Then confirm the schedule reconciles — every float ≥ 0, the critical chain's length equals the finish date — and flag any task whose float is under 2 days.

6. Where to draw the line

Let Claude run the forward/backward passes, the float, the Gantt, the re-computation every time a duration changes — it's exactly the bookkeeping that humans get wrong by hand on anything past six tasks. But the inputs are yours and they're where projects actually fail: are the duration estimates honest (or padded, or wishful), are the dependencies real (or just habit), is the deadline a constraint or a guess. The CPM proves the schedule is consistent; only you can make it true.

7. One worked solution

What good looks like

At the default estimates the project finishes on day 36, and the critical path is Spec → Mech design → Procure → Assemble → Test → Ship (3+8+12+5+6+2 = 36). Firmware has 10 days of float, so the instinct to “hurry the firmware” would buy nothing. The lever is Procure, the 12-day long pole — but crash it to about 8 days and the finish stalls at day 32, because the Elec-design → Fab-PCB → Assemble path becomes critical. The honest plan: attack Procure to the cliff, then re-plan against the new critical path — and hold the 38-day deadline only because there's genuine float, not because the chart is green.

8. Going further

Ship it

The Gantt explorer is itself a self-contained HTML deliverable — see explore in HTML, deliver in PDF, and spend tokens well (the CPM is deterministic arithmetic — no model tokens needed to recompute it).