# Our institutional knowledge is in a few senior engineers' heads. How do we capture it for new developers and agents?


URL: https://getunblocked.com/answers/capture-senior-engineers-institutional-knowledge-for-new-developers-and-agents/
Published: 2026-10-30T14:00:00Z
Updated: 2026-10-28T00:05:53Z
Author: Brandon Waselnuk
Categories: Context Engine, Engineering Insights

**Short answer:** Most of it is not only in heads. It is in the PRs they reviewed, the Slack threads they answered, the incidents they ran and the tickets they closed. Connect those systems so people and agents can query them with permissions intact, route the questions the trail cannot answer to the engineer once and record the answer in public, then measure questions deflected and time to the tenth merged PR.

---
Start by checking the premise. The institutional knowledge in your senior engineers' heads is mostly also in the trail they left. That trail is the pull requests they reviewed, the Slack threads they answered, the tickets they closed, the incidents they ran and the design docs they wrote. **Institutional knowledge** is the set of decisions, constraints and workarounds a team relies on that no single document states. Capturing it takes four moves. Stop asking senior engineers to write docs they will not write. Connect the systems where their reasoning already lives so people and agents can query it with permissions intact. Route the questions the trail cannot answer to the engineer once and record the answer in public. Then measure whether questions stop landing on the same three people.

## Why the documentation drive fails

Every team has run one: a quarter, a wiki template, senior engineers asked to write down what they know. On the 284 sales calls we analyzed from May to October 2026, six companies asked some version of this question.

First, the people who hold the knowledge have the least time. Stack Overflow's 2026 survey found developers look to coworkers first for answers about their own work (72 percent), ahead of code (63 percent) and documentation (60 percent) ([Stack Overflow](https://stackoverflow.blog/2026/10/06/the-results-of-the-2026-developer-survey-are-here/), October 2026). The senior engineer being asked to write docs is the coworker in that 72 percent, and answering wins over writing because someone is waiting.

Second, docs record what someone thought to write down, not what someone later needed to know. The knowledge that matters is in the reasons. For example: why the retry count is five and not three, why two services share a database, which approach was tried in 2024 and rejected. That reasoning was written once, in a PR review or a Slack thread, when the decision was made.

Atlassian's 2026 developer experience report puts finding information at the top of the friction list again, with 72 percent of developers reporting the same or more friction than before AI ([Atlassian](https://www.atlassian.com/blog/development/developer-experience-report-2026), October 2026). A drive adds pages to search; it does not change where answers come from.

## Connect the trail instead of rewriting it

| Where the trail is | What the senior engineer left there |
| --- | --- |
| Pull request reviews | Why a change was accepted and what was pushed back on. |
| Slack and Teams threads | Answers to the questions everyone asks, with the reasoning. |
| Incident timelines | What broke, what fixed it, what to avoid next time. |
| Tickets and design docs | What was decided, what was ruled out and why. |


