Almost everything I make with agents becomes a markdown file at some point. The specs I talk through and align on before building anything. The handoff documents that carry learnings from one conversation to the next before an agent runs out of context. The research reports and implementation plans that my RPI pipeline produces on every feature. These blog posts and my project pages, because the site runs on Astro and Astro lets everything be markdown. The plans sitting in every codebase I work in. The exchange format between my brain and my agents is, overwhelmingly, markdown files.
Which means the most important surface in my entire workflow is a markdown viewer. In hindsight that sounds obvious to the point of silly. It took me an embarrassingly scattered workflow to see it, and once I saw it, I made a decision that still surprises people: the markdown viewer in goldengoose shipped with no editor at all. That wasn’t a corner cut. It was the point.
Monospace is for code
Before goldengoose, I ran terminal agents all day, and the part I never adjusted to wasn’t the workflow. It was reading. I like monospace for code; for English, staring at it all day is miserable, and I don’t know how people do it. I was making real design decisions through a terminal screen, with an agent asking questions and dumping prose into a scrollback buffer. Markdown files became my way out: get the thinking into a document, read the document like a document.
My reader of choice became Cursor, for one specific reason: the tab model. Their autocomplete prediction is the best in the world at quickly reworking a file, and for a while I was hand-editing plans often enough that it mattered. Then the models improved and something quietly flipped. Instruction following got good enough that reworking a plan by hand stopped making sense; it was simpler to tell the agent what I wanted changed and trust the edit. The one thing keeping me in an editor evaporated. Writing markdown stopped mattering. Reading it was suddenly the entire game.
The preview tax
Once reading was the job, Cursor’s actual reading experience came into focus, and it was terrible in ways I’d been tolerating without noticing.
The structural problem: it’s a full VS Code fork, so reading a text file means paying for an entire IDE. One window per project, and I multitask across several: four projects meant four Electron windows, each indexing my workspace and running the machinery of a code editor so I could look at prose.
The specific problem: markdown preview in VS Code and Cursor is an afterthought. The default view of a markdown file is the source. The preview is a separate thing you click into, and when the underlying file changes, the preview doesn’t reliably follow. I’d press a refresh button when one existed, and when it didn’t, close the preview tab and reopen it. Now put that next to how agents work: they rewrite files constantly, sometimes one line at a time. Every rewrite meant re-earning trust in what I was looking at. A viewer you have to manually reconcile with reality isn’t a viewer; it’s a cache you don’t trust, and I was flushing it by hand dozens of times a day.
Build the reader, skip the editor
So the design brief for goldengoose’s docs experience wrote itself: make reading markdown instant, beautiful, and always current, and don’t build editing at all. Constraining it to one job made the whole thing tractable, the same lesson as the process manager’s thirty-second rule. The core problem reduces to converting markdown to HTML as fast and as memory-efficiently as possible, which is exactly the kind of problem Rust’s ecosystem has already solved well: comrak for parsing, syntect for highlighting, both battle-tested by community use. Get that core fast, pick good defaults once (typography, colors, document structure), and the rest is mechanical. That’s how the sub-100ms render target fell out, including while an agent is actively rewriting the file, where file watchers stream revision deltas and a detected gap falls back to a clean refetch instead of a corrupted view.
There is exactly one way to view a markdown file in goldengoose: the rendered preview, automatically, always live. No source mode to land in by default, no refresh button because there’s nothing to refresh, no edit mode because edits are the agents’ job and I review them in the diff view like any other change. The conveniences stack on top: when an agent says “I’ve written the plan to this file,” the path in the timeline is a link, and clicking it opens the rendered doc right there in the app. Search and glob-pattern matching are built for the same motion: find the doc, read the doc, stay in flow.
A repo view with no code in it
The docs view goes one step further, and this is where it turns into a worldview: the file tree shows only markdown. The indexing is markdown-only by design, and code files simply don’t appear. That will read as a gimmick until you consider what I think is happening to this profession: engineers are heading somewhere with enormous leverage and full understanding of their systems, without necessarily reading or writing the code themselves. I know that’s a controversial position. I’m comfortable being early on it, because I’m already living it: I understand everything my systems do, and the way I understand them is through documents (research reports, plans, specs, handoffs), not through source files.
The through-line of all of it is bandwidth. The bottleneck in agentic engineering is how much information actually transfers between the agent’s context window and yours: how cheaply you can absorb what it found, co-design what happens next, and hand back intent. Every choice in the viewer serves that one goal: proportional fonts because prose deserves them, instant renders because waiting breaks the loop, always-current previews because trust shouldn’t need a refresh button, a markdown-only tree because everything else is noise at reading time.
The result is the tool I now use to read markdown from any agent, not just the ones inside goldengoose. Whatever writes the file, this is where I read it. Turns out when every artifact of your process is a document, the reader stops being a utility and becomes the desk you work at, and nobody puts an editor in the middle of a good reading desk.