The Growth Project
Podcast
Pilot to Production
The Growth Project podcast. Two hosts, Sam and Maya, turn each field note into a sharp, practical conversation about getting AI from pilot to production: what works, what fails, and the moves the survivors make.
Hosted by Sam & Maya · 22 episodes
-
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 exactly why they'll get 10x results. Here's the tactical playbook for adoption.
-
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: 95% of AI pilots fail. 84% are leadership failures, not tech.