So I've been using Granola as my daily driver for a little over a year now, across a mix of TypeScript, Go, and Python projects. Like many, I was initially drawn in by the hype around its "AI-first" workflows and the promise of a more fluid coding experience. But after the novelty wore off, what actually stuck? Which features became muscle memory, and which ones ended up being more noise?
Here's my honest breakdown of the Granola features that survived my initial setup purge and are now integral to my flow.
### The Persistent Breadcrumb Navigator
This is, without a doubt, my most-used feature. It’s not just a file path. It intelligently shows the symbol hierarchy (class -> method -> function) and allows you to jump to any level instantly. I've customized mine to show type information for the current symbol on hover. It has completely replaced my need for a dedicated file outline sidebar in most cases.
```granola
// In my granola.json config, this tweak made it perfect:
"navigator.breadcrumbs": {
"showTypes": true,
"compactMode": false,
"highlightActiveScope": "file"
}
```
### Live Value Inspection During Debugging
Granola's debugger doesn't just show variables. It **continuously evaluates** simple expressions in your watch window as you type, even when paused. I'll often throw a quick `array.map(x => x.id)` or a conditional check there to filter data while stepping through. It feels like having a REPL inside your debug context. This has saved me countless "print statement -> re-run" cycles.
### The "Semantic Collapse" in the Editor
I don't use the standard "fold to indentation" anymore. Granola's language-server-powered semantic collapse lets me fold by logical block, not just whitespace. For example, in a large React component, I can collapse just the JSX return statement, or a specific `useEffect` hook, leaving the rest of the function visible. It makes navigating massive files so much more manageable.
### The Customizable "Code Actions" Palette
Out of the box, the AI-suggested actions were hit-or-miss. But the ability to write my own tiny scripts and bind them to the command palette (`Ctrl/Cmd + .`) is a game-changer. I have custom actions for:
* Generating a specific type of test stub for our internal framework.
* Wrapping selected text in our observability logging.
* Quickly inserting a common data transformation snippet.
It turned Granola from a smart editor into *my* smart editor.
### What *Didn't* Stick (For Me)
* **AI Autocomplete Beyond Line-by-Line:** The full-function AI completions were cool for a week, but I found myself spending more time reviewing and correcting them than just writing the code. I've since dialed it back to only suggesting single lines, which is less disruptive.
* **Integrated Terminal as Primary:** I still prefer iTerm2 or WezTerm. Granola's terminal is fine, but I missed my standalone terminal's multiplexing and key bindings.
* **The "Project-Wide" Refactor Tool:** For small, safe renames, it's okay. But for any significant architectural change, I still jump back to JetBrains or a dedicated CLI tooling suite. It's good for confidence on small projects, though.
The real strength of Granola, in my experience, isn't any one flashy AI feature. It's how these smaller, intelligent augmentations to the classic editor experience (breadcrumbs, debugging, folding) add up to reduce friction without pulling you out of the zone. It’s less about the editor *writing* code for you and more about it *getting out of the way* of the code you're already writing. I'm curious—has anyone else found a specific, non-headline feature that became indispensable? Or perhaps the opposite, a flagship feature you ended up disabling?
editor is my home
Spot on about the breadcrumb navigator. It's the only "AI" feature I kept enabled. The rest became a distraction.
The debugger's live inspection is useful, but I found it slows down execution too much on larger services. I only turn it on for specific, isolated scopes now. The performance cost isn't worth it for daily debugging.
Show me the bill
Oh, that hover for type information sounds super useful! I'm still fairly new to Granola and I've just been using the default breadcrumbs. I hadn't realized you could customize them that much. Does showing the types ever make the display feel cluttered for you, or is it pretty clean? I work a lot with TypeScript so that seems like it could be a real time-saver.
It can look cluttered at first, honestly. I had to turn down the font size in the breadcrumb settings. But once I got used to it, seeing the types right there is a lifesaver in TypeScript. Saves me from constant cmd-hovering.
There's a "compact mode" setting that helps a lot too. It only shows the full type on hover and keeps the main line cleaner. You should try that.
How did you adjust your breadcrumb view when you started?
Agree on the types being a lifesaver for TypeScript, but you need to be surgical with the config. The clutter becomes an issue when you're working with generics or complex union types. I bound a keyboard shortcut to toggle the verbose type display on and off entirely, which is more effective than just adjusting font size.
The real value isn't just the hover, it's how the breadcrumb integrates with the static analysis. For Go, it shows interface satisfaction. For Python, it can show inferred types from type hints or docstrings. That's the data that actually changes how you navigate. The display is just the UI layer.
Don't sleep on the breadcrumb's right-click menu, either. You can jump directly to a type's definition or find all its implementations from there, which makes the type display an actionable control surface, not just a readout.
That's a really smart tip about the keyboard shortcut toggle. I've been relying on the hover state, but a full toggle for those messy generics-heavy moments makes a lot more sense.
The point about the breadcrumb being an actionable surface is spot on, too. I think a lot of users miss that it's not just a readout. The jump-to-definition and find implementations options from the right-click menu are arguably more valuable than the type display itself. It turns passive information into a way to move around your codebase.
Stay constructive
The live value inspection is a double-edged sword. In a real project, I found it absolutely kills debugging performance on anything larger than a demo, especially with complex Kubernetes manifests or Terraform state.
I gave up on it entirely and just use the traditional watch window. The constant re-evaluation and rendering it does to keep values "live" introduces a noticeable lag. It's fine for a quick glance at a single variable, but trying to step through a pipeline function with it enabled feels like walking through mud.
Your config is interesting, but I'm curious if you've actually run it on a real, memory-intensive Go service or if your experience is mostly with smaller scripts. The overhead becomes impossible to ignore.
Automate everything. Twice.
The performance hit is my biggest worry too. I'm mostly working in HubSpot's sandbox for automations, which I wouldn't call huge, but adding live value inspection to a workflow debugger does sound like it would slow things to a crawl.
I'm curious about the traditional watch window you mentioned. Does Granola's work well enough on its own, or do you find yourself pairing it with an external debugger to avoid the overhead entirely?
Great list, you nailed the two I use daily. That breadcrumb config is almost identical to mine, though I keep `compactMode: true` to avoid the clutter.
But on the live value inspection - I found it only works in production if you're *extremely* targeted. I leave it off globally. When I need it, I toggle it on for a specific watch expression in the debugger. The performance hit is just too brutal otherwise, especially in a busy Lambda or ECS task.