AI Writes a Novel's Worth of Prose Per Day. Your Eyes Weren't Designed for That.

A year ago I was writing maybe two hundred lines of code a day and reading maybe four hundred. Now with Cursor and Claude Code I write three times that much and I read — I have no idea. Every Composer plan is a paragraph. Every Cmd-K reply is three paragraphs. Every Claude Code tool call ends with a post-edit summary that's another paragraph. A long agent session produces ten, twenty, thirty thousand words of prose that didn't exist before the AI was involved. I drink more coffee, I close my eyes more often between tasks, and by 5pm I'm pretty sure my vision is measurably worse than it was at 10am.

This is the guide for fixing that by listening to your AI coding tools instead of reading them — across every major IDE and every major CLI agent, free, one install.

The Problem Is Not the Code. The Problem Is the Prose Surrounding the Code.

Code itself is pretty readable. A function signature, a for loop, an import statement — your eyes are trained to pattern-match these instantly. You don't so much read them as glance and move on. What's different about AI-era coding is the text wrapper around the code. Cursor Composer doesn't just rewrite a file — it explains what it's about to rewrite, then it rewrites, then it tells you what it did. Claude Code doesn't just edit three functions — it lays out a plan, applies the edits in sequence with commentary, then summarizes. Gemini CLI in extended-reasoning mode writes entire paragraphs of rationale before touching the repo. None of this is code. All of it is prose. And all of it ends up on your screen.

If you want to skim it, you can't — it's too critical, too often it contains a wrong assumption that you'll regret approving. If you want to read it, you're reading for hours a day on top of already reading code. The result, after a few months of heavy AI-assisted coding, is real eye strain and real mental fatigue that my friends and I all talk about but nobody has shipped a good solution for.

Here is a solution. It's the same idea as dual monitors: add a channel. Instead of forcing your eyes to handle both the prose and the code, route the prose to your ears. You still see the diff on screen. You still see the test results. You just don't also read seventeen paragraphs of Composer explanation at the same time.

VS Code — The Default Home of Most AI-Assisted Coding

Most developers I know still live in VS Code. GitHub Copilot Chat, Continue, Cline, or just one of twenty AI-coding extensions that drop long text into a side panel. VS Code is Electron-based, so the read-aloud path uses Vision OCR on a small region around your selection — that's why you need Screen Recording permission on first run. The highlight still lands on the real editor window, word by word, with the same gesture as in any native app. Read VS Code Aloud has the full walkthrough including how it handles Copilot Chat output, inline suggestions, and integrated terminal output.

Cursor — Where Composer Is the Killer Feature and Also the Eye-Strain Engine

Cursor's Composer panel is the single biggest source of unread AI prose in my day. Composer plans are multi-paragraph. Composer summaries are multi-paragraph. Cmd-K rationales are multi-paragraph. And because all of it is critical — approving the wrong plan costs you a broken commit — you can't skim. Listening at 1.5× while your eyes scan the staged files is the only way I've found to keep up. Read Cursor Aloud covers Composer, Cmd-K, the chat panel, and the ghost-text limitation (you have to accept the suggestion first — ghost text isn't in the selectable document yet).

Xcode — The Cleanest Technical Path of Any IDE

