AI Writing Code Still Searching Entire Repositories? Next Step: Give Agents Semantic Navigation

GitHub yesterday published an article that’s very accessible for regular developers, about how Copilot CLI connects to language servers, i.e., LSP. This might sound low-level. But I think it hits on a very real problem in AI programming:

Many Agents aren’t unintelligent; it’s just that their way of looking at code is too primitive.

When asking AI to modify a project, it often starts by globally searching keywords — running rg, grep, digging through node_modules, reading a bunch of seemingly related files, then guessing function relationships from the text.

This works, sure. But it’s essentially “reading text,” not “understanding code structure.”

Why can’t many human developers live without an IDE?

Not because the IDE looks good, but because the IDE gives us semantic navigation.

Jump to definition, find references, type hints, rename symbols, see where a function comes from, which interfaces are implemented by whom. These capabilities let you avoid guessing. And now AI Agents are starting to need these things too.

The focus of GitHub’s article is to let Copilot CLI obtain more precise code information through LSP, rather than relying on plain text search and heuristic guesses. For projects in Java, Python, TypeScript, etc., if the Agent only scans files, it can easily miss generics, overloads, compiled artifacts, cross-package types, and indirect references.

This gives us an important reminder:

The next phase of AI programming isn’t just about swapping in stronger models. It’s also about equipping Agents with a better working environment.

We used to always ask: “Which model is best at writing code?”

That question is still important. But from now on, we should add: “How does it get the code context?”

If the context is just a bunch of snippets scraped from a full repository search, even the strongest model might interpret the project as a piece of prose.

If the context comes from a language server, test results, type system, logs, database schema, real page screenshots — then it’s more like working in a fully equipped workstation.

I now break down the AI programming environment into three layers.

First is the text layer.

This is the most basic — reading files, searching, looking at diffs. It’s necessary, but not enough on its own.

Second is the semantic layer.

This includes LSP, type checking, jump to definition, reference relationships, interface implementations, error diagnostics. It answers: “What does this symbol really mean in the code system?”

Third is the runtime layer.

This includes tests, browser acceptance, database queries, logs, build results. It answers: “After the change, did anything break in the real world?”

Many AI programming failures aren’t because the model can’t write code, but because it only lives in the first layer.

It sees a UserService, so it searches for UserService.

But it doesn’t know which interfaces this class implements, which call sites are only injected at runtime, that a certain type actually comes from generated code, or that a seemingly unused field is relied upon by a serialization framework.

So it makes changes confidently — and breaks things subtly.

That’s why now, for complex projects, I ask AI:

“Before you start, explain what code understanding tools you plan to use. Don’t just do keyword searches. Prioritize confirming the definition, references, type relationships, call chains, and test coverage of relevant symbols. If the current environment lacks LSP / type checking / testing capabilities, clearly state the gaps and reduce the scope of your modifications.”

The point of this prompt is to force the AI to admit the boundaries of its vision.

It can’t just say “I’ve looked at the code.” It needs to explain how it looked.

Did it just search text? Did it verify types? Did it run tests? Did it trace the call chain? Did it check the page?

This is the difference between “letting AI write code” and “building a workstation for AI.”

The model is the employee; the tools are the desk.

You can’t expect an Agent that has to modify a large codebase to be as reliable as a senior engineer if it’s only equipped with a text search knife.

The signal from GitHub’s Copilot CLI + LSP move is clear:

AI programming is moving from the chat box to a real development environment.

From now on, the gap won’t only come from who has a bigger model.

It will also come from whose Agent can see more structure, call more tools, and leave more verifiable traces.

Original article link: https://github.blog/ai-and-ml/github-copilot/give-github-copilot-cli-real-code-intelligence-with-language-servers/