Writing

These are the long versions of what I post on LinkedIn, with the evidence the short versions don't have room for. Many land here first. Each one starts from something that actually happened in a build, and every number in it traces to the receipts page.

The leadership essays I wrote in 2024 are kept in an archive below. They were written by 2024-era ChatGPT models and haven't aged well against the current voice — they're due a rewrite into the register the rest of this site uses, not left as they were.

Filter

The thesis

Every layer of computing was a plain-language layer

Each computing layer let people say more in their own words. The receipts for the English layer: twelve projects, six live or shipped, more than 8,000 tests.

I built a tool to audit my own AI claims. It made my numbers smaller.

I audited my own AI usage claims with a purpose-built collector and four verification passes. The audit cut a 10-billion-token headline to 36 million and…

Shipping production software in plain English: what it actually takes

What it actually takes to ship production software in plain English: the gates, the status words, the failures, and the parts that still need a human.

What I actually do when the agent writes the code

The agent writes the code and tests. I direct, decide, and validate. 157 prompts in two weeks when 75% of the C++ was written—measured.

The layer finally arrived in my native language

I'm dyslexic and proofreading by eye is the task my brain is worst at, so I built Cadence to let me proofread by ear instead — the layer thesis made personal.

Who Adroit is for: businesses competing against bigger money

Adroit is a Growth Partner for businesses competing against bigger money, running on the same systems it sells: revenue operations, marketing…

Your documentation is source code now

About 40% of the game's 104,912 documentation lines exist so the agent can read itself back into context — measured proof that docs are source code now.

A revenue agent that answers only from what you approved

Sadyr answers pre-sales questions from approved sources only, abstains when it isn't sure, and hands the conversation to a person.

Inside LEGION: running agents like an engineering org

LEGION is the control layer I run Adroit on — a generated state panel, human-triggered sessions, capability packages and agent governance, built after eight…

My second brain is an ADHD accessibility system an agent can navigate

The Brain Vault: 1,765 documents in two layers, 50 pillars, 17 playbooks. An ADHD accessibility system designed so an agent can navigate it and act on real…

A website built to be read by machines as well as people

Adroit's website rebuilt with a machine-readable layer: 74 pages updated, 17 created, JS from 103 KB to 2 KB, Markdown twins and llms.txt live.

An agent-operated job-search pipeline with two Python packages and no database

A job-search pipeline with 13-dimension scoring, file-based state, and an agent-facing API of pure re-exports — built with two Python packages and no…

Connect your data: seven systems into one, with nothing rolled back

Six weeks to connect seven systems for a national sports league. The data mirror is live, additive-only, and leaves the audits in the code.

Audio Apothecary: a generative audio lab with an honesty policy

A generative audio app built in six days with 1,211 tests — and a review agent that found the showstopper bugs the test suite missed.

Cadence: the proofreading tool I built because my brain is worst at proofreading

A local proofreading app that reads Markdown aloud with synced highlighting. 368 tests, 2,995 segments rendered, zero failed. Built because dyslexia.

Content Ops: an evidence-first content engine, and what it took to run it at scale

Content Ops drafts only from an approved knowledge base. Running it at scale meant 92 of 95 pages in two days, a same-night incident loop, and choosing…

Milkman: a benchmarking tool that refuses downloads that won’t fit

A local-model benchmarking tool built in 31.4 hours that tunes itself to hardware, refuses downloads that won't fit, and logs its own failures.

Sadyr: blueprint to production in twelve days, and what it answers from

Sadyr went from blueprint to production in twelve days. Here's the architecture, the bugs, the numbers, and what it answers from.

An on-device interactive fiction engine: 38 decisions, 1,010 tests, and why it’s parked

A parked on-device interactive fiction engine: 1,010 tests, 38 decisions, zero network calls, and what I learned building the harness that could refuse…

Seven security probes passed. The product still failed.

An on-device assistant passed seven security checks and then sat unused for 55 days. It only delivered value when I babysat it, and the need it was built for went away.

Seven systems, about 2,400 teams, six weeks, zero rollbacks

A revenue-operations rebuild for a national amateur sports league: seven systems into one CRM, additive-only changes, and no rollbacks.

The creature-battler where my working habits started

A parked Godot toy that taught me battle math in a spreadsheet first, session timers before my business had them, and that tests don't replace play.

The infrastructure behind a game in development

