When we talk about Unfault being “quiet,” we aren’t just talking about the UI. We’re talking about where it lives.

To stay in flow, a tool shouldn’t feel like a destination. It should feel like an extension of your existing senses. That’s why we built Unfault as a CLI and an LSP-based extension. It doesn’t ask you to look away from your code; it simply enriches the environment you’re already in.

Integrated, not intrusive

In most development environments, gaining context is manual labor: you grep through the terminal, you Cmd+Click through five files, or you keep a “scratchpad” of notes just to remember a call stack.

Unfault flips this by doing the assembly in the background. Instead of forcing you to hunt for details, it uses Code Lenses to place context directly above your functions. It’s a high-signal line of text that tells you the reach of your current context before you even touch your mouse.

Objective observations

At its core, Unfault works by generating Facts.

In our documentation, we define a Fact as a discrete observation, something Unfault noticed, measured, or inferred. Unlike traditional tools that bombard you with “suggestions,” Unfault surfaces these as quiet signals. Above a function, a code lens might show you:

The Inbound Path: Used by 3 places · reached by POST /api/checkout · woth a look` It’s a factual observation of how this logic is actually reachable within the system.

The Context Sidebar: If you choose to click a lens, a sidebar opens to show you exactly where you stand in the larger chain. It’s a vertical slice of the system:

Callers & Routes: Who is relying on this function right now. When discovered, Unfault even shows you defined SLOs for that route.
Heads Up: Specific observations about the logic inside, like a missing timeout or a missing circuit breaker.
Upstream & Downstream: A view of the impact, noticing if a caller doesn’t handle your errors, or if a function you call lacks retries.

Because these are facts rather than “to-do items,” they don’t add to your backlog. They simply sharpen your mental map.

Low-resolution by design

There is a reason Unfault doesn’t show you everything at once.

Senior engineers know that too much detail is just as dangerous as too little. If a map is 1:1 scale, it’s useless. Unfault provides a “low-resolution” view through the CLI, Status Bar or Code Lenses, just enough detail to help you decide if you’re in the right place, or if a file has significant architectural weight.

It’s about understanding your impact and how you are impacted. It’s the difference between reading the entire manual and seeing a signpost that says, “This function is a central node in a route with a 99.9% Availability SLO; keep that in mind as you refactor.”

The end of the “Mental Stack”

By delivering this via the tools you already trust—the terminal and the editor, we lower the tax of curiosity.

When it’s easy to see the shape of the code through lenses and sidebars, you’re more likely to explore, more likely to improve the structure, and less likely to leave complex logic alone because you’re uncertain of its side effects.

Unfault is there to make sure that when you look up from your screen, you still know exactly where you are.

About Unfault

Unfault is a tool for developers who work in growing systems. It’s designed to help you maintain a mental map of your codebase by surfacing objective facts about your code’s architecture.

Delivered as a CLI and an LSP extension, it fits into your existing workflow to show you the connections that matter, without the noise of traditional analysis.