STATE — Progress Ledger

Read this file first. Every session starts cold and reads only this. It is updated at the end of every session with: what we did, the scores, what is next, and what is blocked.

Table of Contents

• Right Now
• Your Next Action
• Blocked On You
• Levels
• Session Log
• Build Backlog
• Mock Scores
• Milestone Tracker
• Pre-Interview Checklist

Right Now

Your Next Action

Take the 3-hour baseline diagnostic.

Book one uninterrupted block. Timer visible, recorder on, no AI, no search, no docs.

Then score against RUBRIC.md, record in scores/, and report the numbers. PLAN.md unlocks the moment I have them.

Blocked On You

Things I cannot do without input from you. Each blocks something real.

Levels

Assigned from the diagnostic. Blank until it is taken.

Session Log

Newest first. One entry per working session.

2026-07-31 — Session 7: Track G's diff bank

Did: wrote tracks/agentic/DIFFBANK.md — 30 agent-produced diffs to accept, reject or revise in 90 seconds each, extending the five in the warmup. Track G was the thinnest track and its core skill — deciding what the agent produced is safe to ship — had five examples. Eight categories, a six-pass review ordered by how cheaply each pass finds a fatal problem, and a ranked taxonomy of what agents actually get wrong.

Two structural additions that matter more than the diffs:

• Section H — "Looks Wrong, Is Right". Reflexive rejection is a scored failure and the bank now tests for it directly. An engineer who rejects all thirty scores worse than one who accepts the three that are correct.
• "The Things You Cannot See in a Diff." git diff --stat first, every time; and after the agent's tests pass, break the implementation and confirm the test fails. Thirty seconds, directly targets what agents are worst at, and almost nobody does it.

The measurement that changed a section: the folk rule "s += x in a loop is O(n²)" is false on CPython — measured 1.5× vs join and linear at n up to 500k, because unicode_concatenate resizes in place at refcount 1. Hold one extra reference and it becomes 300× at n=50k and quadratic. So the diff is ACCEPT-with-a-precondition, not REJECT — and the transferable point is that a performance rule resting on an interpreter optimization must be stated with its precondition.

Next: unchanged — the diagnostic.

2026-07-31 — Session 6: Track A's follow-up bank

Did: wrote tracks/coding/QUIZBANK.md — 150 questions asked after your code works, the Track A counterpart to Track B's quiz bank. Fourteen sections, one per WARMUP chapter plus complexity, testing and concurrency, each mapped to the harness problem it attaches to. Opens with the six shapes of follow-up, because misclassifying the shape is how a correct answer becomes an irrelevant one, and closes with the twenty that recur most.

Every measurable claim was measured on 3.13 rather than asserted, and three came out somewhere other than where I expected:

• list.pop(0) vs deque.popleft at n=100k: 15,895 ns vs 40.7 ns — 390×.
• flush() vs flush()+fsync(): 2.2 vs 24.5 µs — only 11×, because macOS fsync() does not flush the drive's write cache (that needs F_FULLFSYNC). The low ratio is itself the finding and is now taught as one.
• dict[k] += 1 across 4 threads lost zero updates — the same eval-breaker behaviour Track B's experiments found. Recorded as "an implementation detail, not a guarantee", with the free-threading consequence.

Next: unchanged — the diagnostic.

2026-07-31 — Session 5: Track D gets its own eight worked designs

Did:

• Wrote m01–m08 — the ML-infrastructure design round, in the same shape as Track C's twelve: nine sections, six hostile critiques, six revisions. 48 defects found, 48 fixes. LLM API platform · KV cache tier · GPU cluster scheduler · pretraining data pipeline · eval harness · RAG serving · LoRA serving · training fault tolerance.
• Wrote designs/README.md for the track, including the section that is worth more than any single design: which Track C primitives carry over, and which distributed-systems instincts actively fail on a bandwidth-bound substrate.
• Every number in all eight was computed by script before being written down.

Two real errors that surfaced while doing that arithmetic — both in material already committed, both the kind that would have been quoted in a round:

