Reading & understanding

Find files, follow symbols, and check source references

When to use Go to File, Search All Files, or language-server navigation, and what to check when a result is missing.

Use Go to File when you know roughly where something lives, Search All Files when you know what it says, and language-server navigation when you want to follow a symbol. Switching between the three is usually faster than refining one broad search.

What you know Use Example
Part of a file name or path Command-P (Go to File…) SettingsStore or src/config
A message, setting, or code fragment Search All Files in the sidebar An exact error message or config key
A symbol in an open file Go to Definition, Find References A function’s implementation or callers

Go to File matches file names and paths, not what’s inside the files. To find an error message the program prints, use Search All Files, and search for something distinctive rather than words like data or result.

If a file or result is missing, check the project root first, then whether hidden and Git-ignored files are shown. The defaults live in Settings → General → Files and apply to the sidebar, Go to File, and Search All Files. Each workspace can override them from the sidebar’s status bar.

Trace an error message to the branch that produced it

An error message gives you a starting point, but the line that prints it may only wrap a failure from somewhere else.

  1. Search the fixed part. Open Search All Files from the sidebar’s magnifying glass. Leave out timestamps, request IDs, and paths inserted at runtime. Start with Regex and Whole word off; if capitalization is uncertain, choose Ignore from the Aa menu.
  2. Check the search scope. Open Filters and clear any old folder or file patterns before searching broadly. Once you know the likely module, narrow the folder or use a file pattern such as *.rs. A Best matches label means the list is incomplete: refine the search before drawing conclusions from missing matches.
  3. Read around the match. Open the result and find the condition that reaches it. Is the message created here, or is this a catch/logging layer adding context to another error? In the latter case, follow the operation that failed.
  4. Trace the input back. Follow the enclosing function’s callers and the value that selects this branch. Use Find References when a language server supports it, or search the function and configuration names and check each use in context.
  5. Check the explanation. Compare the proposed input and branch with an existing focused test or a runtime log from the same code version. Record what that evidence confirms and what remains unverified; finding the message alone does not establish the cause.

Search All Files searches the current workspace, including unsaved text in open files. It does not search every Git revision. If the error came from an older build, compare the relevant version before treating the current source as an explanation.

Language servers

Go to Definition, Find References, implementations, and call hierarchy come from a language server:

Language Server
Swift SourceKit-LSP
Rust rust-analyzer
C, C++, Objective-C, Objective-C++ clangd
Python Pyright
JavaScript, JSX, TypeScript, TSX TypeScript Language Server
Go gopls

Yenpo can install rust-analyzer for you from Settings → Code Navigation. SourceKit-LSP and clangd come from your selected Xcode toolchain. Pyright, TypeScript Language Server, and gopls have to be installed by you and available on your PATH. Servers differ in what they support, and some projects need extra setup before navigation works.

If a symbol you know exists returns nothing, check three things: that you opened the project root, that the server is installed, and that the project’s dependencies and build configuration are in place. (Syntax highlighting works even without a language server.)

Without a server, text search still gets you most of the way. Search for the declaration and its uses, then use types and imports to tell same-named symbols apart.

Follow a behavior without losing your place

Keep the file you started from open in a tab while you follow a definition somewhere else. At each important call, note the input and what decides which path runs next: a setting, a type, a registry key, or some current state.

Find References shows uses reported by the language server, not an execution trace. Server support, project setup, and result limits can leave the list incomplete. If a registry has a local and a remote implementation, find the value that picks one. For async code, also check what can change before the result comes back.

A reading note for a configuration value might look like this:

CLI input → config resolver → validation → request builder
Selected source: environment override
Failure: invalid value stops before request construction
Unverified: which parent process sets that environment variable

Add file and line references for the steps you actually checked. The configuration walkthrough does this end to end with runnable tests.

Check an AI source reference

Clicking a source reference in an AI answer opens the cited lines in Quick Look. If the snippet is too short to make sense of, click Open File to open the whole file in a tab.

Read the surrounding conditions and the caller before you rely on the answer. A line that deletes a cache entry, for example, may only be safe if the entry still belongs to the same request. The reference tells you where to look; the code around it tells you whether the claim holds.

Docs and older versions

Markdown files open in reading mode, and you can switch to editing the source. It helps to keep a README or test next to the implementation and note where they disagree.

Files from Git history can sit next to your current files. Before following a reference or making an edit, check which version the tab shows: an explanation of an older commit may not match your working tree. Compare commits and branches explains how to pick versions.