Skip to content
Empire StateField Notes

The work, as it happened

Build journal.

41 build days · 214PRs shipped. Facts auto-assembled from git history; the summaries are curated. Nothing here asserts what the data doesn't show.

generated 2026-10-24 · since 2026-07-01

  1. 7 PRs

    I graded my own AI checker, then made the one Notion writer prove itself against the real thing

    I labelled 58 of my output-evaluator's verdicts myself. It agreed with me on 54 of 57, against 37 if I'd had no checker, so it now does the first pass on every public draft. Then I closed the gaps the audit had found. Every Notion write now goes through one writer that a tested validator constrains: known databases only, approved pages only, no contact details I didn't supply. CI now blocks any agent that can both read the web and write. And I cut the skill library from 278 to 189. The lesson of the day came from testing on a real scratch page: Notion silently escapes HTML comments, which would have broken every edit the design depended on. It passed review and failed on contact with the real system.

  2. A 62-minute recording became three posts, and the checkers earned their keep

    I ran the full post-event pipeline on last night's Ramp + MeritFirst talks. The recorder app turned "MeritFirst" into "Mary First", so I re-transcribed the audio with ElevenLabs Scribe, seeded with the guest list. That gave clean speaker labels and a quote bank where every quote is tagged safe to quote word for word, or paraphrase only. Then three posts and three carousels. Two independent read-only checkers caught what drafting missed: two slide paraphrases sitting inside quote marks, and a "$78M a year" figure extrapolated from one company-reported spike week, cut before it reached a draft. What's left open is mine on purpose: the recap, a surname, and the personality lines no model should fake.

  3. 1 PR

    journal: regenerate build-journal.json through 2026-10-16

    Summary not yet written — facts below.

  4. 2 PRs

    The second leak attempt changed the shape of the filter

    A cross-repo git cleanup across all five public repos: more than 30 dead branches and four stale worktrees gone, every delete of unmerged work preceded by an archive tag, and repo settings (auto-delete merged branches, no force-push or deletion on main) so the pile can't rebuild itself. The real find was underneath: talk transcripts exported from a different tool had slipped past my name-based ignore rules for the second time, so recorded speech under the event tree is now ignored by file type, and only known-good files are let back in (#207). The lesson: a privacy rule keyed on file names fails the moment the export tool changes, and a fix you have to remember isn't a fix. — Second ship: eight carousels (ElasticON, Quantum, Durable State, Revolt) and the 10-07 healthcare-territory ruling in role-radar, cut to the half the comp script didn't already hold (#194).

  5. 10 PRs

    yed 259 routing diagnostician

    Summary not yet written — facts below.

    YED-259
  6. 1 PR

    job search mission scaffold

    Summary not yet written — facts below.

  7. 2 PRs

    consolidate event content

    Summary not yet written — facts below.

  8. 7 PRs

    linkedin comment cap

    Summary not yet written — facts below.

  9. 38 PRs

    The rigor system became the work, so I cut it down

    A 30-day inventory of my own repo said something uncomfortable: roughly two of every three commits were about governing the build (judges, gates, hooks, telemetry, rules) rather than the product, and about half the agents and commands had not been used once. The systems analysis named the pattern Shifting the Burden: each gate stood in for my own call on what is good enough and what to delete, then needed that call anyway to operate, and because nothing ever removed a rule (357 governance files added all time, 15 deleted) the pile only grew. The irony is that the gate at the center was prescribed in June by an analysis that named the same archetype. So one sitting of deletion: the three-seat judge with its quorum and trust ladder became one on-demand Sonnet reviewer (YED-231, #155); telemetry moved out of git and eleven hooks became one (YED-229, #153); about 6,200 lines of unused agents, commands and duplicate skills came off the live surface, all still recoverable from git (#154); the project instructions went from 6,400 words to 1,770 (#156) and memory from about 70 files to 18; the hub's ops pages and system map are being cut to what is actually true; the event recordings got a backup. What is left is the product, stated plainly: a one-person field bureau for New York's AI scene. The lesson: a rigor system with no removal path grows until it becomes the work, so the ceiling has to be held by a person, not by one more mechanism.

    YED-103YED-193YED-196YED-197YED-208YED-229YED-230YED-231YED-233YED-248
  10. 34 PRs

    Drew the whole system, then started deleting

    Shipped the System Map — an interactive two-layer map of everything the pipeline is — and the first thing it did was make the clutter obvious. So the same day became a deletion day: the Pipeline page (a frozen May replay nobody had updated) came off the site, three workflow scaffolds that had sat unwired since May were retired because their jobs already ran elsewhere, and an audience-intelligence ticket the knowledge graph had quietly absorbed was closed. The lesson: a map earns its keep as a deletion tool — less surface means fewer things for a reader, or me, to misread. — Second ship: researched six NYC events in one batch (brief, long-form deep read and sourced graph claims for each) and rendered seven carousels. Checking the numbers against primary sources caught two stats that had drifted through secondary write-ups (47% → 44%, 78.4% → 56%); both were fixed everywhere before anything posted. — Third ship: while regenerating the map I caught it about to publish the names of my private, gitignored files. Nothing leaked; fixed at the source and at the public boundary, with CI now enforcing the check. Then the judge passed my fix and I disagreed: a flaw in the first layer of a privacy control should fail regardless of the backstop. That label dropped the voting seat below its trust bar, so the rule became arithmetic — a new rubric version where a broken privacy layer can't pass, proven by re-judging the original change from pass to flag.

    YED-104YED-149YED-157YED-198YED-199YED-205YED-210YED-217YED-218YED-223YED-224YED-227YED-228YED-231YED-232YED-235YED-236YED-237YED-47
  11. 5 PRs

    795 questions the graph can now remember

    Shipped the question half of the merge: questions are now a first-class claim, each linked to the exact topic it belongs to, and 220 Notion question banks were backfilled into the graph. Splitting the banks turned out to be the real work — four different formats, and until I looked at real rows 81 of 100 topics parsed as a single question. Proof it landed: re-running the A/B seed now surfaces the exact question the old system had won on. Zero data lost, re-runs create nothing.

    YED-217YED-218YED-221YED-222
  12. 2 PRs

    A/B verdict: the substrate does not replace the old pull — yet

    Two clean events, two blind raters: the substrate won on material (my call: "topic cards are far stronger"), the old pull won on packaging — speaker-named questions drawn from a question bank Notion had been accumulating for months. By the pre-registered rule the substrate lost, and I said so plainly rather than softening it. The real finding was that the arms are good at different things, so the work became merging them: teach the pack to aim material at named speakers, and give the graph a memory for questions. Freeze lifted; two blocked builds unblocked. — Second ship: an event's Notion namespace is single-writer, enforced. Two sessions ran the same event on 09-20 and disagreed on two facts; now whoever starts a pipeline claims the event machine-wide, a second session goes read-only, and claims expire after four hours so a crashed run cannot lock one.

    YED-172YED-213YED-218
  13. 2 PRs

    Research becomes a standing scan

    The New York AI Mafia research stopped being a one-off list: six of those companies (Runway, Modal, Profound, Taktile, Reflection AI, Hugging Face) now get picked up by every role scan, and the scanner learned a fourth job-board API to do it. Small ship, but it is the pattern: research that lives only in a doc decays, research wired into a scan compounds. Also recorded a trap for the next builder: some job boards return a clean 200 with an empty list on a wrong company slug, so "zero roles" needs a verification step before it is believed. — Second ship: The graph-write freeze protecting the A/B turned out to be a sentence in a note — nothing refused a write. Moved it to a committed marker enforced at the one place every writer passes through, after an adversarial pass found six scripts could write around the producer. The judge then caught that my first version broke the substrate's own read path, which would have handed the A/B to the old system on a bug. Fixed, verified live, and the two review passes were worth more than the build.

  14. 3 PRs

    A metric the do-nothing policy beats is not a standard

    First Monday rigor review on the new cadence caught the fourth "harness bug blamed on a model" in two days: a flag only one adapter understood was killing every Gemini control run, and the canary was booking it as the seat failing. Fixed, plus a 33-case contract test so every runner accepts the same flags, and an adapter error no longer counts as a judgement. Also codified the null-baseline rule: the "83% agreement" I had trusted for 63 days was exactly what a seat that says pass to everything would score, so every registry metric now records its do-nothing baseline and the threshold has to sit above it. The hub's citation stat was the first one repaired.

    YED-212YED-214
  15. 9 PRs

    First blind A/B of the memory layer, and a hygiene sweep

    Added a third, OpenAI-based seat to the build-quality judge and rewrote the quorum so any number of seats can sit: a seat's pass only lowers scrutiny once it has earned voting status against my own labels, any seat's doubt raises it, and a split is never auto-resolved. A pre-registered bake-off across three OpenAI models on 16 real labelled states came back with identical accuracy at a 4× price spread, so the rule written before the runs picked the cheapest. A canary runner now re-tests every seat on a schedule and demotes one that fails twice, silently swaps model, or goes stale. — Second ship: Ran the first blind comparison of the new knowledge substrate against the old Notion pull on a real event: two packs, coin-flipped labels, scored by me and an independent model seat. Also found and closed a repo problem — one finished build's telemetry existed only on this laptop, 19 merged branches were never deleted, and four sessions were writing to the same Notion pages at once. Rescued the orphan, deleted the branches, and filed the single-writer rule for shared systems so it can't recur silently.

    YED-172YED-209YED-211
  16. 16 PRs

    The review loop, reviewed

    Ran the weekly rigor review for the first time in 9 weeks and redeemed three quality checks that had been promised "next session" and never run. The judge flagged all three live skills: a removed tool still wired into a mandatory content step, a loophole in the job-search scoring rubric, and inbox rules that were decided but never applied. It also showed that the second, cross-provider judge scores almost everything a perfect 1.0. A 15-minute Monday slot now keeps the loop from going dark again. — Second ship: turned the review's findings into guardrails and cleared the backlog it exposed. A skipped quality check now has to name where its make-up run lives, and a new automated check catches files that still call tools I removed months ago (71 stale lines, now 0). Audited both public repos before leaning into building in public: no leaked secrets, but I redacted two things speakers had asked the room to keep private.

    YED-171YED-172YED-189YED-190YED-200YED-201YED-202YED-203YED-204YED-206YED-209YED-47
  17. 3 PRs

    Every open thought gets one home

    Ran the backlog reconciliation: about 170 open items scattered across Linear, notes, the roadmap and the hub, and one rule going forward, that each kind of thing has exactly one home. Decisions and parked ideas go to Linear in the same turn they are written, and the hub describes the present, with its old 'what's next' prose reduced to pointers at tickets. Several issues were killed or folded outright rather than re-filed. — Second ship: slide photos from an event now line up with the moment in the recording they were taken, using the photo timestamps and the recording's own clock; on the Postgres Tuning talk it reproduced all 11 of my hand matches exactly. The same talk became a 26-term Postgres glossary for defining jargon inline in posts, fact-checked before it landed (it caught that EXPLAIN's BUFFERS default arrived in Postgres 18, not 15). — Third ship: the knowledge store's backfill finished at 614 claims from 20 events on prod, and the first acceptance run served the Postgres talk's claims back into research.

    YED-128YED-129YED-135YED-149YED-160YED-168YED-170YED-171YED-173YED-174YED-175YED-176YED-34
  18. 3 PRs

    The inbox gets a boundary that actually runs

    The denylist that keeps personal mail out of inbox mining called itself the primary privacy control, and nothing executed it. Now one parser reads it, a filter runs on message metadata before any body is opened, and the whole-inbox scan refuses to start while the list is still a draft (#74). Then I did the review the gate was waiting on: real sending domains added for the banks, insurers and landlords the list only described in prose (the old Amex entry had missed Amex's actual sender), Ramp and Brex taken off because their events and product news are signal, and friends' personal addresses deliberately left out, since writing them into a public repo would be its own leak. Merging that review opened the gate (#75). — Also: the LeadDev NYC meetup's transcripts and visuals landed, and GTM University came off the parked list, re-aimed at a GTM-engineering role description as a benchmark rather than a pivot (#72).

  19. 3 PRs

    The write path that can't be skipped — and the judge that caught the switch

    Roadmap v2's Phase-0 gate shipped (#73): ADR-9 draws the PII boundary in three tiers — Notion may hold contact detail only when Alex supplied it, the Supabase spine holds professional-public identity and never an email or phone, the hub carries aggregates and public figures — and one module, `spine_client.py`, becomes the only way anything writes to the graph. It hard-fails: per-table allowlists, a recursive email/phone scan through metadata JSON, a denylist backstop for inbox rows, and a rule that any column may be nulled but only known ones set — which is how the one stored email was removed through the guard itself. Six copy-pasted writers folded into it; the hub got `npm run check` as its own failing guard (#16). — Second ship: the first cross-provider judge split worth having. Gemini scored the guard 1.0 across the board; Sonnet flagged it at 0.68 because `req()` shipped with a public `guard_writes=False` — a disable switch on a hard-fail guard, contradicting the docstring's own "no in-run override." Sonnet was right; the switch is gone, the writer scan now catches JS `fetch` and the doc-KB tables, and three regression tests pin all of it. The value: a leak-prevention property the code can prove, and a calibration record that shows which judge to trust.

    YED-161YED-164YED-81
  20. 12 PRs

    Back to one source of truth — and the rules so it stays that way

    Four parallel worktrees converged to main in a single day (#60–#64): the document knowledge base shipped Phase A plus A.5 retrieval hardening and the first two Phase-B stories (YED-118/156/157), the Inbox Intelligence Miner landed as a first-class market-intelligence signal source with its own ADR (YED-153), the OBS capture lane replaced the dead Granola path (YED-154), and the job-search content rulings plus a roadmap reconcile cleared a five-item decision backlog. Convergence worked on its own; what didn't was everything around it. — Second ship: the build-quality judge caught ADR-8 Increment 1 claiming a scope it had not held — a quorum split, Gemini 1.0 against Sonnet 0.55 — and the flagging seat was right. The system graph was persisting edge types nothing read, a direct violation of the ADR's own rule, and one git subprocess per artifact had put the rebuild at ~5s against a stated <2s. Fixed by deletion (0.2s, roughly 25× faster), the false "scope held" claim struck in place rather than quietly rewritten, and a --selftest added so the extractor cannot regress silently (#65). A decision record that shows its own wrong claim is worth more than one that hides it. — Third ship: the reconciliation itself. The chaos was never branches — code had self-merged unprompted — it was sessions: three Claude sessions shared the main checkout while it sat on a feature branch, each believing another one owned it, and Linear carried six shipped issues still marked Backlog. Converged from a scratch worktree with server-side PRs (the charter's quiesce-first rule could not be met, so the method routed around it), corrected Linear to git truth, retired a four-month-stale priorities block, wrote the git conventions into CLAUDE.md and the reconciliation charter into the repo, rescued five machine-local plan files that two ADRs still cited, and sharded the telemetry ledger per session so the one file every worktree appended to can never conflict again (#67, #68; YED-159). Still open: the denylist review that gates the whole-inbox scan, and ADR-7's acceptance sits in review (#69). Diagnosing it wasn't abstract — one of those sessions hit the failure live: it stashed a sibling session's uncommitted work, watched a branch tip move three times between two commands, and found the main checkout sitting on another session's feature branch. The rules got written straight off that wreckage. The value: a repo where "what's open" and "what shipped" finally agree, and the failure mode written down before it recurs. — Fourth entry, the pipeline in use rather than under construction: /check-new-events ran against the coming week and found nine events on the calendar, none carrying a PIPELINE block, so the raw-calendar fallback did the intake — Luma, Meetup and the Gmail registration receipts resolved what the invites truncated (the Notion-hosted "Context is King" webinar, Miracle Software's middleware pitch, the seven names on the LeadDev agenda, Ryan Booz of pganalyze). Dedup against Notion came back empty, the Deep Read ledger was clean, the renderer was registered: a clean start, and one calendar defect caught before it cost a missed session (the Goldcast receipt says 1pm ET; the invite said 9am). — Fifth entry, the run stopping exactly where it is designed to: nine full briefs do not fit one session — each research fan-out spends roughly 40–70 of a ~200-search cap — so the pipeline surfaced a tiering call (four in-person rooms plus the RevGenius system-of-action panel now, two vendor livestreams next session, two webinars roundup-only) and held at the Step 5 gate with the steering intake batched into the same reply. Nothing was written to Notion. Still open: the go on the tier split. The value: the human-in-the-loop design holding under a real week's load, and a hard constraint doing the prioritization the calendar never does. — Sixth entry, what the flagged build actually is: ADR-8 Increment 1 is a derived graph over the repo's own build artifacts — every skill, command, hook, ADR and the references between them — rebuilt by a stdlib-only extractor on SessionStart and Stop hooks. The point was never the graph; it was that the rigor layer had been good at recording and bad at watching, because every control was invoked (a command someone types) rather than triggered. Proof it flipped: an ordinary `git mv` on a referenced file surfaced a finding at the next session start naming all three citing sites, with nobody invoking anything. It also turned up two defects in `check-refs.sh` — the tool it generalizes, and the one feeding the judge's completeness cap: first that path templates like `evolution-log-{slug}.md` were being reported as missing files, so the cap had been firing on artifacts whose references were never broken; then that the fix over-corrected and began swallowing real broken references sharing a line with a template, which is a reference checker hiding references. Both are pinned now by the extractor's self-test, whose second assertion checks the two tools still agree — the ADR says their rules are shared verbatim, and until now that was enforced by a comment reading "change both", which cannot enforce itself. The value: the check that guards every other build finally has a check of its own (#61, #65).

    What broke · one shared checkout
    session 1session 2session 3main checkouton a feature branchstashcheckoutcommit
    The rule · a worktree per session
    session 1session 2session 3worktreeworktreeworktreemainvia PR, same hour
    The failure was never branches refusing to merge; it was three sessions sharing one checkout. A reconciliation pass stashed a sibling's uncommitted work and watched a branch tip move three times between two commands. Now each live session has its own worktree and reaches main only through a PR.
    Before · invoked
    a file is renamedsomeone runs the checknobody doesbroken refs founddrift goes unseen
    After · triggered
    a file is renamedSessionStart hookno one invokes itrebuild system graphstdlib · zero tokens≤5 findingsin the next session'scontext
    Every rigor control used to be a command someone had to remember. The system graph now rebuilds on session start and stop, so an ordinary rename surfaced at the next session start naming all three files that still cited the old path, with nobody running anything.
    9 events next week40–70 searches eachFits one ~200-searchsession?no → tier itrun now4 in-person + 1 panelnext session2 vendor livestreamsroundup only2 webinarsheld at the gateawaiting Alex's go
    Nine full briefs don't fit one session when each research fan-out spends 40–70 of a ~200-search cap. The pipeline proposed a tier split and held at its approval gate with nothing written to Notion — the constraint doing the prioritization the calendar never does.
    YED-158YED-159YED-160YED-161YED-162YED-163YED-81

  21. Rulings that had been blocking a workstream, and a rubric that stopped discriminating

    Cleared the five-item content-quality decision backlog that had left the invariants contract paused since spring: variants at 3, visual briefs mandatory, stance advisory rather than an enforced gate, and ADR-6 settling the research brief as a discrete Content Draft with the Event page carrying only the head — the dual-write was the real smell, and discrete wins because Content Drafts carry multi-Event relations, Goal/Outcome properties and clean RAG provenance that page-body text cannot. Out of it came an archetype upgrade rather than just a ruling: the two per-event posts are now one deliberate arc — pre-event table-sets macro (the topic's current state, trends, recent developments), then micro (the perspective the event description and the presenter carry), then the implications in broader context; post-event cashes that setup against what was actually said, agreed and argued, mining the brief's Pre→Post Gap. Stance-license rose low-medium to medium once it was clear the May rule predated Field Guide v2's research depth. Role-radar took v2.4 the same day — A-tier threshold 78 to 85, because at ≥78 half of everything scanned landed in A: the registry is pre-filtered to AI-native PLG companies, so roles clear 75–80 on mechanism, tier and leverage before location is even counted. Alongside, the knowledge base took its A.5 retrieval hardening (eval set v2, vendored metrics, a local reranker, a 3-arm harness) and the judge gained cross-provider evidence parity. The value: content rules that are decided and wired rather than re-debated, and a scoring tier that means something again.

    research briefone Content Draftpre-event postmacro → micro → implicationsthe eventpost-event postresolves the setupsets the tablewhat was saidPre→Post gap
    The two per-event posts became one deliberate arc. The pre-event post frames the topic without resolving it; the post-event post cashes that setup against what was actually said and argued, mining the gap the brief recorded between expectation and the room.
    documentepub · PDFchunk + embed locallysha256 deduppgvector + R2eval set v23-arm harnessquestiontop-k retrievalk = 8local rerankercited answertitle — pagewritespassagesmeasures
    Books and papers are chunked and embedded locally into pgvector, deduplicated by content hash. A question pulls the top passages, a local reranker reorders them, and the answer cites every claim to a title and page. An evaluation set and a three-arm harness measure whether each retrieval change actually helps.
    YED-118YED-156YED-157
  22. 4 PRs

    A voice rule earned from a real correction

    Codified the TABLE-SET rule into the content voice system (style guide v0.9): every event post must plainly say what this is / that it was a webinar-panel-briefing / who presented BEFORE the why and the value — context → why → value — with a matching anti-pattern row. It came from a live correction on the shipped GLM-5.3 post: the Variant C draft dove straight into the insight and lost the table-setting, so the fix hardens the lesson into the standing pipeline rather than re-catching it by hand each time. Shipped the GLM-5.3 frontier-crossing carousel (HTML → rendered 4:5 PDF) as the visual companion, and marked the YED-130 graph consolidation done in the roadmap. The value: the recurring "diving straight in" failure is now a rule the generator enforces, not a note Alex has to remember to give (#57). — Second ship: the candidate source-of-truth grew the thing the job search kept stumbling on — proof of selling technical products to technical buyers. Three roles now carry it explicitly (Meltwater's API as a data-integration sale into CRM, BI, cloud and on-prem databases and data lakes; Curalate's expansion motion of graduating clients to full custom API implementations across web, email, mobile and in-store touchpoints; Bluewolf's managed database administration and custom Salesforce consulting), plus a competency entry so every future resume and interview-prep inherits it instead of rediscovering it. The same pass hardened the ICP: a comp floor with the acceptable band explicitly not penalized, and Mid-Market at a top-tier company scoring as a full fit on mechanism — the step-back-to-step-forward move made legible to the scanner. The value: the through-line that answers the one question standing between an account-management track record and an AI-native commercial seat now lives in the source of truth, not in a single application.

    The draft that shipped
    the insightthe valuewhat was this event?
    TABLE-SET rule
    contextwhat · format · who presentedwhy it mattersthe value
    A shipped post opened on its insight and never said what the event was. The correction became a rule the generator enforces on every event post: say what it was, what format, and who presented — then why it matters, then the value.
    YED-130
  23. 1 PR

    The job search becomes a system

    Shipped Job-Search Engine v1 (Phase A+B, YED-146–152): repositioned role-radar from a generic scanner into a Target-Role ICP filter anchored on the me-model — the candidate source-of-truth authored days earlier — then ran it live end-to-end, 158 roles scored into the Notion Roles DB. Hardened the rubric from that real run: exemptions so good roles don't drop on a technicality (hybrid new+existing, PLG-primary, an intangibles lever), an IC-vs-people-management gate (does the role carry a personal book?), and a wider title keep-list that closes real misses (Sierra, Snorkel) — every exemption reasoned in Notes so it's auditable. Cross-provider quorum judged PASS (Sonnet 0.81 / Gemini 1.0), with 7 leadership roles JD-verified and demoted A→C in the same run. The value: the parallel job search stops being ad-hoc browsing and becomes an instrumented, ICP-scored pipeline that sharpens itself from its own output (#56).

    ATS boardsGreenhouse · Lever · AshbyRSS saved searchesApollo at targetscredit-gateddedupe on ATS job IDIC vs manager gatedoes the seat carry a book?score the role'smechanismfrom the JD, not the titleranked for approvalNotion Roles DB
    Role radar stopped being generic browsing. Roles from legitimate sources are deduplicated on their ATS job ID, screened for whether the seat carries its own book, and scored on what the job description says the role does rather than its title — then held for approval before anything is written.
  24. 1 PR

    Reps on the host's own stack, as the demo

    Scaffolded Signal Stream — a real-time GTM signal agent built on Confluent's own stack (Kafka + Flink ML_PREDICT + managed MCP + RAG) — as warm-up for Confluent AI Day NYC, so the prep doubles as reps on the event's stack and a working opener for the Confluent-for-Startups lead. Built in three independently-demoable layers: query a live topic in natural language → classify each stream event against the ICP into Notion → a stretch multi-agent situation room; stdlib-only, with the producer and sink tested against live data. Deliberately scaffold-only, with the fast-moving Flink AI SQL flagged in-file as needs-verifying rather than claimed working — honest about what compiles versus what's proven. The value: it turns event attendance into a demo on the room's own terms — the documentarian edge applied to a hackathon (#55). The Confluent AI Day carousel shipped alongside.

    LAYER 1 · ASK THE STREAMLAYER 2 · CLASSIFY AGAINST THE ICPLAYER 3 · SITUATION ROOM (STRETCH)natural-language querylive Kafka topicFlink ML_PREDICTflagged unverifiedNotionmulti-agent roombuilds onbuilds on
    A real-time GTM signal agent built on Confluent's own stack as prep for its AI Day, in three layers that each demo on their own. Only the producer and sink were tested against live data; the fast-moving Flink AI SQL is flagged as unverified rather than claimed working.
  25. 2 PRs

    Co-creation gets a real gate, and the content finally gets a mirror

    Split the pre-research steering interview into two touches (YED-143): a light, skippable Aim before the research fan-out, and a Sharpen gate after the brief that puts ≤3 genuine forks — derived from what the prep actually surfaced — to Alex before drafting. The insight: real co-creation comes from informed forks that only exist after the research ("the transcript leaned on X but your angle says Y — which post?"), not generic up-front prompts, so the fix was to split the intake, not move it; wired to auto-fire across five content flows. — Second ship (hub): the Content Performance dashboard, a point-in-time read of 50 LinkedIn posts answering the question under the whole post-performance thread — who does the content actually reach? It surfaced the topic→audience finding (GTM posts reach founders+GTM 54%, technical posts reach engineers 65%), visuals out-engaging text ~2.4×, and a reach≠resonance gap — and cleared the repo's pre-existing lint so the hub build goes green again. The value: the pipeline now co-creates by construction, and Alex can finally see whether the audience he's reaching is the one he's targeting (#54, hub #13).

    Before · one up-front interview
    steering interviewgeneric promptsresearchbriefdrafting
    After · two touches
    Aimlight · skippableresearchbriefSharpen gate≤3 forks it surfaceddrafting
    Real co-creation needs choices that only exist after the research, so the single up-front interview was split in two. A light Aim points the research; a Sharpen gate after the brief puts at most three genuine forks to Alex before anything is drafted.
    YED-143
  26. 5 PRs

    The gate that can't close green on a thin brief

    Turned the Deep Read from a step you could silently skip into one the run fails without. A local ledger marks each event pending at commit and rendered only on success; a fail-closed Stop hook plus an in-conversation marker re-check then fail any run that closes with an unrendered Deep Read — and, most importantly, write it to a durable failure log so a thin brief can't stay invisible the way 38 of them did on Aug 24. The prior fix (YED-138) was prose discipline an agent can skip; this is mechanical. Adversarially reviewed (four real false-green/invisibility holes found and fixed), quorum-judged PASS, DoD closed, with the residual-hardening edges logged as a follow-up rather than overclaimed. — Second ship: a pronoun-fidelity rule in the brief renderer — never infer a person's pronouns from their name, default they/them until a source confirms — after it silently misgendered a real speaker from their name. Small rule, but it stops a real person being mislabeled in content Alex may tag them in; the parallel name-fidelity fix also got its long-pending validation cleared in the same render.

    ledger row: pendingset at Scan-head commitDeep Read rendersuccess → renderedPending at Stop?block closere-run or waiverun closes greenyesnone
    A thin brief can no longer close green. Each touched event gets a ledger row marked pending when its Scan head commits, and only a successful render flips it. At stop, any pending or unreadable row blocks the close; if it still can't be resolved, a durable FAILED row is written — the invisibility that let 38 thin briefs through on Aug 24.
    YED-138YED-139YED-140YED-142
  27. 1 PR

    A better brief and a truer voice

    Wired the research brief v2: one artifact with a phone-glanceable Scan head in the room, and a deep, cited, novice-friendly prose “commute read” rendered afterward and appended without ever blocking the pipeline. The old output had regressed to a machine-readable bullet lattice; this restores flowing analysis and adds a historical spine, inline-defined jargon, and end-to-end source citations. The value is a briefing worth reading on the train that walks Alex into a room genuinely conversant — and a richer substrate every downstream post draws from. — Second ship of the day: the audience-first ethos went from charter to production (YED-103). The north-star document existed but no content skill actually read it, so posts kept drifting back to self-as-protagonist; this wired it into the six content surfaces and codified the “ordering, not erasure” counterweight (so “decenter yourself” stops collapsing into self-erasure that reads junior to a buyer), the three floors, a softened voice rule, and a mandatory 3–5 “learn more” citation set on every post. The value: the pipeline now generates audience-first content by construction, not just on paper — shipped, judged pass cross-provider, DoD closed. — Third ship: the brief-v2 wiring finally got its live end-to-end acceptance test, which last session's frozen agent registry made impossible. Ran the whole pipeline on a real event (Elastic NYC × Plural) — four specialists, synthesizer, five Notion writes, then the Deep Read rendered section-by-section on Opus and appended decoupled. The render cleared the Daytona spike bar and closed its one open gap: endnotes now carry real source URLs end to end (specialist ledger → synthesizer evidence set → renderer), quorum-judged PASS (Sonnet 0.896 / Gemini 1.0). It also caught a genuine renderer bug — confabulated speaker first names in the sections where the speakers were only passing references — corrected in-run and then hardened out of the spec so the standing pipeline reproduces names verbatim. Decoupling held: the Scan head and every entity record committed independently of the render. The value: brief-v2 is proven in production rather than merely wired, with the one real defect found and fixed before merge (#47).

    synthesizerScan headphone-glanceableEvidence SetURLs per sectionfield-guide-rendererOpus · per section → stitchContent DraftNotionDeep Readcited prosecommits firstappended later
    The brief became one artifact in two layers. The Scan head commits to Notion immediately; the Evidence Set feeds an Opus renderer that writes the cited Deep Read section by section and appends it afterward, so a failed render never blocks the pipeline.
    YED-103YED-119YED-136
  28. 1 PR

    Closing a decision that was already made

    Two lines in the roadmap still called the database consolidation undecided three days after it shipped. A small fix with a real reason: plan text that contradicts the decision records and Linear invites someone, me included, to re-argue a settled call. The one loose end, shutting down the old database, got its own ticket (YED-135) instead of staying buried inside a closed one (#46).

    YED-130YED-135
  29. 3 PRs

    Corrections that reach the post, and a carousel that renders itself

    The RevGenius run exposed a seam: a fact the research pass had corrected could still reach the published post, because the correction lived in a side document while the content step read the original brief. Now a re-run updates the brief in place with an audit note, and the content step builds a do-not-assert list from every flagged or unverified claim; each one is dropped, attributed to a primary source, or softened to my own observation (#44). — Second ship: carousel export is now automatic, HTML straight to a 4:5 PDF through headless Chrome, which removes the last manual print-dialog step from publishing; verified on the RevGenius carousel (#45). — Third ship: the decision records behind the data consolidation moved from a loose folder into the repo, with a short playbook for changing a live system safely, so the next session finds the reasons before re-arguing the decision (#43).

  30. 2 PRs

    Research that starts from what I already know

    Added a step to the front of event research that pulls what the system already knows (prior briefs, Notion records, Gmail, the graph) and distills it into a sourced pack before any web search runs. The trigger was a run that made 98 web searches and zero reads of its own history while claiming continuity from memory. Everything prior is tagged known, stale or unverified and treated as a lead to re-confirm, not a fact to repeat (#41). — Same-day hardening: the 'pull at most eight' limit had only been a sentence in a doc, so it became a fixed procedure with an audit line that proves it ran, and a slow or empty graph now gets noted and skipped instead of stalling the run (#42).

    triage plandrop entities with noprior recordresearched fresh insteadrank by fixed priorityseries brief firstpull the top 8the rest: on demandaudit linemissing = cap never ranknowledge-conditioningKNOWN · STALE · UNVERIFIEDPrior-Context Packfeeds the fan-out
    Research compounds instead of restarting from web search. Before the fan-out the run pulls what the pipeline already knows — only for entities with a prior record, ranked by fixed priority and capped at eight, with an audit line that proves the cap ran. Each fact is tagged known, stale, or unverified, and nothing stale reaches the brief as fact.
  31. 2 PRs

    One graph instead of two

    Consolidated the market-intelligence data onto a single database: the trend signals from my GTM project and the 59 in-person events from this pipeline now live in one graph, with topic intelligence recomputed on the combined data (76 events, 449 event-to-entity links). The cutover was rehearsed end to end on a test database first, including an independent recompute that had to agree row for row, a 1.6-second swap and an exact 1.25-second rollback, and the production run still caught a bug the rehearsal had not (market events weren't being carried over), fixed before the swap (#39, YED-130). The hub's market-intel page was filtered ahead of time so in-person events would not show up as market signals (hub #12). The old database stays up until a few nights of watching say it is safe to retire.

    build canonical_v2public stays read-onlyinvariants + referenceimplementationProven on a test DB,incl. rollback?atomic swaphubs + pipeline repointnothing touches prodyesno
    The graph consolidation never changes data in place. The new model is built in a parallel schema while the live one stays read-only, validated against invariants and a fresh reference implementation, and cut over by an atomic swap — and nothing runs on production until the whole sequence, rollback included, has passed on a test copy.
    YED-130
  32. 17 PRs

    The portfolio starts maintaining itself

    Shipped the self-instrumenting build journal — a generator that assembles each build day's facts from git and telemetry, a human-owned prose sidecar, a /journal page on the hub, and a Stop hook that regenerates it automatically. Also restructured the build arcs into foundation-anchored themes and made one canonical JSON the single source for both the hub page and the shareable artifact. The portfolio now documents itself, and two surfaces can no longer drift apart.

    git historybuild telemetryprose sidecarhuman-ownedbuild_journal.pyzero tokensEntries changed?build-journal.jsoncommitted by a humanyes · adopt
    The journal assembles itself. On every session stop a script rebuilds each day's facts from git and telemetry and merges in the human-written prose. The hub's file is replaced only when the entries actually changed, and committing it stays a human step.
    Before · two hand-edited copies
    an edithub page copyArtifact copydrifts
    After · one canonical file
    build-arcs.json/build-arcs pageArtifactregenerated
    Build-arc copy lived in two hand-edited places that drifted apart. One JSON file now feeds both the hub page and the shareable Artifact, so an edit lands in both or neither.
    YED-106YED-119YED-124YED-130
  33. 8 PRs

    The build-arcs surface + the first live intelligence run

    Shipped the public Build Arcs page (3 → 13 arcs, themed) and a shareable artifact, so a month of work is legible to a hiring manager at a glance. Ran the progressive market-intelligence engine live for the first time — seven cited signals, a new topic, a recomputed viewpoint — entirely on subscription, zero API tokens. The portfolio now shows an instrumented system that documents and re-ranks itself, not just claims it does.

    Delta pullonly since last runNormalize + matchbefore createAppend signalsnever deletedRecompute relevance0 tokensReportFarmed · Added · Cooledmanual trigger, dailynew onlyranked
    Each run appends what's new and re-derives every topic's ranking from the full history, with a 14-day half-life. Nothing is wiped: a topic with no new signal is reported as Cooled, not removed.
    YED-115YED-119YED-121
  34. 1 PR

    Branch-first discipline, promoted to canonical

    Landed the governed batch: branch-first git discipline and a hook-schema reference, promoted into the cross-project canonical config, plus the hub's build-in-public content (changelog + candid README). Enforced in a hook rather than left to habit, so the right change-management path is the default in every project, not a thing to remember. Makes disciplined, reviewable change the paved road.

    git commitBuild surface on main?refusedpre-commit hookbranch → PR → mergelands on maintelemetry · contentyesno
    The hook decides by what changed, not by who is committing: skills, commands, and schemas can't be committed straight to main, while telemetry and content churn still land directly so the guardrail doesn't tax small work.
    YED-112
  35. 2 PRs

    Promoting the proven primitives

    Swept the strongest Empire State primitives — the toolbox skill, the PostHog/Vercel and hook-schema references — into the personal plugin via governed PRs, and added a toolbox/counts generator so the build-in-public surface can't drift from reality. Validate locally, promote deliberately. Every future project now inherits accumulated discipline automatically.

    Empire Stateproves a primitivegoverned PR+ Linear issueuser-scope pluginskills · agents · commandscross-projectinvariantsLinear-as-truth · branch-firstevery new projectvalidated locallypromoteinherited at open
    A primitive is proven inside one project first, then promoted to the user-scope plugin through a PR with an issue behind it. Every project opened afterward inherits it instead of re-learning it.
    .claude/ frontmatterskills · agents · commandspnpm gen:toolboxtoolbox.jsoncounts + cataloghome page stats/architecture counts/ops/toolboxscanswrites
    The counts on this site aren't typed by hand. A generator scans the live skill, agent, and command files and writes one JSON file that every page reads, so the numbers can't drift from what actually exists.
  36. 2 PRs

    A dedicated telemetry project

    Repointed build-rigor telemetry to its own PostHog project so build signal isn't mixed with product analytics, with read and write keys split by scope. Observability for the delivery system deserves the same rigor as the product. Clean, trustworthy build telemetry the hub can read honestly.

    build hooksMI producersPostHog projectbuild telemetry onlyMI graphSupabase/ops/rigor/ops/market-intelwrite keyread key
    Build telemetry moved to its own PostHog project so delivery signal never mixes with product analytics, with write and read keys split by scope. Each /ops surface reads exactly one system.
  37. 1 PR

    Two judges, and a check that doesn't need one

    The build-quality judge became a two-seat panel by default: a Claude seat that knows the house rules and a Gemini seat that doesn't, merged into one verdict, with any disagreement coming to me rather than to a third model. The same PR turned the dangling-reference rule (a file citing a path that no longer exists) from something the models were asked to notice into a script that checks it deterministically. The panel's first run was on that script itself, and the seats disagreed: the house-aware seat caught two real bugs that both the other seat and I had missed, which is the whole case for a second opinion (#18, YED-109).

  38. The cross-provider judge

    Wired a second, cross-provider judge (Gemini alongside Sonnet) into the build-quality gate and mechanized the dangling-reference check. An LLM grading its own model family self-prefers; a different provider is the cheapest robust mitigation. Build quality now gets an independent, adversarial second opinion instead of a rubber stamp.

    SAME RUBRICartifactmechanized checksdangling refs · skeletonClaude seatSonnetGemini seatProAgree?auto passseats agreeAlex breaks the tiesplit · interactivefail-safe FLAGsplit · autonomous
    Two model families score every build against one versioned rubric. Agreement passes; a split escalates to Alex, or becomes a non-destructive FLAG when he isn't present — a disputing model never gets to break its own tie.
    YED-109

  39. Closing the rigor loop + judge calibration

    Calibrated the judge against a human anchor — crossing the trust gate to provisional-trusted — and wired the missing writer so DoD telemetry fields stop coming back null. Rigor that isn't written to the execution path decays silently. Rigor became measurable where the work actually happens, not in an optional doc.

    judge scores a buildAlex agrees ordisagreesone ack per run≥20 runs at ≥80%agreement?provisional-trustedgates independent buildsstays advisoryyesnot yet
    The judge had to earn trust against a human anchor before its verdict could gate anything: at least 20 runs agreeing with Alex 80% of the time or better. Even then it stays advisory on work it helped produce, and never hard-blocks. The same pass wired the writer that stopped DoD telemetry fields coming back null.

  40. The command-orchestration convention

    Authored the required command skeleton (intake → dispatch → collect → synthesize → named output) after a thin, declarative command failed the quality bar, and ran live LLM-as-judge execution. A command that only lists agents without dispatch/output logic isn't done. Commands now meet a completeness standard the judge can enforce.

    Declarative · failed the bar
    command filelists its agentsno dispatch, no output
    Required skeleton
    intakedispatchcollectsynthesizenamed output
    A command that only named its agents did nothing when it ran. Every command now follows one skeleton — intake, dispatch, collect, synthesize, and a named output — and the judge checks for it mechanically.
  41. 1 PR

    Rigor loop close + drift cleanup

    Closed the first pass of the rigor loop and fixed confirmed documentation drift across the project config. Source-of-truth docs that lie are worse than none. The running system and its documentation agree again.

    Before · rigor in optional docs
    buildgreen checksrigor docsskippableshipno traceoptional
    After · in the execution path
    buildjudge quorumadvisoryDoD gatemet or waived + reasonStop hookbuild_session rowHub /ops/rigor
    The diagnosed failure was structural: rigor lived in documents a memory-less agent could skip, so builds shipped on green checks and left no trace. The fix puts each check in the path every build already runs through.

Regenerated by build_journal.py — git history in, curated prose merged, zero API tokens. This is the honest V1; a fuller voice comes later.