• Machine balance was 2× too high. The guide used NVIDIA's headline 1,979 TFLOP/s BF16, which is the with-2:4-sparsity number. LLM weights are dense, so the honest figure is 989.5 and the balance is 295 FLOP/byte, not 590. Fixed everywhere, and the asterisk is now taught as a trap — quoting a sparsity number for a dense workload is a fast way to lose credibility.
• gpu_math.py was 4× pessimistic on anything multi-GPU. It divided aggregate bytes and FLOPs by single-GPU bandwidth, so a 70B on 4×H100 reported $4.92 per 1M output tokens. Corrected it is $1.23, which is in the range real providers charge. The ratio (and so the memory-bound verdict) was always right; every absolute number was not.

The lesson worth keeping: both errors survived a full pass of writing and review, and both died the moment a number had to be used in a downstream calculation. Deriving something from a number is a much stronger check than reading it.

Next: unchanged — the diagnostic.

2026-07-31 — Session 4: all twelve designs, plus the two reference documents

Did:

• Wrote d02 through d12 — the eleven remaining design exercises, in the same shape as d01: nine template sections, then six hostile critiques, then six revisions. Across the twelve that is 72 defects found and 72 fixes written. Every one names a concrete flaw in the first draft, not a stylistic quibble.
• Wrote designs/README.md — the index. Beyond the table it carries the two things that generalize: a cross-cutting pattern map (which of the ~13 primitives recurs in which designs), and a defect taxonomy over all 72 critiques.
• Wrote CHEATSHEET.md — every track compressed into what fits in working memory before a round, including the verbatim scripts to say out loud at each of the six moments an interview goes wrong.
• Wrote GLOSSARY.md — every term used anywhere in the program, one line each, each pointing at where it is actually taught.
• Registered all of it in SUMMARY.md; corrected the Track C and root READMEs, which still described d02–d12 as future work.

The finding worth keeping — from tabulating what the 72 critiques actually caught. The single most common defect class is arithmetic never done: ten of the twelve first drafts asserted something a two-line calculation disproves (d10's rebalance moving 2.4 TB off one node; d05's circuit-state read at 1M/s). Second is an uncosted hot path, eleven instances. Neither is a knowledge gap — both are the same missing habit.

Before defending a component, size it. That one rule would have prevented 21 of 72.

Next: unchanged — the diagnostic. Twelve worked answers are worth nothing until you have measured yourself against one cold.

2026-07-31 — Session 3: the harness fully automated, Track E written

Did:

• Automated all 13 remaining harness problems. Every one of the 15 now ships a starter.py, a heavily-commented reference solution.py, and a gate-test module. 60 of 60 gates green, in ~6 seconds: python3 tracks/coding/harness/runtests.py.
• Rewrote the problem catalog so every gate brief is API-precise — the briefs are the spec the candidate codes against, so vagueness there is a bug.
• Dropped the --self-certify path from the harness; on completion it now prints the WARMUP chapter that teaches the pattern.
• Wrote tracks/take-home/WARMUP.md — the last track without a study guide. Hour-by-hour 48-hour playbook, the webhook system specified with seven logged decisions and a worked benchmark write-up, and the deep-dive interrogation: 40 questions across seven classes with full model answers, including the hostile ones.

Bugs the gate tests caught in my own reference solutions — which is the point of writing the tests first:

• path-resolver: physical mode resolved .. against the cwd string instead of walking the cwd's own symlinks, so /a/link/.. gave the logical answer in physical mode.
• text-index: re-adding a document did not purge its buffer postings, and _postings unioned across segments before filtering — so a replaced document's OLD terms resurfaced in results.
• async-crawler: an empty seed list hung forever, because the sentinel that ends the stream is only produced by a worker and no worker ever ran.
• object-pool: __slots__ removes weakref support along with __dict__, so the pooled class needs '__weakref__' explicitly or the leak detection cannot work at all.

And one finding worth keeping: on CPython 3.11+ the instance dict is managed and created lazily, so a subclass that omits __slots__ measures identical to a slotted one — same sys.getsizeof, same tracemalloc — until something is actually stored in the dict. Then it is 5.8× larger (41.6 MB vs 7.2 MB over 100k instances). The reliable tell is hasattr(x, "__dict__"), not the size. The gate test now teaches exactly that.

Next: unchanged — the diagnostic.

2026-07-30 — Session 2: study material written

Why: the first pass produced inventories and pointers — what to practise and how you're scored — but not the material itself. Everything named was a link to somewhere else. That was the right criticism and this session fixes it.

Did — eight self-contained study guides, ~15,000 lines:

• tracks/coding/WARMUP.md — ten patterns from first principles with complete implementations (MVCC/predecessor queries, delta logs, intrusive lists, four rate limiters, heap scheduling, streaming state machines, dependency graphs, WAL + crash recovery, Bloom filters, backpressure). 63 behavioural checks run green, including a WAL test that truncates the file at every byte offset.
• tracks/python-internals/WARMUP.md — the runtime from the interpreter up, including an event loop built from scratch.
• tracks/python-internals/QUIZBANK.md — 150 questions with mechanism-level answers, spot-checked against a live interpreter.
• tracks/systems-design/WARMUP.md — every primitive from zero: Little's law, the utilization knee, the failure taxonomy, clocks/Lamport/vector/HLC, leases and fencing in full, quorums, Raft including both safety rules, consistency models, partitioning, delivery semantics and the outbox, load control, CRDTs.
• tracks/systems-design/designs/d01-job-scheduler.md — the reported screen question worked end to end, then attacked by a hostile interviewer, then revised. The critique found six real defects in the first draft, which is the point.
• tracks/ml-infra/WARMUP.md — inference from zero with the roofline derived, plus a complete "design ChatGPT" answer at both altitudes and the follow-ups answered. 24 arithmetic claims verified by script.
• tracks/behavioral/WARMUP.md — all twelve categories with worked model answers at staff density.
• tracks/agentic/WARMUP.md — a fully worked 60-minute agent-driving transcript with scoring commentary, and five diffs to accept or reject.

Errors caught by verification, worth remembering:

• gc default thresholds are (2000, 10, 10) on CPython 3.13, not the long-documented (700, 10, 10). Both files now teach the shape plus gc.get_threshold() rather than a memorized constant — it is a live example of the confident-wrong failure mode.
• The decode memory/compute ratio is 590×, not 600× — and it lands exactly on the machine balance, which is a useful self-check that the derivation is right.

Next: unchanged — the diagnostic. The study guides do not replace it; they are what you read after it tells you where you are weak.

2026-07-30 — Session 1: program built

Did:

• Phase 0 research. Corroborated the source report against independent sources; wrote research/findings.md with confirmed / reported / inference labels and an explicit source-quality assessment.
• Wrote research/source-report.md — all 41 rows, each with a corroboration mark and a destination, plus a coverage audit.
• Wrote research/company-brief.md — charter structure, talking points, three questions to ask, adaptation table for eight other labs.
• Built the full baseline diagnostic: 4-gate coding problem with a working test runner and reference solution (all gates verified passing), system-design exercise with hidden follow-ups, 20-question internals quiz (every answer verified against a live interpreter), 3 behavioral prompts, answer key, rubric with level mapping, score template.
• Built the progressive harness — gating, timing, chart, 15-problem catalog. Two problems fully automated (versioned-kv, token-stream-differ), both verified 4/4.
• Wrote all seven track documents with concept inventories, drill sets, failure modes and rubrics.
• Built and verified 5 Track B experiment scripts, the Track C envelope calculators, Track D's gpu_math.py, and the review.py spaced-repetition queue.
• Registered the track in the mdBook build and the hub.

Findings worth carrying forward:

• The agentic round is not a one-lab beta — Meta, Google and CodeSignal all ship the format. Track G is not optional.
• Reported sources disagree on the coding pass bar (2/4 vs stricter). Assume the stricter one; the error is asymmetric.
• AI-lab levelling is compressed: "L5 Senior" reportedly carries Staff scope. Every rubric in this program scores at both levels and names which one you hit.
• AI tool policy is opposite at different labs. One peer lab reportedly bans AI in live rounds entirely. Ask per company, per round.
• The textbook GIL race demo does not reproduce on modern CPython (the eval breaker is checked at backward jumps, after the STORE). Put a call between the load and the store and it loses 3–61% of updates. Measured in exp03_gil.py and folded into the answer key.

Next: the diagnostic. Then PLAN.md.

Blocked: B1–B6 above.

Build Backlog

Work on the program itself, in priority order.

Mock Scores

Weekly, from week 3. Verdicts on the hire-bar scale.

Milestone Tracker

Pre-Interview Checklist

Run this once a loop is scheduled. Not before — it is a pre-flight, not a study guide.

Per company

Per loop