Agents · measured July 2026 · 7 min
GitHub says AI writes most of the code now. Finding the code is still manual.
Grant the claim in full. GitHub's leadership has publicly predicted AI will write the majority of code, and by GitHub's own 2023 figure Copilot already writes an average of 46% of a developer's code (61% in Java). But writing was only ever half the job. Before a single line is written, the right code has to be found and read: the file, its neighbors, every callsite. On a real 4.47-million-file machine we measured that other half, and it is still done the way it was in 2006: an agent grinding grep.
TL;DR: the two halves of writing code
- 01GitHub reports AI already writes a large share of new code (an average of 46% of a developer's code where Copilot is used, by its own 2023 figure, 61% in Java), and its leadership expects most code to become machine-written.
- 02Writing is only half the job. Before any line is written, the right code has to be found and read: the file, its neighbors, every callsite.
- 03That finding half is still manual. An AI agent spent 71 tool calls and 6 minutes 57 seconds locating one file by grinding grep: about 58% of the session's tokens went to finding, not writing.
- 04ripgrep, the fast grep agents lean on, re-reads the disk every query: one content search took 93.8 seconds. A prebuilt index answered the same query in 16 milliseconds, 58,625× faster across the set.
- 05Interlinked hands any agent an always-fresh, whole-machine index over MCP, so the finding half is automated too: 139-microsecond filename lookups, one call instead of seventy-one.
Programming is two jobs, not one
Automation reached the writing. It never reached the finding.
Writing code is authorship; finding code is retrieval: locating the right file, reading what surrounds it, and tracing every callsite before a single line can change. A model can only write against code it has already found, which makes finding the step that comes first and the one nobody put a number on.
Copilot automated authorship, and the 46% headline is real. But the retrieval underneath it is still hand-cranked: the agent shells out to the same terminal tools a developer would type, one blind probe at a time. Here is one code change, drawn as its two halves.
The bright half gets the press; the dim half sets the clock. When the finding is slow, the whole task is slow, and on this machine the finding half is not the smaller one. It is where roughly 58% of the session's tokens went. This is the same bottleneck we traced in the backbone of the LLM economy: context acquisition, the layer every agent stands on.
Grant GitHub the writing · here is the finding, timed
One half ships a headline. The other half ships the delay.
We watched Claude Code (Anthropic's coding agent) find a single file on the benchmark machine. With no index, it reached for its shell tools and ground through the job: 71 tool calls over 6 minutes 57 seconds. That is about the length of a song, spent looking for one file. Six of the seven steps below are the manual finding half; only one of them is the celebrated automated one.
| The step | Automated? | Done by | On 4.47M files |
|---|---|---|---|
| Write the diff | ✓ Automated | Copilot / the model | ≈46% of code · GitHub |
| Find the right file | Manual | grep · ripgrep · ls | 71 tool calls · 6m 57s |
| Read the surrounding code | Manual | sequential file reads | part of the 6m 57s |
| Locate every callsite | Manual | repeated grep | re-walks the drive each time |
| Find the right file, indexed | ✓ Automated | one indexed call | 16 ms · 1 call |
Methodology: Ryzen 9 9950X3D · 64 GB DDR5 · NVMe · Windows 11 · 4,470,000 files. The 71-call run is the measured Claude Code session; the indexed row is the same file resolved by a prebuilt index. The 46% figure is GitHub's own 2023 number: an average of a developer's code across languages where Copilot is used. Full agent breakdown in the token cost of file hunting.
When the agent needs to search content, it shells out to ripgrep, the fastest grep ever written, and genuinely excellent software. But a grep keeps no index; it re-walks the directory tree and re-reads the bytes on every single query. One heavy content search cost ripgrep 93.8 seconds, a minute and a half of a scanner opening every file on the drive. The same query against a prebuilt index returned in 16 milliseconds, a single blink, and across the five-query set the index averaged 58,625× faster. The math is in the ripgrep comparison.
Why the finding half never got automated
Search was built for one open project. Agents work across the whole machine.
VS Code indexes the folder you opened. Cursor indexes the repo you're in. Both are fast inside that one boundary, but an agent's questions don't respect folder boundaries. The answer might sit in a sibling repo that ships alongside this one, or in the 90% of the disk that was never in git: a config, a document, a log, the git-ignored file a repo-scoped search never sees. Nothing keeps a warm, machine-wide view of all of it.
So the agent falls back to the floor: ripgrep and ls, one blind probe at a time, because nothing across the machine is kept ready between them. Give the model a map and it makes one call; give it a flashlight and it makes seventy-one. The manual finding is a property of the tools, not the model. A bigger subscription buys a smarter writer, not a faster finder.
What Copilot automated
Generating the diff
Autocompleting the line
Boilerplate and tests
What it left manual
Finding the right file
Reading what surrounds it
Tracing every callsite
Automate the other half
Keep Copilot for the writing. Hand the finding to an index.
Interlinked keeps an always-fresh index of every file on the machine (names and contents, every repo, the git-ignored files a cwd grep never sees, documents included) and exposes it to any agent over MCP. One signed install auto-configures 19 AI clients, Copilot and Claude Code among them, with no JSON editing. Filename lookups land at 85 microseconds (139 microseconds median across 20 queries, median, not best case); content in milliseconds. A save is searchable in about a millisecond, under 30 ms worst case, so the index never lies about a file the model just wrote.
The same index carries a knowledge vault that rides along on the searches the agent already runs, with no model in the loop. On a fresh machine it found 12 of 12 repos and replayed 8,455 git events in 1.7 seconds into 26,958 relationship pairs, and flagged two repos that quietly share 435 identical files, a link nobody had told it about. Speed finds the file; the vault knows why it matters. It costs about 44 MB of memory at rest, less than a browser tab, and the index on disk stays under 1% of the drive.
THE MODEL WRITES THE CODE. THE INDEX FINDS IT. AUTOMATE BOTH HALVES, NOT JUST THE ONE THAT MAKES HEADLINES.
Common questions
The finding half, answered plainly.
Does AI really write most of the code now?
By GitHub's own 2023 figure, Copilot generated an average of 46% of a developer's code across languages (61% in Java), and GitHub's leadership has publicly said it expects AI to write the majority of code going forward. What the headline leaves out is that writing is only half the job: the code still has to be found and read first.
If AI writes the code, why does finding it still matter?
Every change starts by locating the right file, reading what surrounds it, and tracing its callsites. A model can only write against code it has already found, so when the finding is slow the whole task is slow. On the benchmark machine, about 58% of an agent's session tokens went to finding, not writing.
Why do AI agents use grep or ripgrep to find code?
Agents reach for the same tools a developer types into a terminal (find, grep, ripgrep, ls) because there is no warm, machine-wide index to ask. ripgrep is excellent, but it re-walks the filesystem on every query; on a 4.47M-file drive one content search took 93.8 seconds against a prebuilt index's 16 milliseconds.
What does Interlinked change?
It keeps an always-fresh index of every file on the machine (names and contents, every repo, including git-ignored files) and exposes it to any agent over MCP. Filename lookups return in about 139 microseconds (median of 20), content in milliseconds, and a saved file is searchable in about a millisecond. The finding half stops being manual.
Does this replace Copilot or my model?
No. Copilot and your model still write the code; Interlinked finds and reads it for them: it is the layer underneath, not a competitor. One install configures 19 AI clients, and everything local is free forever.
Do this today
Automate the other half.
Install once. One signed installer auto-configures 19 AI clients: Copilot, Claude Code, Cursor, Codex, Windsurf, Zed and the rest. No JSON editing.
Let it index. Filename search works immediately; content search fills in behind it. At rest the whole engine sits around 44 MB (less than a browser tab), and updates as you save.
Point it at a path when you can. Whole-machine when you don't know where something lives; scoped to a folder when you do. Scoped queries return in the microsecond range.
Stop pre-pasting file trees. Let the agent ask the index instead of grepping the disk. That is the move that turns the manual finding half into one indexed call.
Everything local is free forever, on all your devices, no card. Hosting starts at $5.99/mo. Download for Windows.
Keep reading: how to make Claude Code faster, content search vs ripgrep, and the backbone of the LLM economy.