The Velocity Lab

The Velocity Lab

By Dave O'Dell and Dan McAulayBusinessTechnology
Download on the App Store

The Velocity Lab episodes

  • Why Google Can't Move Fast (And Two Guys With Six Agents Can)

    Episode Summary

    Thirteen months ago DHH called AI "slop" and a fancy autocomplete. Today he runs his own agent-orchestration project and reviews PRs from an inbox. That turnaround is the jumping-off point for a bigger question: why can't companies with the best engineers in the world and effectively unlimited resources move as fast as two people with six agents?

    Dave and Dan argue the bottleneck was never talent or compute. It's process — the PRD review, the design doc meeting, the meeting about the meeting — and you don't fix that by adopting AI slowly.

    Key Topics

    • DHH's 13-month reversal, and what it says about where the skeptics land
    • Why unlimited resources stopped being a moat — everyone has them now
    • Two people, six agents: what a two-person company actually ships in a year
    • The human-to-human bottleneck is bureaucracy, not conversation
    • The two adoption paths: slow drip, or pull your best engineers off everything for 6–12 months
    • Why flattening the org is the precondition, not the reward — and what managers should automate first
    • Building your own tools instead of buying: the booking and billing stack behind App Vitals
    • Notable Quotes

      • "Oh my God, how cute, someone's still paying you to write code? Good luck, buddy."
      • "Take a handful of your best engineers, remove them from any company function whatsoever, and say, we are going to adopt AI for every single process across the board."
      • "You gotta flatten your org or you're not gonna be competitive."
      • "Let builders build. You have to do it. You can't stop 'em."
      • About The Velocity Lab

        Dave O'Dell and Dan McAulay work inside engineering organizations every day helping them ship faster with AI. No hype, no BS — just what's working in the field.

        Subscribe: RSS

        13 min
      • The Model Doesn't Matter Anymore (Here's What Does)

        Episode Summary

        Open-source models have caught up to Sonnet on the benchmarks, so does it still matter which model you use? Dave and Dan argue the model stopped being the differentiator a while ago. They break down why they default to Sonnet over Opus, why a free model matching Sonnet still doesn't make them switch, and what you're actually paying Anthropic for.

        Key Topics

        • Is the model still the moat? Why open-source parity with Sonnet doesn't change how they work
        • Trust as the real switching cost — you don't adopt someone else's evals, you build your own confidence
        • Default your org to Sonnet, not Opus (Sonnet runs ~40% cheaper) — and when to reach for Opus
        • The spend framing: expect an engineer to run $50k/year on an LLM, and expect them to at least double their throughput for it
        • Don't fragment across tooling — pick a stack and build a system around it
        • Anthropic's real product is enterprise adoption: a whole-org toolset plus hands-on help getting teams to actually use it
        • Notable Quotes

          • "You should expect an engineer to spend $50,000 a year using an LLM. But they should double their throughput."
          • "Make your default model Sonnet."
          • "We can prove the newer models don't really matter, 'cause we don't even use them."
          • About The Velocity Lab

            Dave O'Dell and Dan McAulay work inside engineering organizations every day helping them ship faster with AI. No hype, no BS — just what's working in the field.

            Subscribe: RSS

            16 min
          • I Was Dead Set Against This Feature (Then I Shipped It)

            Episode Summary

            Dave was dead set against building a Human-in-the-Loop mode for Shipwright — then Dan shipped it overnight using autonomous agents, and Dave came around completely. This episode is the story of why they built it: a low-risk on-ramp that lets AI-nervous teams watch autonomous coding happen, approve each step, and build trust before handing over the keys.

            Key Topics

            • Why Human-in-the-Loop exists — meeting teams that are nervous about AI escaping the sandbox or leaking secrets
            • The three ways to try Shipwright: Claude Code plugins (one task at a time) → local Human-in-the-Loop → fully autonomous in your own cloud
            • The feature was built by autonomous agents overnight — the medium is the message
            • Trust as the real product: HITL is a confidence-builder, not the destination
            • Laptop vs. cloud permissions — why you'd never run full-autonomous on a machine holding all your tokens
            • Getting developers out of the terminal without taking away the safety of watching
            • Notable Quotes

              • "I was dead set against this... and now I'm going the opposite."
              • "You don't write code anymore. That's the real experience."
              • "Turn your phone off, go boating, and a day later it's shipped."
              • About The Velocity Lab

                Dave O'Dell and Dan McAulay work inside engineering organizations every day helping them ship faster with AI. No hype, no BS — just what's working in the field.

                Subscribe: RSS

                14 min
              • The System Beats the Model

                Episode Summary

                Teams are finally staring at their AI bills — and the reflex is to use the LLM less. Dave and Dan make the opposite case: the answer isn't a cheaper model or less AI, it's a system. The harness around the model — how you plan, review, patch, and deploy — matters more than which model you run.

                Key Topics

                • The harness beats the model — a real system on an older/cheaper model out-executes ad-hoc prompting on the latest one.
                • Why bills exploded — adoption without measurable speed gains, and the instinct to "just stop using LLMs" is the wrong lever.
                • Deterministic pipelines — code → review → patch → deploy, ~14 steps each, so every change gets the same treatment every time.
                • Model selection per task — only ~3% of tasks hit the expensive default (Opus); 70%+ run on a model 84% cheaper.
                • Systems are optimizable, ad-hoc work isn't — you can't standardize or tune what everyone does differently.
                • Enforcing org standards — one shared system means changing how everyone builds APIs or runs migrations is trivial.
                • Notable Quotes

                  • "The harness — basically how you use the LLM — is much more important than the actual model itself."
                  • "If you don't have a system, then you cannot enforce standards across your organization."
                  • About The Velocity Lab

                    Dave O'Dell and Dan McAulay work inside engineering organizations every day helping them ship faster with AI. No hype, no BS — just what's working in the field.

                    Subscribe: RSS

                    18 min
                  • Adopt Autonomous Coding Now, Or Find a New VP of Engineering

                    Episode Summary

                    A month ago, Dave and Dan weren't giving this advice. Now they're telling every client — from solo founders to the Fortune 500 — the same thing: adopt autonomous coding immediately. The technology crossed the quality threshold, and this is now a CEO-level decision, not an engineering preference.

                    Key Topics

                    • Why the advice changed this month — autonomous agents now ship real, high-quality code, not AI slop
                    • Shipwright (free, open-source, runs in your own infrastructure) vs. Devin (commercial, $25B valuation, raising $1B)
                    • Why adoption is a CEO's call — developers won't volunteer to stop writing code
                    • Developers get paid to plan and review, not to write code — and that's the part that doesn't change
                    • Flatten your org: top-heavy, management-heavy structures break under autonomous velocity
                    • The economics — roughly $10–20 per PR/feature in tokens, optimized down toward $10
                    • Notable Quotes

                      • "If your VP of engineering is not pounding on the door saying 'we need to adopt this,' you should think about getting a different VP of engineering."
                      • "A lot of developers think they're getting paid to write code. That is over with."
                      • About The Velocity Lab

                        Dave O'Dell and Dan McAulay work inside engineering organizations every day helping them ship faster with AI. No hype, no BS — just what's working in the field.

                        Subscribe: RSS

                        11 min
                      • You're Not Getting Paid to Code Anymore (And That's Good News)

                        Episode Summary

                        Dave and Dan make the case that developers are no longer getting paid to write code — and explain why that's actually better news than it sounds. Drawing from real client work across Fortune 500s and one-person startups, they walk through what the new engineering job actually looks like: planning, reviewing, and exercising technical judgment while autonomous agents do the typing.

                        Key Topics

                        • Why paying developers to write code is now a waste of money — and what to do instead
                        • The new developer job: plan, deploy, review, and manage autonomous agents
                        • How junior engineers can level up faster in the AI era
                        • Why the transition from coder to engineer is harder than it sounds (and why Dave wishes AI hadn't happened)
                        • What engineers should actually be spending their time on: CI, deployments, incidents, and bigger systemic problems
                        • How Shipwright fits into the autonomous coding workflow — and why engineers fear it
                        • Notable Quotes

                          • "There is absolutely no reason at this moment to pay developers to write code. That is an absolute waste of money."
                          • "No one is paying you to type anymore. No one's paying you to look at a terminal. That is over with right now."
                          • "Your job was never really to write code. Code was a byproduct of judgment."
                          • About The Velocity Lab

                            Dave O'Dell and Dan McAulay work inside engineering organizations every day helping them ship faster with AI. No hype, no BS — just what's working in the field.

                            Subscribe: RSS

                            15 min
                          • Shipwright vs. Devin: The $26B Competitor We Accidentally Built Against

                            Episode Summary

                            Dave and Dan break down how Shipwright, their open-source autonomous coding agent, stacks up against Devin AI — a $26B-valued competitor. They cover the key differences: open source vs. black box, runs in your infrastructure vs. Devin's cloud, built on Claude Code for full extensibility, and the one thing Devin doesn't do that Shipwright does — deploy.

                            Key Topics

                            • Why they accidentally built a Devin alternative while building for their own clients
                            • Open source (MIT) vs. closed black box — what you can and can't customize
                            • Your infrastructure vs. Devin's cloud — the security and flexibility gap
                            • Claude Code as the foundation: plugins, skills, and the extensibility advantage
                            • Deployment: Shipwright merges and deploys, Devin stops at the PR
                            • Cost model: Shipwright's only cost is tokens; Devin adds licensing at every seat
                            • Notable Quotes

                              • "Shipwright literally built Shipwright. The last 1,000 pull requests in Shipwright were all written by Shipwright."
                              • "Devin is a black box. You have no idea what it's doing. The only knobs you can turn are the ones they give you."
                              • About The Velocity Lab

                                Dave O'Dell and Dan McAulay work inside engineering organizations every day helping them ship faster with AI. No hype, no BS — just what's working in the field.

                                Subscribe: RSS

                                16 min
                              • How We Accidentally Built an Open-Source Alternative to Devin

                                Episode Summary

                                Dave and Dan tell the origin story of App Vitals — from LiveKit AI-voice tutorials to an AI-transformation consultancy to shipping their own open-source autonomous coding agent. They unpack the 37signals philosophy that shapes how they build, how a mobile-dev side project quietly became Shipwright, and why test readiness is the real on-ramp to autonomous programming.

                                Key Topics

                                • The 37signals model — build products for yourselves first, let consulting pay the bills
                                • How Shipwright started as a Claude Code plugin and grew into a managed autonomous coding agent
                                • Shipwright vs. Devin — open source, runs in your own infrastructure, fully customizable vs. a closed SaaS black box
                                • Coding asynchronously in Slack: planning and reviewing while the agent handles execution, PRs, review, and deploy
                                • The ski-trip story — building and deploying a website by voice from a chairlift, no laptop
                                • Test readiness as Phase Zero: fixing flaky, slow, low-coverage tests before you can trust an agent to ship
                                • Notable Quotes

                                  • "There's no reason to be in a terminal. There's no reason to write code anymore."
                                  • "While I was skiing, it built a different version of solitaire and deployed it to Vercel — and I never saw my laptop the whole day."
                                  • "We ship hundreds of PRs a week for us and our clients with no human interaction."
                                  • About The Velocity Lab

                                    Dave O'Dell and Dan McAulay work inside engineering organizations every day helping them ship faster with AI. No hype, no BS — just what's working in the field.

                                    Subscribe: RSS

                                    17 min
                                  • You're Choosing Not to 10X Your Team for Free

                                    Episode Summary

                                    Major announcement: Dave and Dan are open-sourcing Shipwright, the autonomous coding agent they've been building since November. It takes you from PRD to production deployment with no human intervention ~99% of the time — and it built itself. Across ~500 pull requests, they say they barely read a line of code. The core provocation for leaders: if a free tool can 10X your engineering throughput and you choose not to adopt it, that's a decision you'll have to justify.

                                    Key Topics

                                    • Open-sourcing Shipwright (MIT) — PRD → plan → code → tests → PR → CI → review → merge → deploy, mostly hands-off
                                    • "Shipwright built Shipwright" — ~500 PRs, the founders read essentially none of the code
                                    • The 14-step dev-task checklist (TDD, green CI, docs) vs. raw Claude Code's half-baked PRs
                                    • Human-in-the-loop only where it must be — Terraform applies, secret/key updates, GitHub access
                                    • Run it in your own cloud (EC2/EKS/AKS/Kubernetes) — you control security, secrets, and tokens
                                    • The economics: 10X throughput for free, but it also 10X's token spend and pressures headcount
                                    • Portable by design — a thin Claude shim means it can move to OpenCode/Pi and open-source LLMs later
                                    • Notable Quotes

                                      • "If you have an engineering team and you're choosing not to adopt this, you are choosing not to 10X your throughput on purpose."
                                      • "Shipwright created Shipwright. It has 500 pull requests... I didn't look at a single line of code."
                                      • About The Velocity Lab

                                        Dave O'Dell and Dan McAulay work inside engineering organizations every day helping them ship faster with AI. No hype, no BS — just what's working in the field.

                                        Subscribe: RSS

                                        27 min
                                      • We Built an Agent That Ships 85 PRs a Week

                                        Episode Summary

                                        Dave and Dan pull back the curtain on the autonomous coding agent they built — an agent that lives in the cloud, takes instructions in Slack, and runs a full plan-to-deploy pipeline 24/7. In the last seven days alone, their agents opened 85 pull requests. They walk through exactly how the system works and why "build the system" beats "write the code."

                                        Key Topics

                                        • Talk to your agent in Slack — an agent that lives in the cloud, writes code, and runs around the clock.
                                        • 85 PRs in a week — the metric that frames the whole episode, and what it says about building systems over writing code.
                                        • Brainstorm → PRD → Plan → Tasks — the interactive front of the pipeline, where the human stays in the loop.
                                        • The four crons — dev task, review, patch, and deploy fire every 30 minutes and only burn tokens when there's real work pending.
                                        • Right-sized tasks — why a 1,000-line PR fails and how the plan session breaks work into manageable, one-commit-sized tickets.
                                        • Mandatory canary deploys — merge to main, canary, promote to prod, with automatic rollback and Slack alerts when telemetry looks wrong.
                                        • Everything is metered — PostHog metrics on every step, used to wake up to "what did the agents do overnight?" and to keep improving the system.
                                        • Notable Quotes

                                          • "We said it a million times — you don't need to code anymore if you build a system. So we built a system."
                                          • "You're gonna flip your laptop open on Monday morning and there's 24 PRs — all done, all passing green, all ready to be reviewed and deployed."
                                          • "If you build the right system, not only do you not need to code — you don't even need to watch your deploys."
                                          • About The Velocity Lab

                                            Dave O'Dell and Dan McAulay work inside engineering organizations every day helping them ship faster with AI. No hype, no BS — just what's working in the field.

                                            Subscribe: RSS

                                            24 min

                                          About The Velocity Lab

                                          From the publisher's feed

                                          Dave O'Dell and Dan McAulay work inside engineering organizations every day, helping them ship faster with AI — not in theory, but inside their actual teams. Each week they share what they're seeing…