- How context builds - the search-and-read loop behind every change.
- What you can do - find, navigate, read, and reach beyond the repo.
- Capability reference - every search and navigation move at a glance.
- Tips for large codebases - how to point 100xprompt fast.
How context builds
You describe an outcome. 100xprompt turns that outcome into targeted code reading - a small number of precise searches and reads instead of loading your whole repository. It widens when it needs more context and narrows the moment it has enough to act.You never run these searches yourself. You state the goal in plain language, and 100xprompt chooses the right combination of searching, navigating, and reading to get there.
What you can do
Codebase understanding is four complementary skills - finding code, navigating meaning, reading with judgment, and reaching beyond the repo.Search by content
Find every place a behavior lives using full regular expressions across a repo of any size.
Search by file pattern
Locate files by name or path shape with glob patterns, honoring your ignore rules.
Follow symbols
Jump to a symbol’s real definition, references, implementations, and callers - semantically, not by guessing.
Read intelligently
Open large files in sections, and read images, PDFs, and notebooks - not just plain text.
Search by content
When you describe what the code does rather than where it is, 100xprompt searches file contents directly. It uses full regular-expression matching, so it can find flexible patterns - a function shape, an error string, a config key - not just exact words. Searches can be scoped to a directory or filtered to specific file types, and they run fast whether your project has a hundred files or a hundred thousand.Search by file pattern
When the target is better described by its name or location - “the checkout page,” “every test file,” “the config for this service” - 100xprompt matches files by pattern instead. Glob patterns like**/*.ts or src/api/** find files by path shape, and results respect your project’s ignore rules so generated output and dependency folders never clutter the picture.
Follow references and symbols
Text search finds strings; real code navigation follows meaning. For supported languages, 100xprompt resolves symbols semantically - it goes to the actual definition of a function, finds every genuine reference to it, locates the implementations of an interface, and traces who calls what. That precision means it distinguishes a real usage from a same-named variable, a comment, or a string, which is exactly what makes cross-file changes safe.Read files intelligently
Once 100xprompt knows where to look, it reads with judgment rather than brute force:- Large files are read in focused sections, so it can pull the exact region it needs without wading through everything.
- Images and PDFs are read as visual content - useful for design mockups, screenshots, diagrams, and reference documents.
- Jupyter notebooks are understood as cells, so data and ML work is first-class.
- Binary files are recognized and skipped, keeping attention on what’s actually readable.
Bring in external context
Your repository is not the only source of truth. When a change depends on a library, framework, or SDK you use, 100xprompt can pull focused, up-to-date usage context for that dependency - so it applies APIs correctly instead of guessing from memory.Capability reference
| Capability | What it does for you | Best for |
|---|---|---|
| Content search | Full-regex search across file contents, scopable by folder and file type | Finding every place a behavior or pattern lives |
| File-pattern search | Glob matching on file names and paths, honoring ignore rules | Locating files by name, type, or location |
| Directory exploration | Surveying structure and neighboring files | Orienting in an unfamiliar area of the repo |
| Go to definition | Resolves a symbol to where it’s actually defined | Understanding what a function or type really is |
| Find references | Lists every genuine use of a symbol | Safe renames and impact analysis |
| Find implementations | Locates concrete implementations of an interface | Tracing polymorphic or abstract code |
| Call hierarchy | Shows callers and callees of a function | Following how logic flows through the system |
| Sectioned reading | Reads large files in targeted ranges | Working with huge files efficiently |
| Rich file reading | Understands images, PDFs, and notebooks | Design assets, docs, and data/ML work |
| Library context | Pulls focused usage context for dependencies | Getting external APIs right |
Work in a large or monorepo project
Suppose you’ve dropped 100xprompt into a large, multi-package repository it has never seen. The winning move is to read less, not more - but read the right things. 100xprompt starts from your request, casts a targeted search, follows the threads that matter, and stops as soon as it has a confident picture of the change.Anchor on the request
Your goal points to a starting search - by behavior (content) or by location (file pattern).
Locate the candidates
A focused search returns the handful of files that actually relate to the task.
Follow the connections
From those files, 100xprompt jumps to definitions, references, and callers to see how the pieces fit together across packages.
Read what matters
It reads the exact regions it needs - full small files, targeted sections of large ones - and confirms the surrounding patterns.
This is why 100xprompt can be dropped into a repository it has never seen and still make a correct, consistent change: it derives the context on demand rather than assuming it.
Tips for large codebases
Name the surface, not the whole app
Name the surface, not the whole app
“The billing webhook handler” or “the mobile login screen” gives 100xprompt a precise anchor to search from. Broad asks like “fix the backend” force it to explore more before it can act.
Point at a file or folder when you know it
Point at a file or folder when you know it
If you already know roughly where the change lives, say so. Scoping to a directory or a file keeps searches tight and answers fast.
Describe behavior for cross-cutting changes
Describe behavior for cross-cutting changes
For anything that spans many files - a renamed field, a deprecated call - describe the behavior or string. Content search will surface every site so the change is complete.
Keep ignore rules honest
Keep ignore rules honest
File and content searches respect your project’s ignore rules. Keeping generated output and vendored code ignored means searches stay focused on code you actually own.
Lean on memory and rules for repeat context
Lean on memory and rules for repeat context
Facts that hold across a project - where key areas live, which conventions to follow - are better captured once in memory and rules than re-explained each session.
Semantic symbol navigation depends on language support for the file in question. Where it isn’t available, 100xprompt falls back to content and pattern search - still finding the right code, just by text rather than by resolved meaning.
Related
Code Editing
From context to change: how understanding turns into precise, multi-file edits.
Memory & Context
Skip the re-explaining: carry project knowledge across sessions.
Rules
Keep context on target: teach 100xprompt your conventions once.