Codex Astra did not remove the need for proof.
A more capable coding agent can cross a larger problem in one run. That makes scope, receipts, and independent verification more important, not less.
5 minRead
Find your next useful idea.
Field notes, research, playbooks, and lessons. One place to follow the threads that matter to your work.
The Second Brain needed a job description.
A beautiful knowledge graph becomes another inbox unless it is clear what belongs there, what stays elsewhere, and which system is allowed to call work complete.
5 minRead
Polygon count could not save the course.
The environment had terrain, trees, bunkers, and mountains. It still did not feel like the concept, because technical completeness and visual authorship are different jobs.
5 minRead
The game started as a pipeline, not a level.
Before there was a playable hole, there had to be a way to keep concepts, assets, physics, builds, and claims from collapsing into one folder called progress.
5 minRead
The Mac app was healthy, signed, and running. The workstation still did not appear.
A signed macOS process, green tests, and an idle run loop did not prove that the user had a usable app. The launch investigation that separated disk work, window state, and observation error.
7 minRead
Automation needs a job description.
The useful question is not “can Airtable automate this?” It is “what may this automation change without a person reviewing it?”
3 minRead
The performance number we need is the one we do not have.
The Range spike has a full instrument, a protocol, and a hard exit bar. It still has no iPhone measurement. That is not a gap in the story. It is the story.
5 minRead
One prompt clause turned my analysis agent into an experimentalist.
Most analysis sessions return confident prose. This one returned reproduction scripts, error bars, and a ranked list of experiments. The difference was a one-page brief written like a lab contract.
6 minRead
Why I write a postmortem for every meaningful incident, and the template that makes it take 45 minutes.
Twenty-six postmortems across QC and Parley in six weeks. The template, four worked examples, and the discipline that makes the same mistake stop happening twice.
7 minRead
I shipped a Sprint Contract template. Here's why my AI agents kept declaring done when they weren't.
A 48-contract system born from agents that praised their own work. The fix wasn't a smarter model. It was structural.
7 minRead
Recipe beats architecture: lottery tickets in sign models
We trained seven landmark architectures three times each. Three of them worked on one seed and collapsed to near-random on the others. A single-seed comparison would have called two of those collapses a result.
6 minRead
Why I'm running Parley
I started a Kaggle research project in Q2 2026 while running two startups. The decompression channel, the four open questions, and what makes it survive.
8 minRead
I pasted my session tokens into a chat. Here's the gate I built.
Sixteen cookies that together are my whole Google account, dropped into a chat window — while building a security playbook. The how is the whole point.
5 minRead
Cost-per-Artifact Curves Across Claude Model Tiers (Opus 4.7 / Sonnet 4.6 / Haiku 4.5)
Selecting the right Claude model tier for a given artifact type is the single highest-impact cost decision an operator makes in an agent-mediated workflow.
12 min readRead
Sprint Contract Overrun: Updated Causal Taxonomy from 80+ Cross-Venture Sprints
TPL-2026-005 established that sprint-contract discipline reduces overrun rates in solo-operator agent-mediated work (median overrun 78% → 12%).
13 min readRead
Brief-Drift Detection in Long Agent Sessions: An Empirical Audit of Self-Diagnostic Reliability
Long agent sessions (those exceeding two hours of continuous operation) accumulate a characteristic failure pattern we term brief-drift: the gradual divergence of agent behavior from its original operator-specified constraints, without any single identifiable failure event.
12 min readRead
Information-Loss Curves Across Multi-Agent Handoff Chains
Operators increasingly compose work as a chain of specialized LLM agents: a routing agent dispatches to a planning agent which delegates to a coding agent which calls a review agent.
13 min readRead
Plan-Mode Efficacy on Time-to-Merge: A Cross-Venture Study (n=42 tasks)
Plan mode, the agent-harness convention of producing and approving a written implementation plan before any code is written, is widely advocated as a discipline for non-trivial coding work, but its quantitative effect on time-to-merge has rarely been measured outside anecdote.
12 min readRead
Postmortem-Driven SOP Effectiveness: A 6-Month Recurrence Audit
Blameless postmortems are widely advocated as a structural-learning discipline, but their effectiveness depends on whether action items reach the mechanical layer (gates, hooks, contract criteria) rather than remaining as discipline-only commitments.
10 min readRead
The Sprint Contract Effect: Measuring Overrun Reduction in Solo-Operator Engineering
Solo operators running agent-mediated engineering work routinely overrun sprint estimates by 50-200% of the originally scoped time.
11 min readRead
Sub-agent ROI: When Spawning Pays Back and When It Doesn't
Sub-agent invocation (spawning a child agent to handle a bounded subtask) is increasingly common in solo-operator AI workflows, yet the conditions under which it produces a net benefit remain poorly characterized.
13 min readRead
Token Economics of Agent-Mediated Engineering: Per-Artifact Cost Distributions
Operators running agent-mediated engineering workflows routinely lack visibility into the per-artifact token cost of shipped work, treating the monthly API bill as a single aggregate figure.
12 min readRead
Sprint Contract System
Pre-work contracts co-signed by builder and evaluator. Eliminates close-enough shipping. 48 contracts shipped.
DisciplineRead
Postmortem Discipline
Blameless postmortems with structural action items. The discipline that makes the same mistake stop happening twice.
DisciplineRead
CLAUDE.md Template
The annotated skeleton every Claude Code operator needs before their second week. Three worked examples, one framing essay, and the advice everyone skips: what NOT to put in.
TemplateRead
Agent Routing Template
The chief-of-staff + N-specialists scaffold. Routing table, authority levels, and an escalation protocol — the piece everyone skips until it bites them.
TemplateRead
Memory Architecture
The MEMORY.md index pattern. Four memory types, a staleness protocol, and the one rule that stops memory systems from becoming archives.
ArchitectureRead
Agent Hierarchies
Authority levels, the mothership pattern, generation/evaluation separation. The structural decisions most multi-agent setups skip until they break.
ArchitectureRead
Token Discipline
Context window hygiene. What belongs in CLAUDE.md vs memory vs code. The compaction strategy that keeps sessions fast after month 3.
DisciplineRead
TruPath Stack
The assembled picture — how agents, hooks, memory, sprint contracts, kanban, and the Telegram bridge connect into a single operating system for a multi-venture portfolio.
ArchitectureRead
Hooks Bundle
Five production-tested Claude Code hooks — session loading, config protection, eval auditing, decision logging, anchor-check cadence. The mechanical enforcement layer your CLAUDE.md rules have been promising.
ToolkitRead
Why run a parallel research arm
A small operator can run a parallel research project alongside two startups without it cannibalizing them — but only under specific conditions, and Parley is the worked example.
DisciplineRead
How to run one without it cannibalizing the startup
Four discipline levers that let a side research arm survive contact with the main work — scope rails, monthly cadence, public publishing, and decision logs, with kill criteria written down in advance.
DisciplineRead
Pre-register the recipe before you rank architectures
A shared training recipe across architectures does not control for the recipe. It bakes it into the result and disguises it as an architecture finding. Four cheap controls keep the ranking honest.
DisciplineRead
Run a falsification session before you trust your own asset
Operators accumulate load-bearing assets that were built under deadline and never adversarially examined. A one-evening AI falsification session is the cheapest insurance that exists, and the discipline is scheduling it before the asset feeds a decision.
DisciplineRead
Your first CLAUDE.md
The instruction file your AI reads on every session. What goes in it, what doesn't.
10 min read · 20 min applyRead
Your first agent.md (a 'soul file')
Define a specialist. Scope, triggers, authority, tools. One file, one role.
12 min read · 25 min applyRead
Your first Claude Code skill
What a skill is, when to write your own, the bootstrap pattern.
10 min read · 30 min applyRead
The brief format that gets the design you wanted
Five fields that turn fuzzy asks into concrete renders.
8 min read · 15 min applyRead
Asking Claude to write a document
Voice, structure, source-pinning. The difference between a brief and a fight.
10 min read · 20 min applyRead
Asking Claude to make a report
Inputs → research → structured output. The reporting loop in plain language.
10 min read · 20 min applyRead
Building your first simple web page with Claude
Project scaffold, dev server, iterate-by-screenshot. End-to-end.
20 min read · 60 min applyRead
The five phrases that change how Claude responds
Specific language, used at specific moments, that produces outsized improvement.
8 min read · ongoing applyRead
Picking your model — Opus, Sonnet, Haiku
Three models, three jobs. The decision rule that saves $300/month.
12 min read · 20 min applyRead
Your first plan-mode session
When to drop into Plan, how to read its output, when to exit.
12 min read · 30 min applyRead
Reading agent output critically
The trust-but-verify reflex. Spot fabricated results before they ship.
12 min read · ongoing applyRead
Slash commands you'll actually use
The 6 slash commands worth memorizing on day one.
10 min read · 15 min applyRead
Background agents — when, why, never
Long jobs offloaded right; the failure modes nobody warns about.
12 min read · 30 min applyRead
Reading a diff before you accept it
The 4-pass diff review that catches what tests miss.
12 min read · ongoing applyRead
Your first MCP server
The 20-minute setup, the gotchas, when MCP beats writing a tool.
15 min read · 20 min applyRead
Your first custom agent file
Build CIPHER (legal/IP) from scratch in one sitting.
15 min read · 45 min applyRead
Tool permissions and you
Allow vs ask vs deny — the model that prevents 90% of "wait I didn't mean that" moments.
12 min read · 20 min applyRead
When your agent says "done" — turning claims into evidence
The diagnostic that catches every kind of "finished but not really." One prompt, three patterns, one habit.
15 min read · 30 min applyRead
Postmortem discipline — when something breaks anyway
The substitution test for structural causes. Action items that ship. The close-out protocol.
15 min read · 45 min applyRead
Memory architecture — what to remember, what to throw away
MEMORY.md as an index. Four memory types. The single rule that prevents bloat.
12 min read · 20 min applyRead
Hooks — mechanical enforcement vs. promised future discipline
SessionStart, PreToolUse, PostToolUse. Why hooks beat "agents must remember to."
18 min read · 60 min applyRead
Mid-sprint scope changes — the amendment protocol
How to add work to a contract without losing rigor. When a re-sign is required.
10 min read · 15 min applyRead
Cross-agent handoffs — when one agent's done is another agent's begin
Communication protocols, delegation templates, authority boundaries.
14 min read · 30 min applyRead
Wiki synthesis — turning chat history into queryable knowledge
Karpathy-style ingest. Page format, index pattern, lint cadence.
15 min read · 45 min applyRead
Decision logs — ADRs that ship
Frontmatter, options table, revisit conditions. Future-you reads this.
10 min read · 20 min applyRead
The routing model — one chief of staff, N specialists
Why six is right and fourteen is too many. Authority levels, trigger words, escalation.
14 min read · 30 min applyRead
Sprint contracts in practice
The contract format with three real examples — QC firmware, Parley research, MHG site search.
20 min read · 45 min applyRead
Branch hygiene with agents
When worktrees beat single-branch. The merge etiquette nobody taught you.
18 min read · 40 min applyRead
Cost ceilings + the Sunday-night ritual
The spend dashboard, the kill-switch, the weekly review that prevents bill shock.
16 min read · 30 min applyRead
When to delegate vs do-it-yourself
The 4-question test before you spawn a subagent.
15 min read · 30 min applyRead
Test-first with agents
TDD with an LLM that wants to skip it. The 3 enforcement patterns that work.
18 min read · 45 min applyRead
Plan-mode discipline
Plan mode for senior operators. When to skip Plan, when to triple it, the exit ritual.
16 min read · 30 min applyRead
Code review with agents
The review prompt that catches what humans miss. The escalation rules.
18 min read · 40 min applyRead
Postmortem-on-rails — the template
The 7-section postmortem template + how to make agents write it for you.
20 min read · 45 min applyRead
Decision logs in practice
Why decision logs beat status meetings. Format, cadence, retrieval pattern.
16 min read · 30 min applyRead
AGPL vs Apache: the license decision that ships or sinks your product
Permissive vs strong-copyleft, the AGPL SaaS loophole, and why a single library can turn your whole codebase open. The license check that belongs in your workflow.
9 min read · 15 min applyRead
Decompression channels
A parallel technical project that restores focus to the main work instead of competing for it. How to tell if yours qualifies.
12 min read · 30 min applyRead
Skill-transfer adjacency
Picking a topic close enough to compound with the main work, far enough to feel like rest.
10 min read · 25 min applyRead
The "won't become a product" rule
Declare in writing, before starting, that the arm will not become a product. The declaration is what makes it survive.
10 min read · 20 min applyRead
When NOT to start an arm
Three conditions under which a second project is a distraction, not an arm. Honest about when I would have said no.
10 min read · 15 min applyRead
Scope rails for a research arm
Naming what you commit to NOT building, in writing, before starting. The Parley scope-rails block as the worked example.
10 min read · 30 min applyRead
Monthly cadence as a discipline lever
Why monthly beats weekly and quarterly for a side project. The forcing function logic.
10 min read · 20 min applyRead
Kaggle as a publishing loop
Using a public platform as the forcing function instead of a private repo. Why public is the discipline lever.
10 min read · 15 min applyRead
Kill criteria for the parallel arm
The advance commitments that make starting the arm psychologically safe. The three triggers that put it on ice.
10 min read · 15 min applyRead
Retrofit — applying structure to a project that's already a mess
Where to start when there's no CLAUDE.md, no contracts, no postmortems, and the deadline was yesterday.
25 min read · several hours applyRead
Real ROI from agent hierarchies
When 6 agents are right, when 1 is enough, when more agents make you slower. With numbers.
20 min read · 60 min auditRead
Tracking token spend and identifying waste
Cache health ratios. Tokens per shipped artifact. Idle days vs. uncommitted-output days.
20 min read · 30 min applyRead
Accountability — contracts + postmortems + gates as one system
How the three disciplines compound. Where each catches the others' failures.
18 min read · 45 min applyRead
Scope creep prevention
The amendment protocol at scale. Refusing 'while we're in there' work. Without becoming an obstacle.
12 min read · 30 min applyRead
Cloud training discipline — postmortem-driven SOPs
Pod lifecycle decoupling. Exit-path audits. Watchdog cadences. Don't lose a 14-hour run.
20 min read · 90 min applyRead
Hidden cost of agent context drift (and how to detect it)
The signs that your session is gradually losing accuracy. Restart hygiene that compounds.
15 min read · 30 min applyRead
Building your first custom MCP server
When to build vs use existing. The protocol in plain language. The failure modes that cost teams two weeks each.
20 min read · 2 hours applyRead
Multi-agent orchestration patterns
Beyond chief-of-staff routing: parallel-spawn, gather-then-merge, race-then-cancel. When each fires and when each breaks.
18 min read · 60 min applyRead
Production debugging playbook
When an agent misbehaves in prod: the diagnostic ladder. Five rungs from "claim says done but isn't" through context drift, tool failures, schema mismatches, upstream model regressions.
20 min read · 60 min applyRead
Custom agent definition files (build AXIOM + CIPHER)
The 5-section agent file pattern. Two case studies from the TruPath team.
30 min read · 90 min applyRead
Production incident response with agents
The on-call playbook: paging, evidence collection, triage ladder, and postmortem-on-rails.
20 min read · 60 min applyRead
Compliance + audit trail for AI work
The audit-trail format regulators (and your future self) will thank you for.
20 min read · 45 min applyRead
Programmatic cost ceiling enforcement
Hooks + statusline + a kill-switch script. The whole stack.
20 min read · 90 min applyRead
ASR ground-truth pipelines
Building an ASR eval set from scratch when there's no public benchmark.
25 min read · 2 hours applyRead
Reproduce the as-built model before you correct it
Two models that disagree tell you almost nothing until you can regenerate the one you are auditing. Reproduction converts ambiguous divergence into a named mechanism, and it finds defects before the correction work even starts.
12 min read · 30 min applyRead
Run the sensitivity tornado before you measure anything
Friction swung our prediction 14.9 inches of a roughly 15-inch budget, three times the runner-up, and mass was noise. A one-afternoon sensitivity sweep turned the measurement wishlist into a spending plan.
10 min read · 40 min applyRead
Uncertainty budgets tell you which stage to distrust
The audit put ±2 inches of uncertainty on our flight prediction and ±15 on everything after contact. The failure lived in one stage, and a per-stage budget is what kept us from throwing away the stage that worked.
10 min read · 20 min applyRead
Research isn't done until the handoff brief is written
The QC physics audit produced runnable models, a dozen figures, and a stack of CSVs. The artifact that mattered three weeks later was none of them — it was a short brief written for the engineers who have to act on the findings.
10 min read · 25 min applyRead
Your domain intuition imports the wrong physics
We assumed spin mattered the way it matters on a golf ball. Priced in the same units, the borrowed mechanism was worth 3 inches and the real one 23, a 7× miss in which mechanism matters, caught in one afternoon before it spent our measurement budget.
10 min read · 20 min applyRead