81,707 lines of C++, 519 subagent conversations, 250 logged decisions: the measured infrastructure behind a game in development built with Claude Code.

A unit test deleted a real 4.7 GB model file

A subagent-written test undid its own sandbox and deleted a real 4.7 GB model; the tool's own failure log caught it and showed why recovery worked.

Adversarial audits left in the code

Three severity-coded adversarial audit rounds live as comments in shipped code; one field-coverage audit caught a form field silently dropped for two months.

Four patch points into a system we had never seen

Reverse-engineer an unfamiliar system, then wire a CRM in through four additive patch points with under 80 lines changed and zero edits to existing logic.

Inside the Brain Vault: layers, triage and seventeen playbooks

Raw and synthesized layers, signal triage, dated confidence labels, PageRank cross-checked, and seventeen agent playbooks instead of vibes.

One platform, two opposite audiences

Two working Sadyr demos — public insurance explainer and gated sports rulebook assistant — run on one platform with opposite audiences and no re-architecting.

The answer gate that divided confidence by word count

Sadyr's confidence gate divided retrieval scores by word count; every test passed, every multi-word question abstained. Found and fixed in one day.

The overnight run, and the gate that earned it

Three engine systems landed overnight with nobody at the keyboard. The overnight part is not the story. The gate that could refuse the result is.

A review agent found two bugs that would have made a calm-audio app secretly stressful

A review agent found a self-canceling pan law and a fake limiter in a generative audio app; listening alone would likely never have isolated either.

Three production defects, found and fixed the same night

Three production defects in Content Ops — a runs race, an artifacts race, and a polling fan-out — surfaced and fixed the same night.

I made the agent attack its own diff engine before I trusted it

I attacked Cadence's diff engine with adversarial tests before trusting it. Three bugs, three fixes, 368 tests. Why hash-based reconciliation matters.

Every pitfall I pre-wrote a rule for, my agent still needed reminding about

Ten documented pitfalls, four real bugs caught in audit, six problems the agent found itself — and the lesson that a rule an agent remembers is just a…

Make the agent argue first: plan the plan, defend the design

Before Cadence got code, a 1,105-line prompt made the agent plan its plan, and a design agent defended 19 features; arguing up front was cheaper than rework.

My listening log became the bug tracker

A plain-language listening log sat directly above an agent's dated root-cause entries, and one 'crackling' report turned out not to be a bug.

Two bugs that weren’t mine: a 30-year-old Windows quirk and an upstream voice bug

A dyslexia proofreading app broke on a 30-year-old Windows quirk and an upstream voice bug; building on other people's code means debugging it too.

Your graph view is a hairball because it treats every link as equal

Sparse top-K edges, PageRank as mass and a seeded layout turn a knowledge graph into a map. A nebula that never rendered showed what 31 tests missed.

The tests proved every fix. They couldn’t see the bug.

Nine days on a game built with AI coding agents: more test code than game code, and the same class of bug fixed one at a time. What heavy testing misses in an AI-first codebase.

A model is not a product: the harness I built on the fly

The speech model was the easy part. Chunking, retries, sync, caching and a UI I trust are what made Cadence a product I use every day.

Own the center; wrap, rent or swap the edges

Sadyr's architecture rule from a production incident: own the policy and logic that make your system yours; treat models, CRMs and channels as swappable edges.

A rule it can argue with: where rules for agents belong

A rule in a prompt gets broken; a rule in the tooling gets enforced. The heredoc hook that blocked the next attempt after three violations and the lesson another builder can use.

Start from someone else’s repo

I cloned open-source repos and built on top. Credit upstream, keep changes additive, and know which bugs are theirs — those are the rules.

Built it, piloted it, deleted it

I built an orchestration platform, piloted it successfully, then deleted it because plain Python and JSON files handled the workflow with less complexity.

Six shipped builds ran settings no eval had validated

Six Android builds of an on-device fiction engine ran sampler settings the eval suite never tested, because the runtime silently filled defaults.

Built, live, demo, shipped, sold

Agents made 'built' cheap, so the status word is now the claim. Five words the industry uses as one, and a real example of each from Todd's own work.

Governance for agents that do real things

Once agents can deploy and spend, governance is four rules enforced in tooling: observe freely, mutate with a flag, some actions human-only, no repo…

My READMEs lied about my tests

