What the work turns up.
Dispatches from our forward-deployed work. We sit inside a business, listen to the problem in the owner's words and fix it.
Each note is one of those problems: what we found, what we did, what changed. Plus what we learn running our own software factory.
How We Run Our Software Factory (and What Broke)
AI agents write most of our code now and checks, not people, review it first. The rules we run by, what we measured and what went wrong along the way.
Why GitHub Wasn't Built for AI Agents (and What to Do About It)
GitHub assumes one person changes code and another reviews it. AI agents break that rhythm. What slows teams down, and the fixes that work.
Paying for Searches You Were Never Going to Win
Loose Google Ads settings spend budget on people looking for competitors, products you don’t sell and places you don’t deliver to.
Quiet SEO Leaks: Empty Pages, Missing Descriptions, Cut-Off Titles
Small search problems that never show as errors: empty category pages in Google, brand pages with no description and titles cut off in results.
The Shopping Feed Fields Nobody Checks
Missing brands, cut-off descriptions and duplicate titles in a Google Shopping feed cost visibility long before any product gets rejected.
Supplier Prices Move. Your Prices Do Not.
In a business that buys from many suppliers, small price rises hide inside big invoices. A price book built from emailed invoices shows where margin went.
To Branch or Not to Branch: Why We Build on Trunk With AI Agents
Long-lived branches feel safe, but with AI agents they multiply copies, collisions and lost work. Why we build on trunk, and when a branch still makes sense.
What Google Ads Says vs What Your Orders Say
Two weeks after an ads rebuild, the ad platform claimed 1.7 times the sales the store credited to ads. Finding the true sources changed what we did next.
When Google Ads Cannot See Your Sales, It Bids Blind
Smart bidding learns from the conversions you feed it. When that signal breaks or is inflated, Google bids confidently in the wrong direction.
Two Hosts Who Don't Exist: How We Generate Our Podcast With Gemini 3.1
We moved our audio stack from OpenAI to Gemini. An honest guide to a two-host podcast on Gemini 3.1 multi-speaker TTS: what breaks, and how we fixed it.
We Were the Bottleneck: What 3 Days of Data Taught Us About Our Own Automation
We built an autonomous engineering pipeline. It felt slow, so we measured three days of our own usage instead of building more. The bottleneck surprised us.
Is Jujutsu a Git Superpower for AI Coding?
AI agents generate changes faster than Git branches can track. We measured the cost: ~60% of CI wasted on rebase churn. The tooling fix, and its limits.
From 17% to 97.8%: Making a Laptop-Sized AI Actually Reliable
A small on-device model started at 17% on a real task and ended at 97.8% with full speed intact. The biggest lever wasn't the model. It was the prompt.
Our Journey to Automated Code Review (We're Still Figuring It Out)
An honest account of automating code review with AI. What works, what backfired, and the one rule we won't break: no self-clearing.
Epics Are Dead: Planning When Work Ships in Days
The Epic was a holding pen for months of slow delivery. When a milestone ships in days, that tier is dead weight. Here's the three-tier model that replaces it.
Stop Measuring AI by Test-Pass Rate
Green tests prove the AI did what it tried, not that it was worth trying. The real metric: would a senior engineer merge it, and how to benchmark that.
Build Skills, Then Loop Them Into a Super-Agent
A clever one-shot prompt answers a turn. A library of named skills plus a loop compounds. How to go from AI that helps you type to AI that runs a process.
Custom Dev Tooling: From Out of Reach to Non-Negotiable
Bespoke internal tools used to cost a team-quarter. Now they cost an afternoon, so not building your own rails is the expensive choice. The new math.
Dogfooding: The Difference Between Ideas and Results
Ideas are free and all sound good. Using your own product in anger is the only honest test. Why dogfooding teams ship truer products, and how to start.
First Principles Are the New Scarce Skill
When the model can build almost anything, the bottleneck moves from how to what and why. The scarce skill is deciding what's actually worth building.
91% Using AI. 11% Shipping. Which Are You?
Four stages of AI adoption: Experimenting, Piloting, Shipping, Compounding. A quick assessment to find where you are and what it takes to move forward.
The Mid-Level Trap: Why Your Best Developers Are Blocking AI Adoption
Mid-level developers resist AI tools, not because the code isn't good enough, but because "good enough" threatens their identity. Here's how to fix it.
Stop Giving AI Tools to Juniors
Everyone thinks AI tools suit juniors. Wrong: seniors spot mistakes, juniors accept everything. Why your AI rollout should start with the skeptics.
How to Get Senior Engineers to Adopt AI Tools
Your seniors are skeptical of AI tools. Good. That skepticism is why they get the best results once they adopt. Here's the tactical playbook.
Vibe Engineering vs. Vibe Coding: Know the Difference
Vibe coding accepts whatever AI produces. Vibe engineering uses AI while staying suspicious. One ships demos, the other ships production code.
The 11pm Fix: Why Plans Fail on Monday
Every plan looks good on Friday. Then Monday happens. What 11pm fixes teach you about planning, and how to build plans that survive reality.
Compounding Engineering: The 4-Step Loop
Most engineering makes the next feature harder. Compounding engineering flips it: a Plan, Delegate, Assess, Codify loop where each cycle makes the next easier.
The Integration Layer Your Business Is Missing
Your systems are wired point-to-point, so nothing talks. Build an integration layer instead, and every new system gets easier to add.
Systems-First Design: Stop Adding, Start Decomposing
Every new tool adds complexity. Systems-first design decomposes problems into primitives and extends instead of adding, shrinking complexity over time.
The Implementation Chasm: Why Forward Deployed Engineers Win
70% of tech projects fail in the gap between builders and operators. Forward deployed engineers close that gap. Here's how the model works.
What Operators Know That Consultants Don't
Consultants see the org chart. Operators see what actually runs the business. Why operator experience changes how you build technology.
Why 95% of AI Projects Fail (And What Mid-Market Companies Can Do About It)
MIT research says 95% of AI pilots fail, and 84% are leadership failures, not technology. Why mid-market projects stall, and how to get yours shipping.
No field notes match that — try a different search or category.