window 2026-04-23 → 2026-09-16 commits 211 status reports 85 revisions mode paper-trading · zero live capital

From empty repository to a six-market production fleet — run like a program, documented like an audit

A project-management case study. One person owned scope, schedule, risk, and quality for an autonomous market-making system — and directed an AI engineering agent as the delivery resource. Every claim on this page traces to a git commit or a document in the project repository.

977automated tests
6markets live in prod
19risk invariants pinned
11/11alerts live-fire proven
28research documents
8incident runbooks

§1 · The project

What was built, and under what constraints

The product: an automated market-making system for a prediction-market venue (Polymarket) — live market-data feeds, a quoting strategy, a risk layer with a hardware-style kill path, a paper-trading simulator, cloud deployment, full observability, and a market-discovery scanner. It runs today as six concurrent instances plus a scanner on AWS, quoting real order books with simulated capital.

The constraints: a single owner with finite session time; a domain where silent failure costs money (the north-star requirement was written into the project charter: survive venue misbehavior without silent degradation); and a delivery resource — an AI engineering agent — that is tireless, fast, and confidently wrong just often enough that nothing it reports can be accepted without evidence. That last constraint shaped the entire management system.

The delivery model: managing an AI engineering resource

This project treats AI-assisted delivery as a management problem, and the controls look like classic project controls because they are:

  1. Separation of duties. The agent writes the test suite; the human types the production implementation from a reviewed listing. Every line of production code passes through two sets of eyes by construction, and hand-typing surfaced real bug classes that reading never would (14 transcription bugs in one session — 10 of them inside strings, invisible to the type checker, caught by behavioral tests).
  2. Verification before claims. "Done" requires command output. This rule later caught a production instance running 43 hours of stale code under a deploy record that said "deployed + verified."
  3. A mandatory end-of-session knowledge sweep. Every lesson is routed to all of its audiences — analysis notes (why it happened), runbooks (what to type at 2 a.m.), layer guides (what the next implementer must not reintroduce), and where possible, code (validators and lints — the only home that doesn't rely on anyone reading).
  4. Cold-start reading lists. Each session begins from a written handoff, not from memory. The one session that skipped the list inherited a day of stale assumptions — and that incident is itself now in the record.

§2 · The management system

Five mechanisms, each with a paper trail

Stage-gate ladder

Six rungs from "collect data" to "multi-venue scale," with an anti-drift rule: no rung starts before the previous one's evidence exists. Scope pressure gets answered with the ladder, not debate.

source: project charter, north-star §
Gate-tagged roadmap

Every roadmap item closes with a commit hash and date written inline — [x] 9a5e33e 2026-07-08. Completion is a pointer into git history, never a memory.

source: implementation-roadmap.md
Decision register with triggers

Deferring a decision is allowed only with a named re-review trigger ("Gate: first calibration that needs adjusted-mid precision"). Vague deadlines rot; triggers fire.

source: deferred-decisions.md, 11 sections
Living status report

One handoff document, revised 85 times, holds the current state, the ordered next actions, and the operational quick-reference. Any session — or any successor — can cold-start from it.

source: Handoff_Prompt.md git history
Primary-source verification

External-system claims must cite a verified document or a source fetched that session. This discipline overturned four design assumptions in a single verification pass — before they became code.

source: docs/notes/*-verified.md (7 documents)

§3 · Timeline

Twenty-one weeks, eight phases

Click a phase to expand its record.

APRResearch & architectureexpand

Domain research reports, an authoritative architecture document, and — as important — the working conventions: test-driven development, the separation-of-duties rule, the decision register, and two-pass design walkthroughs. The management system was designed before the system was.

MAYData backboneexpand

Market-data ingestion (websocket feeds with watchdogs and fail-loud semantics), storage, and observability scaffolding. The feeds layer closed with a five-phase completion review rather than a smoke test — a pattern repeated at every layer boundary.

JUNStrategy, simulator & the risk layerexpand

The quoting strategy, a paper-trading simulator, and a time-semantics audit that produced nine findings before they became production bugs. Then the centerpiece: a seven-phase risk layer — inventory caps, drawdown controls, infrastructure health gates, a circuit breaker, and an OS-thread watchdog — delivered in twelve days with all 19 safety invariants pinned by tests.

  • Suite grew past 600 tests; risk phases 1–7 shipped Jun 18–29 with per-phase design records.
JUL 05Production launch (paper)expand

Deployed to AWS under systemd. Launch week surfaced four bugs the 700-test green suite had missed — an empty runtime registry, no graceful shutdown, a config gap, a data-capture overwrite. All four were fixed with regression tests the same week, and the lesson ("live operation is a verification layer, not a victory lap") entered the record.

JUL 14The M1 crisis — and the calibration milestoneexpand

The quoted market died overnight (its underlying event resolved); the bot went down for 18 hours and nothing paged, because alerting didn't exist yet. The milestone review that followed found something bigger: a configuration parameter was 20× too aggressive, silently zeroing earnings for ~85% of the collection window. The response was textbook: root-cause memo, fleet retune, relaunch on a longer-lived market, and alerting promoted to the next milestone.

  • Deliverable: the M1 calibration memo — findings numbered, each with a corrective action and owner.
JUL 18–31Observability, hardening, fleet ×6expand

Dashboards and alerting shipped as code (Prometheus + Grafana, provisioned from the repo), then every alert rule was deliberately live-fired to a pager — no rule is trusted until it has actually paged. A pre-registered data-quality discriminator caught a subtle feed bug (crossed order books) that had two root causes; both were fixed with regression tests. A stale-process incident produced the project's most durable rule: a deploy isn't deployed until the running process proves it — enforced afterward by a build-version gauge in code. The fleet expanded from one market to six.

AUGUnattended operationexpand

Three commits all month — by design. The fleet ran alone while management shifted to operational review. The multi-week review found that reward pools oscillate violently (vindicating the register's "no retirement without multi-day dwell evidence" rule — a snapshot-based call would have retired the fleet's largest earner right before it recovered) and that crash-restarts wiped simulated position state, which became the next quarter's first fix.

SEPScale machinery & the evidence-driven pivotexpand

Position persistence closed the crash-wipe gap. Two primary-source verification passes (fees, venue APIs) overturned four design assumptions before implementation. A market-discovery scanner was built and censused 16,954 funded markets on its first production-scale run. Then the payoff: when a scheduled market swap collided with a same-day market resolution, a depth-based ranking — run ahead of schedule — showed the staged replacement plan was no longer viable and that the competitive landscape had shifted fleet-wide. The swap was re-decided on fresh evidence and deployed the same day with zero downtime for the remaining fleet.

§4 · The numbers

Three views of the record

Automated test suite over time

tests passing at each pinned count · Jun 28 – Sep 15, 2026

Counts as recorded in commit messages at each milestone. The suite is a delivery gate: no session closes red. Flat stretch in August = unattended-operation phase.

Commits per month

211 total · the shape of a phased delivery

August's near-silence is the point: the system ran unattended while management shifted to operational reviews. September is lean because sessions grew larger, not slower.

Documented defects & findings, by the layer that caught them

layered verification: each net catches what the others miss

Conservative counts from session records. The tail matters most: the four found by data forensics — including a mis-calibration silently zeroing revenue — were invisible to every earlier layer.

§5 · Exhibits

The artifacts themselves

Excerpts from the project's real management documents, lightly condensed.

Milestone schedule with completion evidence

excerpt · docs/implementation-roadmap.md · convention: an item is closed by writing its commit hash inline

ItemScopeGate evidenceStatus
Risk layer P1–P719 safety invariants, kill path, watchdog75eb023 · 2026-06-29SHIPPED
Production launchAWS + systemd, first paper market2026-07-05SHIPPED
S1 replay fixhard edge: must land before calibration9a5e33e · 2026-07-08SHIPPED
S2 telemetry14 metric families, liveness-awareb92a499 · 2026-07-10SHIPPED
S4 dashboards + alertingprovisioned as code; rules live-fired539828d · 2026-07-18SHIPPED
S7 alert test-fireevery rule proven to page, on schedule2026-07-30SHIPPED
S9b position persistencecrash-wipe fix; gated before calibration2026-09-10SHIPPED
S12 scanner phase 1b16,954-market census, first ranking88b5b52 · 2026-09-15SHIPPED
S13 alert dispatch + depthmakes rankings depth-real, pages humans—NEXT

§6 · What the record demonstrates

PM competencies, with receipts

CompetencyWhere the record shows it
Scope & schedule controlStage-gate ladder + gate-tagged roadmap; an attractive new revenue line parked mid-session because it sat on the wrong rung — and stayed parked
Risk management19 test-pinned safety invariants; a decision register where every deferral carries a trigger; alert rules proven by live fire, not by review
Quality managementLayered verification (tests → smoke → production → forensics), each layer's catches counted; no session closes with a red suite
Incident managementEvery incident closed with a postmortem, and every lesson routed to at least three audiences — including code, the only audience that never forgets to read
Evidence-based decisionsTwo major pivots (market strategy, replacement plan) executed on same-day data that contradicted the staged plan; the dwell rule that prevented a wrong retirement
Communication & continuity85 revisions of a self-perpetuating status report; cold-start reading lists; 28 research documents that cite primary sources
Managing AI-augmented deliverySeparation of duties, verification-before-claims, and knowledge routing — controls designed for a resource that is fast, tireless, and requires audit

§7 · Retrospective

An honest accounting

What worked
  • Gates over intentions. Writing the commit hash into the roadmap made "done" unarguable and made the schedule auditable months later.
  • Triggers over deadlines. Deferred decisions came back exactly when their evidence arrived — including one that saved the fleet's biggest revenue source from a premature cut.
  • Live-firing the alerts. Every rule was made to actually page before it was trusted. Two real delivery defects in the paging channel were found this way.
  • Routing lessons to code. The most repeated failure classes ended as startup validators and lint rules — the one place a lesson can't be skipped by not reading it.
What I'd do differently
  • Alerting shipped after the first silent 18-hour outage, not before launch. It should have been a launch gate. The record shows exactly what that ordering cost.
  • One alerting gap took three occurrences to close. The pattern (fast crash-loops invisible to an uptime check) was named on occurrence one; the fix was gated too patiently.
  • The single most decision-relevant metric arrived late. Competitive depth per market — the number that reranks everything — wasn't measured until month five. Two market picks would have gone differently.
  • Session discipline is only as good as its worst session. The one cold-start checklist skip produced a day of work on stale assumptions. Checklists need teeth, even for the person who wrote them.