There's a line item in every sprint that nobody tracks. It doesn't appear in Jira. It's not in your velocity metrics. It's not in your retrospectives. But it's eating 20-35% of your engineering capacity.
I call it the Understanding Tax: the time developers spend figuring out what to build before they write a single line of code.
The Invisible 90 Minutes
Watch a senior developer pick up a complex ticket. Here's what actually happens:
Minutes 0-15: Read the ticket. Re-read the ticket. Open Slack to ask the PM what "improve the checkout flow" actually means. Wait for response.
Minutes 15-35: Grep the codebase. Open 12 tabs. Find the checkout controller. Trace the call path to the payment service. Discover the payment service calls two different providers depending on the region. The ticket didn't mention this.
Minutes 35-55: Read the git blame on the payment service. Find a PR from 8 months ago that refactored the provider selection logic. Read the PR description. Realize the current behavior is intentional, not a bug. The ticket implies it's a bug.
Minutes 55-75: Slack the engineer who wrote that PR. They're in a different timezone. Leave a message. Context-switch to another ticket. Come back to this one tomorrow when they respond.
Minutes 75-90: Finally understand the full picture. Start planning the actual implementation.
Ninety minutes. And the developer hasn't written a line of code.
Why Nobody Measures It
The Understanding Tax is invisible because:
It's distributed. No single block of time is labeled "understanding." It's 5 minutes here, 20 minutes there, a Slack thread that takes 3 hours to resolve because of timezone gaps.
It's expected. Every estimate implicitly includes it. When an engineer says "3 days," they mean "1 day to understand, 1.5 days to build, 0.5 days to test." But the breakdown is never explicit.
It's unmeasured. No tool tracks "time to first keystroke" — the gap between ticket assignment and the first meaningful code change. If you measured it, you'd find it's 30-50% of total ticket time for complex work.
It scales with team size. A 5-person team where everyone knows the full codebase has a low Understanding Tax. A 50-person team with 12 microservices and 3 years of accumulated decisions has an enormous one.
The Math
Let's make it concrete. A team of 20 engineers. Average salary: $180K/year ($86/hour loaded). Each engineer works on 3-4 complex tickets per sprint.
If the Understanding Tax averages 60 minutes per ticket (conservative):
- 20 engineers × 3.5 tickets × 1 hour = 70 hours per sprint
- 70 hours × $86/hour = $6,020 per sprint on context acquisition
- That's $156,520 per year — almost an entire engineer's salary — spent on grepping, Slacking, and reading old PRs.
For a 50-person engineering org, triple it: $400K+ per year.
And this is before you count the indirect costs: context switches that kill flow state, decisions made with incomplete information that cause regressions, and the morale drain of spending your morning Slacking instead of coding.
Why It's Getting Worse
Three trends are amplifying the Understanding Tax:
1. AI Tools Made Writing Faster, Not Understanding
Copilot and Cursor reduced the "writing code" portion of a ticket from, say, 4 hours to 2 hours. Great. But the "understanding what to write" portion stayed the same or got worse — because now the codebase is growing faster (more AI-generated code to understand).
The ratio shifted. Understanding used to be 30% of ticket time. Now it's 40-50%. The bottleneck moved.
2. Remote Work Broke Ambient Knowledge
In an office, you overhead conversations. You saw who was working on what. You could tap someone on the shoulder. Remote work eliminated ambient knowledge transfer. Now every piece of context requires an explicit, asynchronous request.
3. Microservices Multiplied Context Boundaries
A monolith has one codebase to understand. A microservices architecture has 15. Each service has its own patterns, its own conventions, its own tribal knowledge. The Understanding Tax multiplies with every service boundary a ticket crosses.
How to Measure Your Understanding Tax
You can't fix what you can't measure. Here's a simple approach:
For one sprint, ask each engineer to track two timestamps per ticket:
- When they were assigned the ticket
- When they made their first meaningful code change (not a branch creation — actual code)
The gap between these is your Understanding Tax. It includes reading, Slacking, grepping, tracing, and all the other context-acquisition activities.
What you'll find:
- Simple tickets (bug fixes in familiar code): 15-30 minutes
- Medium tickets (features in known areas): 45-90 minutes
- Complex tickets (cross-service changes, unfamiliar code): 2-4 hours
- Legacy tickets (code nobody on the team wrote): 4-8 hours
If your weighted average is above 60 minutes, you have a significant Understanding Tax problem.
How to Reduce It
The Understanding Tax isn't a tooling problem or a process problem. It's a knowledge architecture problem. Your codebase contains all the answers — who changed what, when, why, and what depends on what. The problem is that this knowledge is buried in git history, scattered across files, and locked in the heads of 2-3 senior engineers.
The solution is making codebase knowledge accessible:
Map tickets to code automatically. When a ticket comes in, instantly identify the affected files, functions, and dependencies. This eliminates 30-40 minutes of manual grepping.
Surface tribal knowledge from git history. Every PR description, every commit message, every code review comment is context that future developers need. Extract it and attach it to the relevant code.
Show dependency chains before coding. If changing function A affects services B and C, engineers should know that before they start — not when B and C break in staging.
Track who knows what. When an engineer needs context, they should instantly know who last modified this code, who reviews it most often, and who has the deepest history with it.
This is what Glue does. Not because we set out to reduce the Understanding Tax — but because we measured our own, found it was obscene, and built the tool we wished existed.
The Takeaway
Your team's velocity problem probably isn't a coding problem. It's an understanding problem. The 20-35% of engineering time lost to context acquisition is the single largest productivity lever most teams haven't pulled.
Measure it. You'll be horrified. Then fix it.
Originally published on glue.tools. Glue is the pre-code intelligence platform — paste a ticket, get a battle plan.
Top comments (0)