Your AI dashboard is green. IDE autocomplete acceptance is at 40%. Pull requests are up 30%.
And yet, your quarterly roadmap is still slipping, your on-call rotation is exhausted, and shipping a routine feature still takes three weeks.
We are falling for the oldest trap in engineering: local optimization. We spent millions on AI coding tools to make typing 10x faster, while ignoring the fact that typing was never the bottleneck.
To see what is actually slowing you down, you don't need another AI observability platform. You need a boring, decades-old tool from the Lean manufacturing playbook: Value Stream Mapping (VSM).
TL;DR: AI compresses coding time, which just creates massive traffic jams at code review, security, and deployment. VSM maps your entire delivery pipeline—separating active work from idle wait time—so you stop automating broken steps and fix the real constraints.
The Trap: Fast Code, Slow Delivery
Before LLMs, our bottlenecks were mostly mechanical. Engineers spent hours writing boilerplate, setting up test harnesses, and waiting on slow CI builds.
AI crushed that "touch time." Scaffolding a service or writing unit tests now takes ten minutes instead of four hours.
The problem? That code doesn't ship itself. When you speed up one step in a messy system without looking at the whole pipeline, two things happen:
- The bottleneck moves downstream. That 10-minute AI-generated PR now sits in a queue for three days waiting on a senior engineer to review it, a security team to sign off, or a staging environment to free up. You didn't speed up delivery; you just built a bigger parking lot in front of your merge queue.
- You automate waste. If your product specs are vague and your architecture has zero guardrails, AI will happily generate 800 lines of plausible-looking code that solves the wrong problem. Now your senior devs spend four hours debugging subtle hallucinations instead of building.
Lines of code and PR counts are vanity metrics. End-to-end lead time is the only number that matters.
What Is VSM? (Yes, It’s From the 1950s)
Value Stream Mapping isn't new. It came off the Toyota factory floor in the mid-20th century and was popularized in software by the DevOps movement years ago.
At its core, VSM is just a whiteboard exercise where you draw every single step it takes to get an idea into production, and you write two numbers under each box:
- Touch Time: How long someone (or an AI agent) is actively working on the ticket.
- Wait Time: How long that ticket sits completely untouched in a backlog, a PR queue, or an approval inbox.
In most software orgs, touch time is only 10% to 20% of total lead time. The other 80% is pure waiting. Pre-AI, we used VSM to spot where humans were blocked. Today, we use it to spot where AI speed is colliding with human review limits and missing context.
How to Actually Use It
Don't overcomplicate this with enterprise software. Grab a whiteboard with your team, pick a recent feature, and trace it from ticket creation to production deploy.
-
Map the whole thing, not just the repo. Start when the product requirement is written, not when
git branchis run. End when the code is live in prod, not when the PR is merged. - Do the math on Flow Efficiency. Divide total touch time by total lead time. If a feature took 6 hours of active coding/reviewing across 12 days of calendar time, your flow efficiency is roughly 6%. Buying a faster LLM won't fix a 94% wait problem.
- Mark the rework loops. Draw arrows backward every time a PR gets bounced for missing context, fails security checks, or breaks integration tests. In the AI era, rework loops are where your velocity actually goes to die.
- Fix the process before you add agents. Follow the Lean order of operations strictly:
- Cut redundant approvals and useless meetings.
- Simplify handoffs between product, dev, and security.
- Standardize the context you feed into your tools (like clear specs and deterministic linters).
- Automate the boring, predictable stuff with regular scripts first, and AI agents second.
The Flashlight You Actually Need
VSM won't tell you how to write a better system prompt. It tells you whether you even need one.
Right now, most engineering teams are stumbling around in the dark, throwing AI budgets at the one part of the job engineers were already decent at—writing code—while leaving the rest of the delivery pipeline held together with duct tape and Slack threads.
Turn on the flashlight. Map the stream, find where the work is actually sitting idle, and fix that first.
Over to You
- Where is work actually stalling on your team right now? If you trace your last shipped feature from idea to prod, what percentage was active work vs. waiting in queues?
- Are AI PRs slowing down your reviews? Have you seen code review become your new primary bottleneck over the last year?
- What metric do you actually trust? Now that LOC and PR counts are completely gamed by autocomplete, how are you measuring real engineering throughput?
Top comments (0)