Guides · measured July 2026
Why your editor search gets slower as your project grows.
You noticed it, and you weren't imagining it. The bigger a project gets, the longer Ctrl+P takes to open, the longer a project-wide find runs, the longer your agent waits before it can answer. The cause is structural and it is the same in every editor: search is scoped to the project you opened, and its index is rebuilt from that project, walked by VS Code, re-embedded by Cursor. Rebuild cost scales with the thing being rebuilt. So as the project grows, the search that reads it grows with it. Here is the exact shape of that cost, and the one design decision that flattens it.
Two editors, one dependency
Different mechanisms. The same rising shape.
Both of the tools you probably use build their picture of your code from the workspace you opened, and both rebuild it as that workspace changes. The rebuild is the whole story: the more files there are to walk or to re-embed, the longer it takes. Nothing is broken: this is the correct design for an in-editor assistant. It just means the cost is tied to the size of your project.
The file picker builds its list by walking the folders you opened, per session, from cold. A project-wide find then scans those files' contents. Open a small repo and it's invisible; open a large one and the walk takes seconds.
It builds a semantic index of the repo you opened, turning each chunk into a vector, and re-embeds files as you change them. Bigger repo, more to embed on first index and more to catch up after a large edit before results are fresh.
Two different jobs (literal filenames on one side, meaning on the other) but the same underlying fact. The index is scoped to your project and rebuilt from it, so the work is roughly proportional to how big the project is. Plot that against project size and you get a line that only goes one way.
The shape of the cost
Search time vs project size.
Both axes are on a log scale, because the numbers span microseconds to tens of seconds. Read it left to right as your project growing. The editor line climbs: every extra file is more to walk or re-embed, anchored to a measured 35 s once the workspace is the whole drive. The blue line is a persistent whole-machine index; it was measured across all 4.47M files at once, and growing your project does not move it.
How to read the widening red gap: it is the time your project's size adds to every search. At a small repo it is a blink; by the time the workspace is millions of files it is the 35 seconds VS Code takes to open Ctrl+P on a full drive. The blue line never joins the climb because it never re-walks your project: it answers from an index that is already built and kept current in the background. The two labelled dots are the only measured points; the editor slope is the walk cost modelled from that measured endpoint.
Why size stops mattering
Your whole project is a rounding error to an index this size.
The editor lines climb because a query triggers work proportional to your project. A persistent whole-machine index inverts that. The index already spans every file on the machine (4.47M of them) and it is kept fresh incrementally in the background, so a query is a lookup into a structure that is already built, not a fresh walk of your code. That is why growing your project from 50K files to 500K does nothing to the query time: the index was already measured at whole-machine scale, and a scale that big makes any single project a rounding error.
The gap at the right edge of the chart: a VS Code file search on a full-drive workspace takes about 35 seconds; the same lookup against the persistent index returns in about 85 µs (139 µs median over 20 queries). The editor is doing more work the bigger you get; the index is doing the same tiny amount of work it always did.
The flat line, measured
What "doesn't move" adds up to.
Methodology: Ryzen 9 9950X3D · 64 GB DDR5 · NVMe SSD · Windows 11 · 4,470,000 files indexed. Filename lookup is the median of 20 queries; the 35 s VS Code figure is Ctrl+P open-to-result with a workspace opened at the drive root; the ripgrep figure is the same content query over the same corpus. Numbers are the only claims here: the editor slope in the chart is modelled from the measured 35 s endpoint.
The layer under your editor
Keep your editor's index. Add the flat layer beneath it.
This is not a replacement for VS Code's file list or Cursor's embeddings. Keep both. It is the fast, literal, whole-machine layer underneath them: an always-fresh index of every file on the machine, names and contents, across every repo and the non-git 90% neither editor was ever going to see. It answers "does this exact file or string exist anywhere on this machine?" at a speed that stays flat as your project grows, and it exposes that to whatever agent you use through one connector. Different job, complementary to the meaning-index: the floor it stands on.
NOT A REPLACEMENT FOR YOUR EDITOR'S INDEX: THE FLAT, WHOLE-MACHINE LAYER UNDER EVERY AGENT.
Do this once
Stop paying the size tax on every search.
One signed installer indexes every file on your machine and wires up the AI clients you already use: no JSON editing, no cloud account, no keys of any kind. Your editor keeps doing what it does well inside the repo you opened; every search that used to grow with your project stays flat, whether the project is 50K files or the whole 4.47M-file drive.
Everything local is free forever, on all your devices, no card. Hosting starts at $5.99/mo. Download for Windows · What Cursor's index can't see · Why context acquisition is the bottleneck