Accuracy note (2026-07-29 audit): This post was reviewed against current official documentation in July 2026 and contains inaccuracies relative to the current state of the tools described. The post is retained for its workflow reasoning; the specific factual issues are:

The /search command and the copilot.search.enabled / copilot.search.indexing / copilot.search.scope settings described below are not documented VS Code/Copilot APIs. Current agentic code search is exposed through agent/search tooling rather than this configuration schema. The cited VS Code and GitHub source URLs below return 404. Treat the command/settings block as unverified; confirm current code-search tooling against official VS Code documentation.

Reference docs to verify against:

  • VS Code agent documentation — https://code.visualstudio.com/docs/agents

Grep and string search are fast, but they require you to know exactly what to search for. If you are looking for “error handling logic,” a simple grep for error returns thousands of matches.

Semantic search understands meaning. When you ask “show me where we handle network failures,” it finds the code that does that—whether the variable is named error, err, exception, or failure.

In VS Code 1.119+, Copilot includes semantic search. It is a search mode that uses AI to understand code intent, not just string matching.

Keyword search:

grep -r "retry" .

Returns every line with the word “retry”. That could be 500 results: comments, variable names, log messages, actual retry logic.

Semantic search (via Copilot):

Query: "Where do we handle retries for API calls?"
Results: 3 files
├─ api/client.ts (backoff logic)
├─ utils/retry.ts (retry wrapper)
└─ middleware/error-handler.ts (retry decision logic)

Copilot returns results where the code actually does what you are looking for.

How to use semantic search in VS Code

In the Copilot chat, use the /search command:

/search where do we validate user input before database operations?

Copilot scans your codebase and returns results. For each result:

  • The file path
  • The relevant code snippet
  • Why it matches your query (the reasoning)

You can then click a result to jump to it, or ask follow-up questions like “why do we use this validation library instead of that one?”

When semantic search is faster than grep

Scenario 1: Understanding authentication flow

Your codebase has 50,000 lines of code. You are new to the team and need to understand: “How does login work?”

grep -r "login\|auth\|session" --include="*.ts" | wc -l
# Output: 8,392 matches

With semantic search:

/search describe the login flow from username/password entry to session creation

Returns 4 key files showing the exact flow. You understand it in minutes, not hours.

Scenario 2: Finding related implementations

You are adding a new feature that requires pagination. You know your codebase has pagination somewhere, but you do not know where.

grep -r "page\|offset\|limit" .
# 2,847 matches (includes "pageant", "temperature", "pageview tracking", etc.)

With semantic search:

/search show me pagination implementations in our API endpoints

Returns the actual pagination logic used across your endpoints.

Scenario 3: Locating error handling patterns

You want to see how your team handles file upload errors consistently:

/search how do we handle file upload errors and return them to the client?

Semantic search returns all the error handling patterns specific to uploads, not generic error handling everywhere.

Technical detail: how semantic search works

Semantic search converts:

  1. Your query (English) into an embedding (a numerical representation of meaning)
  2. Each code snippet in your repo into an embedding
  3. Finds embeddings “close” to your query

This is why it understands meaning instead of just string matching.

The trade-off: semantic search is slower than grep (a few seconds vs. milliseconds), but it is much more accurate for exploratory queries.

Semantic search + Chronicle = powerful onboarding

Combine semantic search with Chronicle (from the prior post):

/search how do we handle database connection pooling?
# Returns: semantic results from current codebase
# Then: ask Copilot "show me Chronicle entries about connection pooling"
# Returns: prior sessions where the team discussed this

New developers get: current code + the reasoning behind it.

Limitations and when to use grep instead

Limitations of semantic search:

  • Slower (a few seconds vs. grep’s milliseconds)
  • Works best on large codebases (semantic search becomes noise on <1,000 LOC)
  • Requires semantic meaning in your code (if your code is named poorly, results are poor)
  • Not good for searching exact strings (e.g., finding a specific error message)

Use grep for:

  • Exact string matches (error codes, config keys, exact function names)
  • Very large result sets (you want to filter, not understand)
  • Speed-critical searches (on tiny codebases, grep is just faster)

Use semantic search for:

  • Exploratory queries (“how do we do X?”)
  • Finding related patterns
  • Onboarding or documentation
  • Understanding intent, not just code

Setting up semantic search in your workspace

In VS Code 1.119+:

  1. Open Copilot chat
  2. Type /search [your query]
  3. Copilot scans your workspace and returns results

Configuration in .vscode/settings.json:

{
  "copilot.search.enabled": true,
  "copilot.search.indexing": "full"
}

If you have a very large codebase (>1M lines), you can scope semantic search to specific directories:

{
  "copilot.search.scope": ["src/api", "src/services"]
}

Practical example: onboarding a new service

You are new to the team. You are assigned to the payments service. First task: understand the current payment flow.

Instead of:

  • Reading documentation (if it exists)
  • Asking a colleague to walk you through
  • Digging through code

You use semantic search:

/search describe the payment processing workflow from order to settlement

Copilot returns the payment handlers, webhook processors, and settlement logic in one query. You now understand the flow.

Then you use /search to answer follow-ups:

/search how do we handle payment failures and retries?
/search where do we validate webhook signatures?
/search how is payment state persisted?

In 30 minutes, you have a solid mental model of the service.

The bigger picture

Semantic search is part of a shift from “find code” to “understand code.”

Grep and git log are literal. They show you what exists. Semantic search helps you understand the architecture, decisions, and patterns—what your code is trying to do, not just what it says.

For large teams and codebases, this is foundational. Faster onboarding, faster code review, faster debugging.

Sources