**A context engine** is a service that indexes code, PRs, issues, docs, chat, incidents and production systems together, works out which source is current when they disagree, and returns one cited answer within the asker's permissions. Unblocked's MCP server exposes that as a `context_research` tool that "returns a synthesized answer with citations" ([Unblocked docs](https://docs.getunblocked.com/unblocked-mcp/mcp-overview)). A new developer asks "why does billing retry five times?" in Slack, and a coding agent asks the same through MCP before touching the retry logic. Both get the PR that changed it, the thread where the senior engineer explained it, and the incident behind it. Nobody wrote a page.

Ekan Subramanian, VP of Engineering at Fingerprint, puts a number on it. "Our team saves between 60–70 hours per week that otherwise would've been spent on looking for answers or answering questions from others."

[Why was this built this way](https://getunblocked.com/blog/why-was-this-built-this-way/) covers what the trail holds and what it costs when nobody can read it. For which systems to connect first, see [how to build a context layer](https://getunblocked.com/blog/build-context-layer-engineering/).

## What agents need: decisions and constraints, not prose

Claude Code's guidance for CLAUDE.md is to "keep it to facts Claude should hold in every session: build commands, conventions, project layout, 'always do X' rules" ([Claude Code docs](https://code.claude.com/docs/en/memory)). The same page sets a target of under 200 lines, because "longer files consume more context and reduce adherence". GitHub's sample prompt for generating `copilot-instructions.md` says the result "must be no longer than 2 pages" and "must not be task specific" ([GitHub Docs](https://docs.github.com/en/copilot/how-tos/configure-custom-instructions/add-repository-instructions)).

The file holds standing rules, and the knowledge does not fit in it. A July 2026 ablation ran Claude Code and Codex on 17 tasks across 3 repositories. Context strategy "does not measurably move correctness on either agent", and the failures it saw were in implementation skill, "not missing repository knowledge" ([arXiv](https://arxiv.org/abs/2607.27250), July 2026). Its selective arm, wiki files read on demand, did not move it either; the study tested files, not the history behind them. [Why Claude Code keeps reinventing rejected approaches](https://getunblocked.com/blog/claude-code-institutional-memory/) shows the cost when the agent cannot reach them: it proposes the rejected approach again, and the senior engineer reviews the same mistake twice.

So keep a short instruction file for the rules every task needs, plus a context engine the agent calls for the history behind this task. The Monday page on [giving AI one place to pull engineering context](https://getunblocked.com/answers/give-ai-one-place-to-pull-engineering-context/) covers the second half.

## Route the question once, record the answer

Some questions have no trail. Let those reach the senior engineer once, and make sure the answer lands where people and agents will find it next time.

Ask in a channel the whole team can read, and correct the record where the question was asked. **A shared memory** is a correction Unblocked saves when someone fixes an answer in a conversation the whole organization can read. It is applied "when anyone in your organization asks something the note is relevant to", with a link back to its conversation ([Unblocked docs](https://docs.getunblocked.com/unblocked-chat/shared-memories)). The senior engineer answers once, in public, and that answer is now part of the trail.

Permissions come from the same sources. Data Shield keeps answers to "source material that the user posing the question is authorized to access", and it is always on for Slack ([Unblocked docs](https://docs.getunblocked.com/team-settings/data-shield)). GitHub's MCP server works the same way: its tools "inherit the same access requirements as their corresponding GitHub features" ([GitHub Docs](https://docs.github.com/en/copilot/how-tos/context/use-mcp/use-the-github-mcp-server)). For example, a new developer without access to the security repo gets an answer that does not draw on it, and so does an agent running as them.

## Measure whether it is working

- Questions answered without a senior engineer. Count the questions the engine answers each week against those that still reach the same three people. Unblocked's analytics dashboard shows the questions answered in a period and which interface they came from ([Unblocked docs](https://docs.getunblocked.com/team-settings/analytics)).
- Time to tenth PR. **Time to tenth PR** is the number of days between a developer's start date and their tenth merged pull request. The first PR measures the environment setup. The tenth measures whether they can learn why things are as they are without waiting on someone.

Also watch how often an agent proposes something the team already rejected. If that drops, the trail is reaching the agent; if not, the routing step is where to look.

## Read more

- [Why Was This Built This Way? The Second Codebase Your AI Agents Can't Read](https://getunblocked.com/blog/why-was-this-built-this-way/)
- [8 Best Developer Onboarding Tools, Compared by Layer (2026)](https://getunblocked.com/blog/best-developer-onboarding-tools/)

## Related answers

- [There is drift between our repos and our documentation and agents cannot tell. What handles this?](https://getunblocked.com/answers/documentation-drift-between-repos-and-docs-for-ai-agents/)
- [How do I mark old Confluence pages as deprecated so AI stops using them?](https://getunblocked.com/answers/mark-confluence-pages-deprecated-for-ai/)
- [MCP tools are eating the whole context window in Claude Code. How do other teams give agents company context?](https://getunblocked.com/answers/mcp-tools-filling-claude-code-context-window/)
- [We have context all over the place and constantly being generated. How do we organize it so AI pulls the right thing?](https://getunblocked.com/answers/organize-scattered-context-so-ai-pulls-the-right-thing/)