Xcode is the outlier. It's a native AppKit app, which means its text is exposed through macOS Accessibility APIs — no Screen Recording needed, no OCR latency, pixel-perfect character alignment. If you write Swift for a living and you've been jealous of how clean the Terminal.app read-aloud experience feels, this is the good news: Xcode works the same way. Doc comments (///), Quick Help popups, README previews, AI Assistant panel replies — all readable through AX, with zero lag on selection detection. Read Xcode Aloud has the full technical breakdown of why native AX matters and where SwiftUI preview + Interface Builder fit in.

Windsurf — Cascade Plans Are Long and Audio Fits Them Perfectly

Windsurf's Cascade agent plans edits across your whole repo in a single pass, which means its plans are longer than most other AI surfaces. A single Cascade plan can be fifteen paragraphs before a single file gets touched. That's a lot of staring. Listening at 1.5× while you scan the list of staged files cuts the review time roughly in half in my experience. Like Cursor, Windsurf is Electron-based — Screen Recording permission, OCR-backed alignment, identical end result. Read Windsurf Aloud walks through Cascade, chat, and the inline explanation panel.

Claude Code — The Terminal-Native Agent That Outputs a Novel Per Day

If you've been running Claude Code in Terminal.app you already know it has opinions and it explains them at length. Every tool call has a pre-plan and a post-summary. Every multi-file edit has a rationale. Every error response is three paragraphs of why-this-went-wrong. All of it is valuable and all of it is prose. Because Claude Code runs in Terminal.app, the read-aloud path is the cleanest possible: native AX, no Screen Recording, no OCR, instant selection detection. Select a paragraph, press ▶, listen. Read Claude Code Aloud covers the tmux / screen caveat and the iTerm2 / WezTerm / Warp compatibility matrix.

Gemini CLI — Verbose by Design, Which Makes It Perfect for Audio

Gemini 2.5's extended reasoning mode is the most verbose of the major coding agents. A single reasoning trace can span a dozen paragraphs before the actual plan begins. That verbosity is useful — you can see how it got to an answer — but it's eye-destroying if you read all of it on screen. Audio at 1.5× is the natural cadence for extended reasoning traces. Same terminal AX path as Claude Code. Read Gemini CLI Aloud has the markdown-rendering note and the VS Code integrated terminal compatibility note.

Codex — OpenAI's Coding CLI, Same Terminal Surface

Codex is OpenAI's terminal-based coding agent. Its output pattern looks a lot like Claude Code's — plans, rationales, summaries — with its own voice. If you run Codex in Terminal.app, all of that text is one selection-and-click away from being audio. Read Codex Aloud covers the ANSI-color stripping, the iTerm2 / Warp / Ghostty compatibility, and why running Codex in Terminal.app gives a cleaner read-aloud experience than VS Code's integrated terminal.

Copilot CLI — When gh copilot explain Finally Makes Sense

GitHub's gh copilot is a different beast. Its core value is generating plain-language explanations of shell commands, git operations, and code. The whole point is comprehension. That makes it the single best fit for audio in this whole list — you're literally running a command whose sole purpose is to explain, and now you can listen instead of read. gh pr view and gh issue view also dump structured prose into the terminal. Same terminal AX path. Read Copilot CLI Aloud has the full gh-subcommand compatibility matrix.

Aider — The AI Pair Programmer With Strong Commit Hygiene

Aider's calling card is its conventional-commits discipline — every edit is paired with a commit plan, a diff summary, and a reasoning trace about why it chose the approach it did. All terminal prose. All ideal for audio. Read Aider Aloud covers the confirm-before-commit flow, the multi-model support implications, and why VS Code's integrated terminal is a second-class citizen for Aider compared to Terminal.app.

One Install, Nine AI Coding Tools, Same Gesture

Download CastReader for Mac. Grant Accessibility permission. If you use VS Code / Cursor / Windsurf, also grant Screen Recording (Electron apps need it; native apps like Xcode and Terminal.app don't). Select any prose output in any of the nine tools, click the floating ▶ that appears next to your selection, and listen. The same gesture, the same word-level highlight, the same voice picker, across your entire AI coding workflow. You set the playback speed once (I run at 1.5×), you configure the default voice once (I use English for explanations, auto-detect for multi-language prompts), and then you forget the app exists until you reach for it.

The Accessibility permission is one-time. The Screen Recording permission is one-time. The app is permanently free — no account, no subscription, no daily word limit. It runs as a menu-bar icon, it doesn't open any windows until you select text, and it stays completely out of your way otherwise.

A year from now every AI coding tool will probably have its own read-aloud feature, and they'll all be slightly different. For now, this is the one app that makes them all work the same way. Pick any of the nine pages linked above for a focused walkthrough of that specific tool, or see CastReader for Mac for the complete app overview. Your eyes will thank you.