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
A disabled button was not a broken recorder.
The Mac app was telling the truth about paired capture while hiding the working single-camera path below the preview.
6 minRead
The copy had to become permission to delete.
Moving a golf video off the iPhone was easy. Proving that the phone copy could be safely removed was the real system.
7 minRead
Seventy-six UI tests passed. Two range controls were still outside the window.
Swing Trainer's Live Studio passed its presentation suite, but a real 1149×772 window clipped critical capture controls. Why visual verification remains a separate release gate.
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
I marked a swing, closed the app, and discovered the annotation was never a record.
Swing Trainer needed to preserve partial human review without calling incomplete work training truth. The revision model that keeps drafts, labels, and source video separate.
8 minRead
I taught the app when to record a swing. I refused to let it call that motion Takeaway.
Body motion can start and stop a golf recording, but it cannot prove where the club is. The evidence boundary behind Swing Trainer's hands-free capture system.
7 minRead
A phone can trace the club. That does not mean it measured clubhead speed.
The physics boundary inside Swing Trainer: what monocular video can support, what calibration might unlock, and what still requires an external instrument.
8 minRead
I had enough data to spend money on a GPU. I did not have enough evidence to train.
Why the Swing Trainer RunPod gate stops at provenance, frozen splits, and real five-point labels—even with thousands of images already staged.
7 minRead
We found 8,295 golf images. Almost none were the data we needed.
GitHub, Roboflow, Kaggle, and Hugging Face produced plenty of files. The hard part was refusing to call mismatched labels a dataset.
8 minRead
I thought tracking a golf club meant finding a line. Then the line disappeared.
The club looked simple until motion blur, hands, clothing, and the edge of the frame turned one object into five different evidence problems.
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
Do not put the club in the body frame.
A pose system can see a body, a club detector can see a club, and a launch monitor can report a ball. Calling all three one measurement is how a golf product starts inventing facts.
5 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
You can falsify a simulator without a single real measurement.
We had no measured data and a simulator we needed to trust. A model-vs-model audit produced decision-grade findings anyway. The five moves, in order, and what this method can never tell you.
7 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
I asked Claude to audit my simulator. It killed every high score.
We had a tens-of-millions-of-throws simulator and an overnight Monte-Carlo run nearly three times larger. One Saturday-night physics audit showed the two models agree on every trajectory and disagree on half the outcomes — and every max-score throw was an artifact.
8 minRead
I run three ventures from one Obsidian vault. Here's the 13-folder template.
Why a markdown vault outperforms a Notion plus Asana plus Drive plus Slack stack when AI agents are part of the work. Battle-tested across QC, MHG, and Parley.
8 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
I called three sign-recognition models failures. The recipe was the failure.
A Parley notebook reported three landmark architectures as broken on cross-signer ASL. A warmup and a gradient clip brought all three back, and two matched the best model. The ranking had measured my training recipe, not the models.
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
The 38-point gap: one accuracy number, twenty-one very different users
Our sign model averages 42% across signers. That average hides a range from 26% to 64% — and the thing that decides where a person lands is not the signs they make, it is who they are.
7 minRead
45%, not 90%: the only sign-recognition number I trust
Our best landmark-only sign model scores 45% on signers it has never seen. The field routinely reports numbers twice that high. The lower number is the honest one, and it is the one we publish.
6 minRead
Six ways hearing-built sign-language AI fails the Deaf community
I keep a running catalog of how hearing-led sign-language AI fails. It is not a list of other people's sins. It exists so Parley can catch itself the moment it starts to look like one of them.
7 minRead
I'm starting a publication. Here's what it is and why.
Field notes from an operator running three ventures on Claude Code. Biweekly. No theory. Receipts only.
5 minRead
Picking the glasses
One AR-glasses decision for two ventures. The criteria that survived the cut, and why doing it once was the right move.
7 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
ESP32 firmware with Claude: the gap between 'it compiles' and 'it works on the bench'
Claude is excellent at writing ESP32 firmware that compiles. It is not reliable at predicting what that firmware will do when the hardware is actually in front of you. Three incidents and the gate I added.
7 minRead
31 million systematic throws or 91 million random ones. Which one taught us more.
The answer isn't obvious. Systematic grid search gives you coverage. Random sampling gives you reality. You need both, and you need to know what each one is telling you.
6 minRead
We ran 124 million simulated cornhole throws. Here's what it cost and what we got.
A parametric physics engine, 8 parameters, two overnight runs. The database exists. Here's the honest accounting of what building it took and what we learned that we couldn't have learned any other way.
8 minRead
What it actually takes to build an AR overlay on a physical object in real time.
AR on physical objects is 80% coordinate system problems. Claude is great at helping you think through the geometry. You still have to understand it yourself.
8 minRead
Training a custom CV model with Claude: the data quality lesson we learned the hard way.
Clean data beats model size. Every time. Don't upgrade the model until you've audited the labels.
7 minRead
We put a language model inside a hardware device. Here's every decision we made.
LLMs in real-time hardware aren't ChatGPT. Latency budget is the constraint that changes everything.
8 minRead
Claude built our CV pipeline. Then it lied about being done.
Agents are unreliable judges of their own work. Here's how a structural fix — not a smarter model — stopped QC's CV pipeline from shipping silent failures.
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
Computer vision already runs elite sports. It's about to run the rec league too.
Twelve-camera tracking rigs and Hawk-Eye are infrastructure at the top. The same capability now fits on a $249 board and a commodity camera. What that unlocks across every sport — and why the smartest way in is the narrowest one.
7 minRead
How I run six AI agents across three ventures without them stepping on each other.
The routing model that holds up under load. Built for TruPath, tested on Mile High Golf, Quantum Caddy, and Parley.
6 minRead
I tried to build my own AI-native business OS. Here's why I scrapped it.
A 20-agent Electron app that didn't ship. The decision to throw it away. What I'd tell anyone tempted to build the same thing.
7 minRead
From Pixels to Club Physics: An Evidence-Bounded Architecture for Monocular Golf-Club Pose, Kinematics, and Training Data
What a phone camera can tell us about a golf club—and where physical measurement needs more evidence.
18 min readRead
Recipe, Not Architecture: Three "Failed" Sign-Recognition Models Recover Under Per-Architecture Training
Three sign-recognition models recovered when the training recipe changed. A closer look at what model comparisons actually measure.
12 min readRead
The Honest Ceiling on Landmark-Only Isolated-Sign Recognition: A Signer-Holdout Audit
An audit of sign recognition on unseen signers, with multiple seeds and explicit limits on what the results establish.
13 min readRead
Signer-Dialect Robustness in Landmark-Only Sign Recognition: A 21-Fold Leave-One-Signer-Out Study
Why one average accuracy score can conceal very different experiences across 21 signers.
14 min readRead
Real-Time Computer Vision for Bounded-Court Scoring: Architecture, Tradeoffs, and Production Lessons
Real-time scoring of physical-object sports requires a computer vision pipeline that can simultaneously satisfy constraints from three domains: inference latency (sub-35ms end-to-end), detection reliability (>99% on custom domain data), and commercial licensing (Apache 2.0 for network-service deployments).
14 min readRead
Data-Centric CV Pipeline Engineering: Lessons from 15 Training Iterations on a Custom 3-Class Detection Domain
Generic computer vision model fine-tuning treats dataset construction as secondary to architecture selection.
15 min readRead
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
Same Task, Three Harnesses: A Throughput-Quality-Cost Benchmark of Claude Code, Codex, and Cursor on a Multi-Stage CV Pipeline Task
We report a case study (n=1 task, three agent harnesses, single operator) comparing Claude Code, OpenAI Codex CLI, and Cursor on the construction of a multi-stage computer-vision evaluation pipeline.
16 min readRead
Detecting Eval-Train Overlap in Production CV Pipelines: A Lightweight Audit Protocol
Computer vision systems shipped to production frequently report misleading evaluation metrics due to undetected overlap between training and held-out eval data.
14 min readRead
Long-Context vs Targeted Retrieval for Compliance Drafting: An SBA Loan Packet Case Study
Modern long-context language models (1M-token windows) make it tempting to load an entire reference corpus and draft against it; the implicit premise is that more context is always better when accuracy matters.
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
Multi-Stage Fallback in Real-Time Computer Vision: A Methodology Study
Real-time computer vision systems that must operate under latency constraints face a tension between detection accuracy and inference speed.
14 min readRead
A 7-Class Failure Taxonomy for ASR-Glasses Coordination in AR Research Sprints
Parley is an AR-glasses product for bidirectional deaf/hearing conversation; the research arm is in Phase-0/1 Kaggle-published exploration and the consumer hardware (Everysight Maverick AI) has not yet shipped.
13 min readRead
Provisional Patent Draft Accuracy: Measured Rework Rates vs Human Baseline
LLM-assisted provisional patent drafting promises faster cycle time at the inventor-startup phase, but the question for operators is how much of the LLM draft survives attorney review.
12 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
Real-Estate Site-Search Automation: Hours-Saved and Filter-Accuracy in a Pre-Launch Venue Search
Pre-launch entertainment-venue site searches are constrained by an unusual cocktail of filters: zoning compatibility, square-footage and ceiling-height fit, ABC-license geography (in NC, alcohol licensing depends on municipal jurisdiction and proximity to schools/churches), and proximity to demand.
12 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
Vault Structure
13-folder Obsidian template that scales across multiple ventures. The operating system around your AI agents.
ArchitectureRead
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
The Security & IP Discipline Playbook
Five gates that keep a fast-moving AI shop from leaking its secrets, its source license, or its patent rights. Written the day I pasted my session tokens into a chat.
DisciplineRead
The CV-for-Physical-Sports Wedge Playbook
Don't build computer vision for sports. Build it for one sport — the one with the most constrained geometry and the simplest rules — get it referee-grade, then generalize. Three filters and the trust-bar framework.
DisciplineRead
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
The Honest Sign-Language Research Playbook
The discipline behind Parley's notebooks: question-first contracts, signer-holdout splits, multi-seed floors, failure-modes-first, and a Deaf-community honesty checklist. The rules that make a 45% you can trust beat an 85% you can't.
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
The five-phase audit: a science agent's working method
An agent audit of a Quantum Caddy simulator ran five phases in a fixed order — reproduce the as-built model, rebuild it from first principles, map the divergence, budget the uncertainty, ship a ranked measurement list. What each phase produced, what breaks it, and how to run it on a demand model or a game economy.
ToolkitRead
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
Vault as operating system — the 13-folder convention
Numbered folders. Single source of truth per concern. Why a markdown vault beats a SaaS stack.
20 min read · 60 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
What public disclosure does to your patent rights
Pitch without an NDA, publish a write-up, prompt a consumer LLM — each can be a disclosure. The grace period, the foreign-filing trap, and what to check before anything goes public.
12 min read · 60 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
Picking a computer-vision wedge: start with a fixed playfield
The hardest version of a CV problem is an open field; the easiest is fixed geometry you can pin with homography. How to choose the narrow, solvable entry point — then generalize.
11 min read · 20 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
Multi-venture portfolio operations
Cross-venture routing, shared agents, isolation rules. Running 3+ ventures from one operator.
25 min read · 60 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
AR research sprints when hardware isn't shipped
How to ship Phase-0 R&D against unreleased hardware (Maverick AI).
20 min read · 60 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
SBA loan packet drafting with agents
The 12-document SBA 7(a) packet, agent-assisted, with rework rate measured.
25 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
The simulator-label trap
Two models agreed on every trajectory to a hundredth of a foot and still flipped 48.3 percent of scored outcomes. Simulated states degrade gracefully; simulated labels fail all at once, right where the outcomes get interesting.
10 min read · 25 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