Blog
Insights for engineering leaders
Field notes from building and running autonomous programming inside real engineering orgs — the thinking that shaped Shipwright, and what we're still learning as we install it.
Subscribe
Get the next post in your inbox
At most one email a week, only when there's something worth reading.
What Actually Needs a Human
In a pipeline built to run the rest of itself, two things turned out to need a human: a narrow slice of tasks an agent is deliberately kept away from, and a decision about which tasks those are, made before any agent starts, not inferred mid-run. Getting the first one right took an outage. Getting the second one right took three days to half-undo what we'd just shipped.
Dan McAulay
The Tech Is Ready. Your Org Chart Isn't.
Someone asked us where App Vitals will be in three years. The honest answer is that the models will be further along than anyone's org chart. The constraint was never the technology.
Dave O'Dell
A Step an Agent Could Skip
We'd just built PostHog analytics for a client, so it was the easy thing to reach for — until we started using its numbers to decide how fast we could actually ship, and to back specific claims to clients. That's when a metrics pipeline built out of steps an agent could quietly skip stopped being tolerable, and we tore it out for code that can't be.
Dan McAulay
Two People, Five Automated Departments, and the 200-Person Question
Dan and I haven't written a line of code in eight months. Billing, payroll, marketing, and this podcast all run without us now. Which raises a question we can't stop chewing on: if two people can automate this much, what is a 200-person company actually doing?
Dave O'Dell
Sharing Proof, Not Promises
A client asked how they'd know Shipwright would still be maintained in six months. I wasn't even ready to start the extraction that would answer it — Dave was, and he just began without me. Thirteen days later: 429 commits, a night four things broke at once, and all of it sitting in public git history for anyone to go check.
Dan McAulay
Your AI Adoption Problem Is a Trust Problem
Every company we work with can install the tool in an afternoon. Months later most of them still are not shipping any faster. What actually stands in the way — not the model, not the budget, not the integration — is trust, and it has two halves.
Dave O'Dell
What's Changed Since February
In February, every call started with 'we're behind'; now it starts with 'we bought the tools and nothing moved.' Same panic, different diagnosis — and only one of them points at the actual fix.
Dave O'Dell
Writing With AI, Not By It
LinkedIn shipped a button in July for reporting AI-generated 'slop' — it's been clicked over a million times in three weeks. I write every post on this blog with AI. Here's the distinction I don't think the backlash is making, and what we just shipped to make sure we're on the right side of it.
Dan McAulay
The Better the Model, the Smaller the Harness
Anthropic deleted 80% of Claude Code's system prompt and nothing broke. That one fact tells you almost everything about where AI tooling is heading, and why the scaffolding you build today should be designed to get smaller.
Dave O'Dell
One Winner Per Tick
Two problems ran under our pipeline's crons for months: commands doing more than one job, and work waiting for its turn instead of starting the moment it was ready. Dave tried to fix the second by fusing two commands into one — and broke the first one doing it. Here's how both problems, colliding again and again, finally got solved by the same fix.
Dan McAulay
The Four Skills I Hire For Now, and Not One of Them Is Coding
My wife overheard me talking to an AI agent and said I was good at articulating what I want. That offhand comment turned into the clearest interview rubric I've got: four skills that decide who stays an engineer, and none of them show up in a coding test.
Dave O'Dell
Unlimited Resources Stopped Being a Moat
The best engineers in the world, unlimited GPUs, unlimited tokens — and still shipping slower than a two-person company. The constraint was never resources. It's the layer of process sitting between a decision and the work.
Dave O'Dell
Am I Building the Pointy-Haired Boss?
DHH's argument that over-specifying an agent makes it worse got under my skin. The audit came back clean — and that was the tell. The real complexity wasn't in any single piece. It was in teaching two different systems as if they were one.
Dan McAulay
We Built an Interface So We'd Never Have to Choose a Backend. We Ended Up Deleting All of Them.
The plan was simple: put an interface in front of the todo list, swap backends whenever we wanted, never think about it again. Instead we got two backends an agent couldn't reliably choose between, a GitHub Issues implementation held together with labels and JSON stuffed in a comment, and a concurrency problem GitHub was never built to solve. Here's how that actually became the task store the whole pipeline runs on now.
Dan McAulay
The Model Doesn't Matter Anymore (Here's What Does)
Open-source models have caught up to Sonnet on the benchmarks. We still won't switch. Here's why the model stopped being the thing that matters, and what actually does.
Dave O'Dell
What Loop Engineering's Failures Taught Us — and How Shipwright's Loop Compares
Loop engineering — set a goal, let agents run unattended, wake up to finished work — is the term of the summer. The real incidents behind it are a lot sharper than the guides let on. Here's what separates the ones that worked from the ones that deleted a production database, and how it lines up against Shipwright's own delivery loop.
Dan McAulay
Build What You Need: How Two Side Projects Became One Pipeline
37signals' whole philosophy is build what you need. Turns out that one instinct, followed honestly, is what forced our two separate tools together, got us our first client, and left us still running every piece of it, every day, five months later.
Dan McAulay
The On-Ramp to Autonomous Coding
I was dead set against building a human-in-the-loop mode for Shipwright. It felt like a step backward. Then Dan shipped it overnight — using the very agents I was arguing with — and I changed my mind completely. Here's why the slow lane turned out to be the fast one.
Dave O'Dell
Dave Put OpenClaw on His Pi First. The Todo List I Built After It Is What Actually Lasted.
Dave bought a Raspberry Pi and ran OpenClaw on it first. I followed onto my own Pi a couple weeks later. I didn't stay on OpenClaw long — but the persistent space it gave Bodhi, and the todo list I built once I moved off it, are still recognizably the shape of how Shipwright agents work today.
Dan McAulay
claude-queue, Dispatch, and Shipwright: Running Claude Code Unattended
claude-queue and Dispatch let you hand Claude Code a backlog and walk away. Here's what each one actually does, where they beat Shipwright, and the one thing a bare queue can't do: open the PR.
Dave O'Dell
The Cloud Agent Was Supposed to Write Code. It Ended Up Reviewing It.
I built a system to run Claude Code in isolated cloud sandboxes, chasing full autonomy — parallel features, overnight PRs, the works. Almost none of that survived contact with reality. The one piece that did became the review skill Shipwright runs on today.
Dan McAulay
Shipwright vs. Claude in Slack: Session Launcher vs. Delivery System
Claude in Slack — Claude Tag and the Claude Code integration — is great at starting work. Here's the honest difference between a session launcher and a system that runs your whole delivery backlog.
Dave O'Dell
You Taught Claude Code Every Step. It Still Doesn't Ship.
We taught Claude Code every phase of shipping software — requirements, plan, code, review, deploy — and it still didn't ship on its own. The missing piece was never a skill. It was orchestration. Here's the state machine that ships our own product, hands off, for under $20 a PR.
Dan McAulay
Adopt Autonomous Coding Now, Or Find a New VP of Engineering
A month ago we weren't giving this advice. Now we tell every client — solo founder to Fortune 500 — the same thing: adopt autonomous coding immediately. Here's why it's a CEO's call, not an engineering preference.
Dave O'Dell
The Harness Is All You Need. So We Built One in the Open — and Made It Easy to Leave.
GitHub says the harness — not the model, not the tools — is where the leverage is. They're right. Here's the step past where their argument stops, and why being a thin, open layer on Claude Code beats going fullstack.
Dave O'Dell
Everyone I Talk To Has 'Adopted AI.' Almost None of Them Have.
A head of engineering asked me why some of his devs were burning through tokens while others spent nothing. That question is the whole story. Here's the ladder I've started using to answer it.
Dan McAulay
No One Is Paying You to Code Anymore
We told a client last week there's absolutely no reason to pay developers to write code. Here's why that's the best career news engineers have gotten in decades.
Dave O'Dell
We Accidentally Built an Open-Source Alternative to Devin. Here's How They Compare.
Devin has a $26B valuation and a billion dollars in funding. We built something open-source and self-hosted that does most of the same things, with no per-ACU metering. Here's an honest comparison.
Dave O'Dell
We Didn't Set Out to Compete With Devin — We Just Built the Tools We Needed
A year ago we were making LiveKit voice tutorials. Somewhere between a mobile side project and an epic powder day, we accidentally built an open-source autonomous coding agent. Here's the origin story — and the philosophy underneath it.
Dave O'Dell
A Free 10X Is Sitting Right There. Now Justify Not Taking It.
We open-sourced Shipwright — the autonomous agent that takes you from PRD to production with almost no human in the loop. It shipped ~500 of its own pull requests. The catch isn't the tool. It's that a 10X in throughput is a 10X in your token bill, which turns adoption into a decision only the person holding the purse strings can make.
Dave O'Dell
Your Data Team Is the Bottleneck. Here's How AI Fixes It.
Every company has dashboards nobody reads and engineers constantly fielding data requests. Natural language queries via Claude change the math entirely — and it's not about replacing your data team.
Dave O'Dell
85 Pull Requests in a Week: What Happens When You Stop Writing the Code
Last week our agents opened 85 pull requests. Not drafts, not experiments — reviewed, tested, deployable work. Here's the system behind that number, and why the job that's left is planning and reviewing, not typing.
Dave O'Dell
Where Do Senior Engineers Come From Now?
If AI writes the code, being an engineer becomes planning and reviewing — staff and principal work. But that quietly removes the bottom rung of the ladder. So how does anyone become senior when there's no junior work left to learn from?
Dave O'Dell
Your Engineering Career Was Never as Safe as You Thought
Dan had a therapy session with Claude this week, and it told him something uncomfortable: the 20-year career foundation he thought was solid was a false sense of security all along. Here's what that means for every engineer right now.
Dave O'Dell
You Can't Transform 200 Engineers at Once (So Stop Trying)
Org-wide AI transformation doesn't fail because the technology is broken. It fails because moving 200 engineers at once is a slog. The teams that win start with one team and let the momentum spread.
Dave O'Dell
The AI Free Ride Just Ended
VC-subsidized AI was always going to end the same way Uber did. Anthropic just pulled the subsidies on autonomous coding, and a $200/month plan becomes a $1,000–$5,000/month line item if you keep doing what you were doing.
Dave O'Dell
Testing Is Phase Zero: You Can't Hand Agents a Codebase Nobody Trusts
Every org we walk into has the same broken tests: slow, flaky, thin. That was tolerable when humans shipped. It's disqualifying the moment you want agents to. Here's why testing became the first pillar of repo readiness.
Dave O'Dell
Pick One Project. Crush It. (Why Org-Wide AI Transformation Keeps Failing)
We spent three months trying to transform whole engineering orgs at once. It didn't move the needle. The fix wasn't more time or more people — it was less surface area. Pick one project. Crush it. Then make the rest of the company copy you.
Dave O'Dell
The Three-Month Bet: Why 20% Time Is the Slowest Way to Adopt AI
Every engineering org we work with is spending 20% of someone's time on AI adoption. It's the most expensive way to go slowly. The companies pulling ahead made a different bet — and it's a board conversation, not an engineering one.
Dave O'Dell
Why Non-Technical Entrepreneurs Are Out-AI'ing Professional Engineers
We work inside engineering teams that haven't touched Claude Code, while non-technical founders we meet at dinner parties are shipping production software with it. The gap isn't skill. It's posture — and the engineers are losing on a battle they should be winning.
Dave O'Dell
Notepad to Claude: What a Non-Coder Founder Sees That Senior Engineers Miss
Our friend Brian doesn't write code. He's running a one-person agency that would have required a team of ten two years ago. He moves faster than most of the senior engineers we work with — and the reason is a thing we've started calling the expertise tax.
Dave O'Dell
Stop Shipping the 12,000-Line PR: How to Actually Run a Migration With Claude
Claude can absolutely write the 12,000-line monolith-to-services migration in two days. It will not ship. Here's the three-piece pattern that turns multi-year migrations into a reviewable PR a day — while your team keeps shipping product code.
Dave O'Dell
Let Builders Build: Why AI Velocity Is an Org Chart Problem
AI tooling makes engineers faster. It does not fix architecture committees, low-trust managers, or org charts that punish builders. Why every CTO we work with is starting to have the same conversation with their CEO.
Dave O'Dell
What to Say When the Board Asks About AI
Six questions every board is asking executives about AI right now — inventory, tooling, accountability, ROI, competitive pressure, and institutional knowledge. Here's how to walk in with real answers instead of getting caught flat-footed.
Dave O'Dell
Six Non-Negotiables Before You Turn On Autonomous Programming
You can't just install an agent and walk away. Here's the repo infrastructure that has to be in place before autonomous programming actually works — and why most teams stall on the prep, not the agent.
Dave O'Dell
We Code Autonomously — And Here's Why That's Achievable Today
Dan and I have been coding autonomously for months. Not vibe coding. Actual production systems, 393 PRs in two weeks, 90% test coverage. Here's why we think most engineering teams can get there — and what it actually takes.
Dave O'Dell
AI Coding Assistant vs. AI Agent: Which Does Your Team Actually Need?
Most teams conflate AI assistants and agents — and end up getting half the value from both. Here's how to tell them apart and use each where it actually wins.
Dave O'Dell
The Hidden Cost of AI-Generated Code: Technical Debt You Won't See Coming
AI writes 41% of all code in 2026. Above 40%, rework jumps 20-30%. Here's how to spot the debt before it compounds.
Dave O'Dell
Why AI Makes PR Review Time Slower Before It Gets Faster
Teams with high AI adoption saw a 91% increase in PR review time. That's not a bug in the data — it's a predictable transition you can plan for.
Dave O'Dell
How AI Coding Tools Are Quietly Overloading Your CI Pipeline
Your developers are shipping faster. Your CI bill tripled. Here's why AI adoption and CI architecture are on a collision course most teams aren't prepared for.
Dave O'Dell
DORA Metrics in the AI Era: What They Still Get Right (and What They Miss)
AI tripled your deployment frequency. Change failure rate followed. Here's why DORA still matters—and what it can't see when AI is writing the code.
Dave O'Dell
Why Your Best Engineers Are Resisting AI (And What That's Actually Telling You)
When your strongest engineers push back on AI tooling, most orgs treat it as a change management problem. They're missing the signal entirely.
Dave O'Dell
How to Roll Out Claude Code to Your Engineering Team
Buying Claude Code licenses is the easy part. Here's the actual system that gets your whole engineering org using it — and keeps using it.
Dave O'Dell
Why AI Adoption Fails (and It's Not the Technology)
Most AI adoption programs fail before the first developer writes a single AI-assisted line of code. Here's why—and what actually works.
Dave O'Dell
One Tool for Everyone: Claude Beyond the Engineering Team
Claude isn't just for engineers. Here's how marketing, ops, and data teams are getting massively accelerated—and why one tool for everyone is the real unlock.
Dave O'Dell
392 Pull Requests in Two Weeks: How We Built an Autonomous Coding Pipeline
Dan and I shipped 392 PRs in two weeks — and we personally opened fewer than 10 of them. Here's how our autonomous pipeline actually works.
Dave O'Dell
Who Should Lead Your AI Engineering Transformation?
It's not an AI Engineer. It's a Principal Engineer who hasn't written a line of code in six months — but has built systems that do.
Dave O'Dell
The Google Meet Epiphany: Two Engineers, One Claude Session, Zero Friction
We accidentally discovered you can pair-plan with Claude Code over Google Meet. Dan talks, Dave's mic picks it up, and the session gets both voices.
Dave O'Dell
We Built 254 Pull Requests in 7 Days. Here's the System Behind It.
Dan and I shipped 254 PRs in seven days using AI agents — most while we slept. This is what we built and how it actually works.
Dave O'Dell
Is Code the Next Abstraction Layer? How Agentic AI Is Redefining What Software Engineers Actually Do
One of us loves coding. The other built an agentic coding platform without writing code. Neither of us has written a line in months. So what does that mean for software engineers?
Dave O'Dell
Voice, Remote Sessions, and the 1M Token Window: Claude Code's Biggest Week
Claude Code added voice input, remote session control, and a 1M token context window. Here's what actually changed our workflow—and what didn't.
Dave O'Dell
The Velocity Engineering Playbook: Accelerating Everything, Not Just Code
Your AI tools made code generation faster. But code is 20% of the journey to production. Here's the comprehensive playbook for accelerating the other 80% — and why velocity engineering matters more than any single tool.
Dave O'Dell
The Velocity Trap: Why Giving Every Engineer an AI Tool Doesn't Work
Giving every engineer access to every AI tool is a waste of money. Here's the scattershot mistake killing adoption—and what actually works.
Dave O'Dell
Why Your AI Coding Assistant Is Just Fancy Autocomplete
You gave an AI tool zero context about your codebase and it produced generic garbage. Shocking. Here's why context infrastructure is the difference between autocomplete and actual AI-assisted development.
Dave O'Dell
Shipwright: How We Built a Mostly Autonomous Dev Pipeline for Claude Code
We built a Claude Code plugin that plans projects, executes tasks, runs multi-agent code reviews, and merges PRs — mostly without human intervention. Here's how it works and what we learned.
Dave O'Dell
Code Review Is Your New Bottleneck (And AI Made It Worse)
AI tools made your engineers faster at writing code. Now PR review queues are backed up, PR sizes have ballooned 154%, and your cycle time hasn't budged. Sound familiar?
Dave O'Dell
How to Measure AI Adoption ROI (When Nobody Can Tell If It's Working)
77% of organizations can't track AI ROI. Here's a practical framework for measuring what actually matters — and why most teams are measuring the wrong things.
Dave O'Dell
The AI Champion Playbook: How One Engineer Can Transform Your Whole Team
Top-down mandates don't work. Tool rollouts don't work. What works is one engineer who's already bought in — and a system that lets them spread it.
Dave O'Dell
Licenses Without Lift: The $100K AI Tool Problem Nobody Talks About
Your company spent six figures on AI coding tools. Usage is at 15%. The early adopters love it. Everyone else opened it once. Here's what's actually going wrong — and it's not a training problem.
Dave O'Dell
The AI Velocity Assessment: Finding Where Your Pipeline Is Really Stuck
Your team adopted AI tools. They're not shipping faster. Before you invest in a 6-month transformation, spend 4 weeks finding out exactly why — and what to do about it.
Dave O'Dell & Dan McAulay
3 Enterprise AI Adoption Mistakes That Kill ROI (And What Works Instead)
Compliance theater. Tool mandates. Ignoring early adopters. Three patterns that kill AI adoption at every enterprise—and what works instead.
Dan McAulay
Why AI Coding Tools Don't Make Teams Ship Faster (And What Does)
Your team rolled out AI coding tools. Code output is up. Nothing's shipping faster. Here's the real bottleneck—and how to fix it.
Dave O'Dell
Two Engineers, AI Assistants, and the Output of Twenty
How App Vitals operates as a 2-person team with AI force multiplication — and what that means for how we think about engineering velocity.
Dave O'Dell
Why Your AI Coding Assistant Keeps Getting Your Codebase Wrong
By week three, your team's AI assistant is suggesting patterns you don't use. This is the context problem—and it has a surprisingly simple fix.
Dave O'Dell
Why Tool Rollouts Fail (And What Works Instead)
Top-down AI mandates fail. Champion-based adoption works. Here's the 12-week pilot model we use to make AI stick.
Dan McAulay
Your CI Pipeline Is the New Bottleneck
AI writes code 3x faster, but if your CI takes 45 minutes, you just moved the bottleneck. Here's where the real velocity gains are hiding.
Dave O'Dell