A runtime map of your codebase.
Atlas turns per-test coverage into a navigable map of the behavior a codebase exhibits under test—so engineers can see which code runs together, what a change may touch, and where the available runtime evidence is thin.
Generated code got faster. Code comprehension did not.
When people write code, they build a runtime mental model by running it, inspecting failures, and tracing state through the system. Generated code can arrive without anyone having walked the same execution paths. The result is more code whose local shape looks plausible while its wider runtime effects remain difficult to review.
Language servers, type checkers, static analyzers, and LLMs remain useful, and they are strongest around the code being inspected. Behavior established earlier in a run, observed by another component, or created through state and concurrency only becomes concrete when the program executes.
Atlas treats tests as repeatable execution probes. It records what each test executes and turns those observations into a behavioral map of the revision under test, so the paths a suite exercises stop being implicit in raw coverage.
From test runs to a navigable map.
- Observe
- Run tests separately and record the code each test executes. The result is a binary relation between tests and code.
- Compress
- Combine consecutive lines in a file when the same set of tests executes them. Each maximal run becomes a code range, without discarding the underlying line relation.
- Group
- Apply Formal Concept Analysis to find the maximal groupings of code ranges and tests that the execution data defines. FCA calls each grouping a concept. Atlas keeps the concepts that introduce a range or a test, because that subset stays tractable at repository scale where the full lattice does not.
- Navigate
- Organize large results as Project → Cluster → Group → File → Range, so a visitor can move from system-level structure to the exact lines and tests behind it.
Read “Vihren Atlas: A Code Behavior Map from Formal Concept Analysis” for the coverage matrix, FCA, code-range model, AOC-poset, and topology in detail.
Navigate and change the codebase with runtime evidence.
Behavioral navigation over string searching
Text searches find names and IDEs find callers. Atlas lets developers move from a test to its execution footprint across the codebase, or from a code range to the tests and shared paths that reached it.
Surgical impact analysis
Before editing a large file, Atlas reveals whether the target range belongs to an isolated feature or to shared substrate exercised across many scenarios.
Exposing test-suite debt
Atlas surfaces ranges reached by a single test, and tests that introduce no execution footprint of their own, making fragile and redundant coverage visible.
Detecting architectural drift
Directory structure shows how developers intended to organize code. Shared test execution shows how code interacts at runtime. Atlas highlights coupling that crosses the intended package and directory boundaries.
Ground coding agents in runtime behavior.
Coding agents are good at following names, imports, types, and nearby call sites. They should not have to simulate a large, stateful execution in a context window. Atlas compresses raw coverage into concepts with explicit extents, giving agents exact execution boundaries instead of forcing them to guess from source text alone.
Explore real repositories.
The public catalog holds three pinned analyses: Visual Studio Code, Temporal Server, and yargs. Each entry names the commit it was built from, so the map has an explicit source version. The Temporal Server entry is partial—built from unit and integration coverage, not the full CI matrix.
Bring Atlas to your codebase.
Atlas is a small, early project being shaped in the open. We are looking for design partners who want to run it on a real repository, test whether the map answers useful review and architecture questions, and influence what the product becomes.
We are also available for consulting and engineering contracts around codebase comprehension, test-derived analysis, and agentic development workflows.