Every stale test count Todd found this year undercounted, across three projects and three stacks. Why docs drift one way, and why agents make it worse.

Operator or agent: make authorship a field

An agent's unapproved scope decision sat in my decision log looking like my own for a full sprint before I caught it; the fix was to make every decision record say who made it. Authorship belongs in the data.

Parallel is a budget, not a speed setting

Ten parallel subagents burned a five-hour budget in 33 minutes. The fix was a cap and a rule, not a bigger plan — and the same lesson applies to…

Stalled vs blocked

A project that goes quiet is either stalled or blocked. The game's 63-day gap was the second kind, and knowing the difference changed every build after it.

Status is derived, not reported

Docs drift and agents trust them. The fix: one generated page, status computed from what exists, not what was last written down.

The handoff file: every session rewrites it, none appends

Agents forget between sessions. A single handoff file, rewritten not appended, plus a stand-up and wind-down ritual keeps long projects coherent.

Deterministic code decides when to speak; the model only chooses the words

Lessons from a failed on-device assistant: put decision logic in code, keep agent memory separate, and watch for SDK instances that don't talk.

Faster, lighter, bigger: every model swap I rejected, and the metric that decided

Three faster, lighter models lost on prose quality; a bigger model that won on quality was rejected on speed. The decision rule matters more than the…

Metrics that misled: the flat traffic that wasn’t

A client's flat traffic hid growth and a conversion problem. "Why now?" is the question that separates a metric from a story.

ADHD, novelty, and building the right room

Novelty-seeking isn't a deficit if you build the environment where it's fuel. How I built systems and tools that work with ADHD, not against it.

Billing, migrations and my first team

Hired into Bluehost billing to absorb two acquired hosts, I learned fast, led training and escalations, and walked out knowing WordPress well enough to…

Eight months of not building LEGION

I tried to build LEGION three times in 2025 and failed each time. The idea didn't change — what was missing was operator skill and model capability.

From COO to Chief Innovation Officer: how operations work turned into AI work

I joined Adroit as COO in 2021, wrote down every process, then spent years building AI into our workflows until the title changed to Chief Innovation…

The ‘I told you so’ board: taking the stigma out of being wrong

Teams hide mistakes when being wrong is costly. A board that celebrates testing ideas made failure normal—and it's why I publish mine now.

Aligning incentives, then and now: incentives for agents are permissions

People respond to what they are scored on; agents respond to what they are allowed to do. Aligning either one is designing the scoreboard.

Curiosity as a catalyst, then and now: I learned it on a toy

The same curiosity that took me from a systems migration into SEO took a toy game's habits into LEGION. Neither was a planned pipeline. Both times it worked.

Data at the helm, then and now: the Brown Score, and an audit log with one entry for thirty-one jobs

A usage score drove client retention at Banyan; an agent that never logged its own actions told nobody anything. Data steers only when it's written down and…

Front-line expertise, then and now: the review agent found what the builders missed

Weekly trainings at NP Accel and an adversarial review agent are the same mechanism: a channel for front-line expertise with no stigma for being wrong.

Guiding transformation, then and now: seventy-four pages rewritten, staged, cut over

A rebrand and a 74-page site rewrite share the same shape: stage everything, verify each piece, cut over only when the check is done.

Measuring success, then and now: green tests are not a result

Self-reported evals at chance level and seven passing security probes on an abandoned product: why green tests don't prove you built something worth having.

Pre-defined metrics, then and now: my eval measured nothing

Define success before the work starts and verify the measurement actually tests what matters, or your eval will agree with whatever the model says.

The art of persuasion, then and now: the churn warning nobody acted on, and the check nobody built

A churn warning ignored in 2016 and a values check nobody built in 2026: both times the information existed, and both times the system wasn't built to act…

Thriving in chaos, then and now: a backlog of thousands, and a second brain built for how I think

Chaos is usually a system that depends on someone remembering. The fix at 180Fusion and the fix in the Brain Vault both write the memory down where it…

What Claude Code’s own report says about how I work

Claude Code's Insights report on eight weeks of my sessions: 855 messages, 262 hours, 195 commits. What it got right, what goes wrong, and what I changed.

From the archive: 2024 essays on leading teams

February 2024

The thesis

Build deep-dives

Build logs

Lessons

Stories

Then → now

Receipts

From the archive: 2024 essays on leading teams