181 sessions · peak 63/day
A first-principles review found Command bloated, and the controller that ran it gave way to a plain board of work items.
- shipped: built, merged, verified
- in progress
- designed, not proven: machinery exists, no real result yet
No entries for the selected day(s). The chart counts sessions; not every day has a featured entry.
Project: Command
142 sessions in this report · active 7/7 days
Watches all ~65 of my projects and keeps their Claude Code setups optimized and running cleanly: surfacing CI failures, stale or unpushed work, and config drift, and proposing the fix from one seat. proof caseBefore a fix runs, Command commits its exact success metric and target to git, so the bar cannot move afterward to fit the result. false-provingA measure reporting success from random noise alone. Caught and bounded before the measure is trusted on a real case.
during this weekReplaced the controller and its managers with a board of work items and a dispatcher that runs no model, then spent the rest of the week building on that board through dispatched workers.
archivePut the Owner’s open questions first on the board, and made publishing wait for an explicit yes
A worker relaunched after the Owner answered its question used to get its original packet with no trace of the answer, so it could only ask again. The packet now carries that answer, and the walk through open questions starts with work blocked on the Owner; both merged. The board’s publish check was also found to treat any reply outside a short list of refusals, even “not yet”, as permission to deploy the site, and a fix accepting only an explicit yes was built alongside goal-by-goal status and on-screen notices for new questions, all waiting on review.
goal Build an always-aware autonomous operator that runs my standing goals with minimal hand-holdingExtended the board to chats I start myself, not only dispatched workers
Once the controller was gone, side chats had no way to stay in step with the board, and three jobs it had quietly done had no owner. Board workers let any session claim, orient on, and release board work, captured ideas and steers from ordinary chats as board entries, scoped the board’s view to the folder a chat runs in, and added a short board-sync paragraph to the kernel every session loads. During a live test the dispatcher expired the builder’s own lease while it waited on idle timers, and it handed its committed branch to a successor.
goal Build an always-aware autonomous operator that runs my standing goals with minimal hand-holdingWeekly scouting and fleet checks ran unattended
The contest rescan found no qualifying open event and disqualified listings the search layer had wrongly shown as current, and the runway check found both of its triggers still green. The weekly worktree sweep removed what it could prove safe but found that more than half of the leftover worktrees could never be cleaned automatically, which is why that backlog had stopped falling, and it filed that question for the Owner.
goal Keep a live status picture across all my projectsMoved the knowledge base’s dead pages into an archive and taught its lint to guard it
Pages for retired projects and dropped ideas sat alongside live ones in the knowledge base. Board workers moved them into archive folders, repointed the living documents that linked to their old paths, and answered review findings about links from outside the base, while new lint rules check that archived pages are marked as such and filed where they belong. Both changes were built and waiting on review.
goal Make my operator's behavior reliably evolvable through skills and durable rulesChecked the Owner’s recorded requests against what the board actually built
A study pulled the Owner’s own asks from the chat record, verified each quote against its transcript, and sorted the asks by whether the board covers them, covers them partly, misses them, or has superseded them. It set down its method before judging anything, and review pushed it to apply its stated filter on the Codex corpus for real and to separate superseded asks from replaced ones before it merged.
goal Build a signal engine that turns my own chat history into targeted improvementsBuilt a sender that posts to a team chat channel only through the board
The operator needed one checked route for posts to a team chat channel. A board worker built a sender that keeps the credential out of the command line, and a later round moved the posting itself into the dispatcher so each post goes out once, carries the Owner’s literal word, and is safe to retry. A worker asked to send a real post stopped instead, because the sender had not reached the main branch yet.
goal Build an always-aware autonomous operator that runs my standing goals with minimal hand-holdingBrought Codex onto the board as an independent reviewer and as a worker
A board worker added a review step that checks out a pull request in a throwaway worktree and asks Codex for a verdict in a read-only sandbox with a fixed answer format, recording only a well-formed answer, and its first live run returned real findings on a sibling’s pull request. Other workers gave the dispatcher a completion step for Codex workers and let it load each repository’s secrets into the workers it launches, with a test proving no value reaches its logs. All three were built and waiting on review.
goal Make my operator's behavior reliably evolvable through skills and durable rulesTaught the dispatcher to treat a fleet-wide stall as an outage, not a reason to relaunch
When usage credits ran out overnight, every worker paused at once, and the dispatcher, which needs no credits, kept expiring and relaunching them for hours, each launch ending before it could do anything. The board now escalates an item after two unclaimed returns, and when every lease goes stale in the same firing it holds all launches and raises one notice until work resumes. A shorter run of empty relaunches still happened when a usage limit hit again the next evening.
goal Make my operator's actions context-aware instead of one-size-fits-allReplaced the controller and its manager chain with a board and a dispatcher that runs no model
The review’s answer was to subtract. The standing controller and its rotating managers gave way to a board: one folder of small per-item files written through a single command, hooks that hold each worker to its own lease, and a ten-minute dispatcher with no model in it that launches workers into their own worktrees. Skills to read the board and walk the Owner’s open questions one at a time landed the same day, and the old office’s record audits were switched off so code could merge again.
goal Build an always-aware autonomous operator that runs my standing goals with minimal hand-holdingTrimmed the always-loaded kernel under a written rule for what may be pruned
Every session loads the operator’s kernel file, so its size is paid on every start. A board worker removed a paragraph that only described what a hook already prints at the moment its rule binds, roughly doubling the room left under the size budget, and recorded its reasoning line by line. The first attempt parked on a test that pins the file’s size to a table in another document, and a later attempt moved both together.
goal Make my operator's behavior reliably evolvable through skills and durable rulesAsked from first principles whether Command had grown bloated, and found that it had
A review I started outside the operator’s own routines measured a week of its Claude Code and Codex sessions and confirmed the hunch that it had become bloated. It rechecked its own numbers and corrected the ones that failed, sketched how Command would look rebuilt from scratch, audited that design against current platform documentation and published research, and drafted requirements from my own recorded friction. Command development was paused that evening while the design was decided.
goal Mine my own chat history for the methods that actually improve resultsThe desk heartbeat kept watch between shifts and retracted its own false alarms
Every couple of hours the heartbeat reaped a lease left behind by a dead manager, woke managers when a gate opened, and found the main checkout’s dependency folder empty, which had left every gate unable to run, and restored it. Several of its capacity alarms were wrong: it counted from stale records, read a waiting session as stalled, and queried the wrong repository, and each was retracted after checking the evidence directly. One firing was suspended by the machine for over a day and re-read current state before acting.
goal Keep a live status picture across all my projectsThe remediation loop proved a queue item fixed but could not close it
The unattended remediation loop closed stale items that were already fixed on main and opened a fix for a status board that showed delivered workers as never started. One item it verified as resolved, a startup cost an earlier change had cut sharply, came back firing after firing because its executor may only list and view issues, so the close could never be posted. The loop recorded that as the wrong layer to fix it at, left the close comment ready for a person, and halted itself once Command development was paused.
goal Operate that signal engine and measurably cut my own recurring frictionNightly shifts ran monitor-only while the daily letter stayed switched off
Each night the ops shift clocked in, ran its self-checks, and clocked out well inside its time limit, filing an Owner decision only when a finding was new: whether to bring back the paused daily letter or name another place for the nightly report. It also caught its own record store truncating long fields. Each run of the daily letter stopped at the Owner’s off switch, as it should.
goal Keep a live status picture across all my projectsTook the operator’s desk over from Codex without losing its open work
At my request, a Claude session took over the controller role, the manager, and every open thread the Codex side had been carrying, confirming the old desk had clocked out before claiming it and adopting its open launch records. It aimed to keep four worker sessions busy at once. A regression alarm raised overnight from single cached test runs was retracted once repeated runs showed the variance.
goal Make my operator's actions context-aware instead of one-size-fits-allMade a finishing worker report itself to its manager instead of waiting to be noticed
A manager only learned a worker had finished when the periodic heartbeat happened to look, so finished work could sit unnoticed for up to two hours. A background session now reports to its manager once when it finishes, stalls, is held, or disappears. The change was split so the Owner signed only the small part that touches a hook, and the Claude heartbeat now drains these reports as the Codex one already did.
goal Keep a live status picture across all my projectsBuilt a hook to pin the operator’s procedures after finding they faded once a long session was compacted
A manager’s checkpoint found the controller had gone a long session without once reading its own playbook, and that the Codex side almost never loaded it either. Its hard safety rules held throughout while the procedures behind a pointer did not, which matched published research on rules decaying after context compaction. The hook that puts them back in front of every turn merged on the Owner’s explicit word, since it edits a hook, but its list of pinned rules shipped empty, left for a session that has read the playbook to fill.
goal Make my operator's behavior reliably evolvable through skills and durable rulesSent three pull requests through repeated rounds of independent review before they merged
Separate reviewer sessions each checked a pull request at a pinned commit and posted a signed verdict, holding them for fixes over several rounds before clearing all three. The merged changes make page QA check the render that actually ships, fail the page gate when a dispatched page has no launch record, and tell the feedback skill what to do when its tools are missing. One reviewer caught a message meant for a different session that shared its target, which became a rule never to address a session by its display name.
goal Make my operator's behavior reliably evolvable through skills and durable rulesGot a stalled manager handover moving, then waited out a CI stoppage
The successor manager could not start because the scheduled launcher its handover named had never been created, which the heartbeat reported for several firings running. Once it was up, it ran four workers whose pull requests all stalled when GitHub refused to start CI jobs on the account. After that cleared the queue began to drain, a rule requiring guard changes to prove their tests can fail merged the next day, and a follow-up spend check found no further refusals.
goal Make my operator's actions context-aware instead of one-size-fits-allStopped the nightly knowledge digest flagging staleness its own run caused
The nightly digest edits knowledge pages and only then checks whether the overview page has fallen behind them, so its own ingest tripped that check every night. The check now sets aside pages the same run wrote. Of the week’s digest runs, one merged after an independent review, a later one is still open for review, and one was blocked; none approved its own work.
goal Make my operator's behavior reliably evolvable through skills and durable rulesSized CI to the change, then had pull requests run only the tests a change touches
CI was split into lanes sized to the change, which merged at the start of the week. Board workers then built a router that picks the tests related to the changed files, fixed a bug that would have turned every pull-request gate red, measured the cost on real commits, and added a probe proving a new test file gets selected. That second step was built and waiting on review.
goal Make my operator's behavior reliably evolvable through skills and durable rules Project: claude-global-skills
active 1/7 days
My machine-wide Claude tooling, version-controlled behind a privacy guard so the automation that touches every project stays clean and auditable.
during this weekPruned the instructions and skills every session loads, and captured the live skill copies back into the repository.
archiveSettled on a point-first reply style and pruned the instructions every session loads
A search of my own chat history across Claude and Codex produced a reply style that puts the next action or the direct answer first, and it is now the default everywhere. An inventory of every global instruction, skill, hook, and scheduled task then scored each on whether it still earns its place, and the cleanup backed up and logged every step, cutting the scheduled tasks to fewer than half and retiring unused skills. The captured skill copies went through review, which caught personal paths before a public merge.
goal Maintain and grow an open-source library of Claude skills and hooks Project: DemandForge
2 sessions in this report · active 2/7 days
A category-authority research engine: it earns trust by producing original, sourced research for a product category, then points that trust at products. The machine does the labor; I approve in about fifteen minutes a day.
during this weekRead the pre-registered crawl result as a negative, and mapped a new marketing design against the book it follows, with each departure waiting on a ruling.
archiveMapped a new marketing design against the book it follows, and listed where it departs
I wanted a fresh affiliate marketing campaign that follows a marketing book closely. The work drew an architecture diagram of the proposed system from its code, had a fresh session review it for accuracy, found the book’s companion guide has no procedure for choosing a niche, and published a ledger of every design choice that departs from the book, with the book’s own position and a recommendation for each, now waiting on my rulings. Settling open points from the book itself proved expensive, which is where the standing rule to spend tokens frugally came from.
Read the pre-registered crawl result: requesting indexing was not enough
A month earlier I had requested indexing for two pages search had never crawled, and fixed in advance the date to read the outcome. On that date one page had still never been fetched and the other had only been recrawled on routine, so the request was not sufficient. A check across untreated pages overturned my first explanation, since one of them drew far more search impressions than the treated page, and the write-up was corrected before it merged.
Project: brycewatson.com
19 sessions in this report · active 6/7 days
This site: the writing, the build, and this work log itself, kept current and accurate.
during this weekMade the draft preview link refuse a post that carries a known fault, added a weekly freshness report, and brought the open pull requests current for the publish word.
archiveRead the work-page click counter and found the traffic summary dropping the current day
The click counter on the links from a guide post to the work page is live and read zero in all three places, so the zero is a real reading rather than a dead sensor. Checking it showed the traffic summary script silently left out the current day and slipped on time zones, and a fix for both was checked against an independent query. The scheduled recheck of published posts found nothing overdue.
goal Keep this site clean, accurate, and currentRefused to hand over a draft preview link while the post carries a known fault
Draft posts kept reaching the Owner for approval with faults he had already flagged more than once, such as a missing cover image, a description lifted from the body, or no link to see the draft at all. A single preview command is now the only route to a draft’s local link, and it refuses to print one while any of those faults remain, naming the fix for each. Board workers answered a Codex review’s blocking findings with tests proven to fail on the old code before it merged.
goal Hold everything I publish to a hard quality and honesty barRefreshed the pending Command project page and corrected its factual slips
The rewrite of the Command project page had fallen behind both the main branch and the system it describes. A board worker merged it forward and refreshed its facts to early September, and a second pass corrected half a dozen slips against the dispatcher’s source, the board’s documentation, and the scheduler. It waits on the publish word.
goal Keep this site clean, accurate, and currentBrought the site’s open pull requests current and parked one built on a false premise
Board workers merged the main branch into several open site pull requests, including the pending work-log refresh, whose lost apostrophes they restored, and a mined-findings note, with checks passing on each. One pull request turned out to rest on a false premise, since the post it was meant to keep unpublished was already live, so it was parked with a recommendation to close it. A research note on which parts of an AI marketing stack are worth adopting passed a fresh review and merged.
goal Keep this site clean, accurate, and currentAdded a weekly content-freshness report, after fixing how it aged a correction
The pull request for a read-only freshness report carried a pinned review saying it was not ready to merge, with open defects in its correction-age measure. A board worker fixed them rather than clearing the review over them, so the age now counts from when a problem was first detected instead of when it expired, and the report merged.
goal Keep this site clean, accurate, and current Project: Akaya
15 sessions in this report · active 4/7 days
An AI platform. My work here makes its question-answering measurable and trustworthy: golden datasets and a real evaluation harness instead of guesswork.
during this weekReleased the platform to production, then tightened the environment checks on its pre-production service.
Fixed review findings in Akaya's upload flow and triaged its open issues
Fixed review findings in the upload flow, each with a regression test. Later in the week I read the platform's recent progress, triaged two new issues, and started independent reviews of two open pull requests. Two other worker runs stopped at a usage limit before finishing.
Added a pre-production mode to an Akaya service
Board workers added a pre-production mode to an Akaya service, with startup checks that confirm which environment it's running against. The work was built and waiting on review.
Released Akaya to production through a staged candidate
I took a fresh backup, staged the release as a candidate with no traffic, checked its health, and released it to production ahead of a call. Then I prepared notes for that call.
Project: Personal
2 sessions in this report · active 2/7 days
The life and money admin that keeps the runway clear while I build.
during this weekKept the billing records current and prepared the next invoice.
Kept the personal billing record current and prepared the next invoice
Updated the personal billing record, then prepared the next invoice, tidied its layout, and saved its cover email as a draft.
Project: honestweek
1 session in this report · active 1/7 days
An open-source tool that generates an honest weekly work log: it re-derives every number from real git and aborts the build rather than publish an unverified claim, and redacts private detail by rule. It is the engine that now generates this page.
during this weekThe weekly findings miner ran clean but found nothing publishable, and learned it had been re-proposing findings that earlier runs had already rejected.
archiveThe weekly findings miner found nothing publishable, and caught itself re-proposing old rejects
The weekly miner scanned thousands of deduplicated sessions for problems solved in someone else’s tool that could become a post, and none of its candidates survived checking, some being errors from my own throwaway commands. It had also described this as its first run, but earlier runs had already proposed and rejected the same findings, so the open pull request was corrected to say so.
goal Ship the next most valuable blog post each week, fact-checked