Reducing Context Gaps to Accelerate Software Development

The real bottleneck in software development isn’t writing code--it’s understanding it. Dennis Pilarinos, who’s spent two decades building developer tools at Microsoft, AWS, and Apple, argues that the growing reliance on AI coding agents is exposing a deeper systemic flaw: the context gap. These agents don’t fail because they’re bad at syntax--they fail because they lack organizational memory, business intent, and the invisible logic behind legacy decisions. The non-obvious consequence? Teams that automate context acquisition--both for humans and AI--will outperform others not by writing code faster, but by reducing the hidden cost of relearning. This post is essential for engineering leaders, developers, and AI tool builders who want to move beyond superficial productivity gains and build systems where knowledge compounds instead of decays.

Why the Obvious Fix Makes Things Worse

When developers get stuck, the default solution is to ask a teammate. It’s human. It’s fast. It works--until it doesn’t. The downstream effect of this seemingly harmless pattern is a silent tax on team velocity. Every interruption fractures focus. Every tribal knowledge dependency creates a single point of failure. And when AI agents enter the loop, they don’t solve this problem--they amplify it. Because unlike humans, agents have no memory of past conversations, no participation in standups, no accidental overhearing of design debates. They’re strangers to the system.

"We started Unblocked because we were going to call the company Bother--as in, you don’t bother me, I don’t bother you. We can get answers and move on very quickly."

-- Dennis Pilarinos

That quote isn’t just a joke. It’s a systems-level diagnosis. The real cost of context gaps isn’t measured in hours spent debugging--it’s measured in repeated hours. A junior engineer asks the same question three times because the answer lived in a Slack thread from six months ago. An AI agent implements a feature the wrong way because it guessed based on public GitHub patterns, not the team’s internal exception-handling philosophy. The system responds by creating more work: reviews, rewrites, outages.

Most teams treat context as a search problem. “Just grep the code,” they say. But as Dennis points out, even humans face a Memento-like reality--constantly relearning, constantly reconstructing. The agents inherit this broken environment and make it worse, not because they’re flawed, but because they expose the flaw: we never built systems that preserve why decisions were made, only what was done.

This creates a feedback loop. The more code AI writes, the more pull requests pile up. The more PRs there are, the harder it is to maintain quality--especially when reviewers lack context too. Teams respond by adding more process, more gates, more meetings. Velocity drops. Burnout rises. The system routes around the solution by becoming slower, more bureaucratic, and less adaptive.

The Hidden Cost of Fast Solutions

AI coding tools promise speed. Type a prompt, get working code. But speed without context is like driving at night with the headlights off--thrilling until the crash. The immediate benefit is undeniable: a feature that took days now takes minutes. The hidden cost? Technical debt that compounds invisibly.

Consider the lifecycle of an AI-generated PR. It passes linting. It has tests. It looks correct. But six weeks later, it breaks in production because it violated an undocumented constraint--say, a legacy system that can’t handle async writes. The AI didn’t know because no one told it. The human didn’t catch it because they assumed the AI “knew.” The system failed not from malice, but from silence.

This is where conventional wisdom collapses. “Just read the docs,” we say. But Dennis is blunt: “I’ve never met a single team that says our docs are up to date and well organized.” Docs decay the moment they’re written. Code evolves. Teams restructure. The why vanishes.

"The way that you would get information historically was typically interrupting your coworkers or spending a bunch of time digging through information... the actual coding part of it is relatively insignificant."

-- Dennis Pilarinos

The irony is thick. We built CI/CD to automate testing and deployment, but we still rely on human memory for the most critical part of development: understanding. And now we expect AI to operate in that same memory hole. The result? AI doom loops--where the agent keeps guessing, failing, regenerating, and failing again, because it has no working set.

The real bottleneck isn’t compute. It’s context persistence. Teams that treat this as a first-class problem--by indexing PRs, Slack threads, architecture decisions, and code comments into a queryable knowledge layer--don’t just help AI. They help themselves. They create a flywheel: every interaction becomes context for the next. Every review improves the system’s collective memory. The payoff isn’t immediate. It’s 12--18 months out, when new hires ship their first PR in a week, not a month.

What Happens When Your Competitors Adapt

The most underappreciated advantage isn’t speed--it’s resilience. Dennis observes that companies with strong internal systems adopt AI better. Why? Because their context is already structured. They don’t need to unblock knowledge--they’ve been doing it for years.

But here’s the twist: the teams that win aren’t the ones with the most AI agents. They’re the ones who use AI to reduce dependence on tribal knowledge. They treat every agent interaction as a chance to codify something that was previously implicit. When an AI answers a question about error handling, that answer gets logged, linked to the policy, and surfaced next time.

This creates a moat. Outsiders see code. They don’t see the reasoning graph underneath. They can copy features, but not velocity. Because velocity here isn’t about lines of code--it’s about decision fidelity. How fast can you make the right call, not just a call?

And the human side? It evolves. Engineers stop being interrupt magnets and become context curators. Their value isn’t in knowing everything--it’s in knowing how to make knowledge last. Pair programming shifts from “explain this function” to “challenge this design.” The friction becomes creative, not corrective.

Where Immediate Pain Creates Lasting Moats

There’s a quiet crisis brewing: AI fatigue. Not because the tools are bad, but because they’re too helpful. They remove the struggle--and with it, the learning. Dennis warns that devs who rely on “vibe coding” hit a wall when things go wrong. The AI can’t debug its own hallucinations. The human can’t, either, because they never learned the stack.

The durable path isn’t avoidance--it’s intentional friction. Use AI to prototype, but force yourself to understand the output. Read the generated code. Trace the dependencies. Ask: Why would this break? This discomfort now creates separation later. Because when the outage hits at 2 a.m., the engineer who understands the system doesn’t panic. They diagnose.

And the role of the senior engineer shifts. It’s no longer “write the hard code.” It’s “define the guardrails.” It’s mentoring teams to ask better questions, not just get faster answers. Dennis notes that at one company, the most prolific coder used zero AI tools--instead, he used AI as a rubber duck, talking through designs before writing a line. That’s the signal: the best users of AI aren’t the ones who let it code for them--they’re the ones who use it to think better.

Key Action Items

• Over the next quarter: Audit your team’s context sources--PRs, docs, Slack, tickets. Identify where knowledge lives and where it decays. Start tagging and linking.
• Within 3--6 months: Integrate a contextual intelligence tool (like Unblocked) into your help channels. Automate answers to common questions to reduce interrupt load.
• This pays off in 12--18 months: Treat every AI interaction as a knowledge capture opportunity. Log questions, answers, and decisions. Build a reasoning graph.
• Start now: Rebalance code reviews. Don’t just check correctness--ask, “Does this align with our system’s values?” Use AI to surface context, not replace judgment.
• Over time: Redefine seniority. Reward not just output, but context contribution--documenting decisions, mentoring, improving knowledge flow.
• Flag this: If your AI tools don’t learn from past interactions, they’re creating technical debt. Demand persistence.
• Discomfort now, advantage later: Force yourself to understand AI-generated code before merging. The short-term slowdown prevents long-term fragility.