The 12-Line Pull Request That Took 5 Days: A Context Problem

Small code changes often take days, not minutes, because the work isn’t writing code — it’s gathering the scattered context needed to know what code to write. A frequently cited example: a 12-line pull request that took 5 days, where the entire week went to reconstructing the history and intent behind the change. This is a context problem, not a coding-speed problem.

The biggest challenge in software development isn’t writing code. It’s having enough context to know what code to write

Why is the state of software development still unproductive?#

Every year Stack Overflow releases their developer survey, and year after year the results remain the same: most developers feel that they are not as productive as they wish they could be.

In the 2024 Stack Overflow Developer Survey, 81% of the 65,000+ developers polled named increasing productivity the biggest benefit they expect from AI tools.

Yet even as AI dev tools moved from autocomplete and chat toward today’s agentic assistants, the same survey found that the blockers weren’t about generating code:

• Siloed information still prevents developers from shipping code
  • 53% say waiting on answers disrupts their workflow, even when they know where to look
• Developers continue to waste too much time searching for the answers they need to do their jobs
  • 61% spend more than 30 minutes a day searching for answers or solutions
• Answering questions from others on a team is an ongoing source of distractions
  • 47% spend 30 minutes or more a day answering questions from others

This data raises the question: for all of AI’s claims about increasing developer productivity, why aren't developers seeing more of an impact?

Software’s biggest challenge is context, not code#

In some ways, the gap in expectations versus reality around AI that the Stack Overflow survey highlights is not surprising.

Companies invest a great deal in hiring engineers who are skilled at writing production-level code. Even so, the vast majority of AI developer tools on the market today are focused on code generation.

There are lots of tools to help us write code, but what we need are tools that give us the answers we need, so we know what code to write.

For most teams, the process for building software can be split into three iterative stages:

• Gathering Context
  • Developers seek to answer questions like "How does the system currently function? What was the original intent behind certain design choices? What are the potential ripple effects of making a change?"
• Implementing Solutions
  • This is where the process of translating context into code happens. Code generation tools are focused on this stage and produce code suggestions
• Operating Services
  • As the problem is understood and the solution is codified, teams typically deploy, operate, and monitor their service at this stage

One of my favorite anecdotes that highlights this point is from an engineering leader at a company known for hiring very competent developers.

"It took 5 days to write a 12 line pull-request. They didn't need help with writing code. They spent the week gathering the context, history, and information about their application to be able to write those 12 lines."

Today’s code generation tools aren’t built to address this particular challenge.

If we want to see actual productivity benefits from AI tools, we need to direct this technology toward our biggest problems.

Our codebases are a compilation of thousands of decisions, discussions, and documents that live across tools like Confluence, Slack, Notion, Jira, Linear, GitHub, and more. We call the buildup of all that scattered, unreconciled knowledge context debt — and before we write code, we need that context. This is where AI can make the biggest difference.

From search engines to context engines#

Every tool we use to develop our application contains a slice of the context that makes up the whole picture of how and why things work the way they do. Without access to this context, individual developers are like the characters in the story of the blind men and the elephant - all acting on incomplete information.

Search doesn’t offer a much better alternative because it's too time consuming and error prone. Plus, developers need to know where to look and what exactly to look for. New team members are especially challenged when asked to rely on search to understand a codebase. If you weren’t there when the original decision took place, it’s unlikely that you will know what context exists, let alone where that context lives. Access is not understanding.

This is why we built Unblocked - because we believe we can make developers productive by providing helpful answers to their questions about their codebase.

Unblocked is a context engine: it synthesizes, reconciles, and ranks the knowledge scattered across your internal systems (GitHub, Slack, Confluence, Jira, Notion, and more) into decision-grade context, all while respecting the underlying permissions models. No matter the question, we can then explain the nuances of your codebase — how it works, why it was written, and why it works the way it does.

The impact here is profound: with Unblocked, developers can answer their own questions without interrupting their peers or having to wait for meetings. What’s more, they can find the entirety of the information they need wherever they're working (including in their IDE).

Because of this, our customers tell us that Unblocked saves an hour or more of time per day for every engineer on the team.

Toward a future where time to knowledge is near immediate#

The best developer tools will be the ones that give developers superpowers to do their work.

Many AI tools will continue to assist with the process of writing code, but regardless of how far AI code generation tools go, developers will remain an integral part of the software development process.

Unblocked's goal is to help developers quickly get the information they need so they spend less time digging for information or interrupting their coworkers and more time writing code.

If you haven’t started using Unblocked, book a demo with our team.

‍

A few questions that come up#

Why do small code changes take so long?

Often the code itself is trivial — the example in this post is a 12-line pull request. What takes days is gathering the context around it: how the system works, why earlier decisions were made, and what a change might break. The writing is fast once you know what to write.

What is context debt?

Context debt is the accumulated, scattered knowledge about why a codebase works the way it does — spread across PRs, Slack, Confluence, Jira, Notion, and more, with no single place that reconciles it. The more there is, the longer developers spend reconstructing it before they can safely make a change.

Why hasn’t AI made developers more productive?

Most AI dev tools target the implementation stage — generating code — but in the 2024 Stack Overflow Developer Survey the top blockers weren’t about writing code: 53% said waiting on answers disrupts their workflow, and 61% spend 30+ minutes a day searching for information. Those are context problems, not code-writing problems, so code generation alone doesn’t move them.

What is a context engine?

A context engine synthesizes, reconciles, and ranks the knowledge scattered across a team’s tools into decision-grade context, delivered where developers work. Where search returns links you still have to read and reconcile, a context engine explains how something works and why — because access is not understanding.