Daniel sent us this one — and you can hear the excitement in how he wrote it. He's been using Linux for twenty years, has ADHD, and always bounced off CLI-first workflows because of the sheer memory tax of flags and parameters. Then Claude Code happened. Suddenly he's got one interface that knows every CLI tool's syntax, so he doesn't have to. A year in, he's finally living in the terminal full-time. But now he's noticing where the visual experience falls short — and he wants a run-through of the modern tools that add design punch without leaving the terminal container. Tools like LSD, which he just discovered. The question is: what else is out there?
It's a perfect moment to ask it. The terminal is having this quiet renaissance — not because people got nostalgic for green text on black, but because AI agents finally solved the CLI's biggest cognitive friction. For neurodivergent users especially, this changes everything. You've got someone with ADHD who tried for two decades to make the terminal work, and the missing piece wasn't willpower or practice. It was a cognitive prosthetic.
That's the phrase you're landing on.
It's the right phrase. Claude Code collapses the interface surface from hundreds of tools times dozens of flags each, down to one tool times natural language. That's not automation — that's accessibility engineering, whether they meant it to be or not. And once you've removed the memory burden, you start noticing where else the terminal creates friction. The visual monotony. The lack of hierarchy. The way every command outputs a wall of undifferentiated text that your brain has to parse character by character.
The episode is really about the intersection of three things that don't usually share a sentence: cognitive accessibility, AI agents, and terminal aesthetics. And the through-line is — what happens when an interface that's been hostile to certain brains for fifty years suddenly becomes the most accessible one in the stack?
Let's dig into why the memory tax hits ADHD brains so specifically, and how Claude Code actually solves it. Because the mechanism here is more interesting than just "AI remembers stuff for you.
The twenty-three minute problem.
So here's the research: when you're deep in a task and something interrupts you — a Slack message, a forgotten flag, a quick Google search — it takes an average of twenty-three minutes to fully regain your focus. That's not a guess, that's from a UC Irvine study that's been replicated. Now think about what happens in a traditional CLI workflow. You're trying to extract a specific set of files from a tar archive. You know tar exists. You know the archive name. But you can't remember whether it's dash x dash f or dash x v f, or whether the f flag goes before or after the filename, or whether you need a dash at all for the short options or if tar even uses dashes anymore because some implementations don't.
The moment you open the man page, you've left your task.
You've left your task, you've entered a documentation document that is famously dense and not organized around your intent, and now you're reading about incremental backups and multi-volume archives and something called a "checkpoint action" which sounds interesting, actually, maybe you should understand how that works before you proceed —
Thirty minutes later you're reading about something completely unrelated and the original task is a distant memory. This is the man page trap.
The man page trap. And for someone with ADHD, this isn't a minor inconvenience. The attentional cost of context-switching is amplified. Executive function is already working harder to maintain task focus. Every interruption isn't just a delay — it's a potential derailment of the entire work session. You might not come back to that task at all. The tar archive sits there unextracted for three days.
What does Claude Code actually change about this loop?
It changes where the interruption happens. Or rather, it eliminates the interruption entirely. You type "extract the archive dot tar dot gz to a folder called project-data" and Claude Code constructs the command. It knows tar's flag syntax across implementations. It knows whether your system expects the dash or not. It constructs tar -xzf archive.gz -C project-data and executes it. You never leave your intent space.
The intent space. That's the thing you're protecting.
That's the whole game. The terminal has always been powerful — that was never the problem. The problem was that accessing that power required you to leave your intent space and enter the tool's documentation space, sometimes dozens of times per session. Claude Code lets you stay in your intent space. You describe what you want to accomplish; it handles the translation layer.
Give me a concrete example.
Here's one. Say you want to find all Python files modified in the last week that contain TODO comments. The traditional command is find. py' -mtime -7 -exec grep -l 'TODO' {} \;. That's find with a glob pattern, a time filter, an exec flag that invokes grep, a semicolon that has to be escaped because the shell will interpret it otherwise, and a pair of curly braces that get replaced with each filename. If you don't use find regularly, you're not constructing that from memory. You're looking up find's exec syntax, then grep's flags, then shell escaping rules. That's three context switches minimum.
With Claude Code?
"Find all Python files modified in the last week that contain TODO comments." That's it. That's the input. Claude Code knows find's exec syntax. It knows grep's dash l flag. It knows about shell escaping. You never think about any of those things. You stay in the problem domain — which is "I need to find TODO comments in recent Python files" — rather than dropping into the tool domain of "how do I construct a find exec command.
There's a criticism that surfaces here, and I want to address it head-on. The argument that using AI to construct commands makes you a worse developer because you never learn the underlying tools.
I think that argument misunderstands what expertise actually is. Expertise isn't memorizing flags. It's understanding what's possible and knowing how to express intent. The flags are implementation details. If you know that find can search by modification time and execute commands on results, you have the expertise. Whether you type the syntax from memory or describe it to an AI — the cognitive work of understanding the problem is the same. What's different is whether you also have to do the clerical work of syntax construction.
It's like saying using a calculator makes you worse at math. No, it frees you to do more interesting math.
And for neurodivergent users specifically, the clerical work isn't just tedious — it's actively exclusionary. It's the difference between being able to use the terminal and not being able to use it at all. Daniel spent twenty years wanting to be CLI-first and couldn't make it stick. Not because he didn't understand Linux, not because he wasn't technical enough, but because the memory tax on rote syntax was incompatible with how his brain works.
The knock-on effect here is bigger than one person's workflow. If you remove the memory tax, the terminal becomes viable for whole categories of users who previously found it inaccessible. Junior developers who haven't built up flag fluency yet. Data scientists who use the terminal occasionally but not daily. Sysadmins who touch dozens of different tools and can't maintain deep fluency in all of them. Non-engineer technical roles.
Here's the thing that doesn't get said enough: the terminal's text-based nature is actually cognitively easier for some neurodivergent brains. It's linear. It's predictable. There's no spatial layout to parse, no icons to decode, no nested menus to navigate. Every interaction follows the same pattern: you type something, you get text back. For someone who finds graphical interfaces visually overwhelming or spatially confusing, the terminal's austerity is a feature, not a bug.
The problem was never the interface itself. It was the memory burden layered on top of it.
And Claude Code strips that layer away. So now you've got someone with ADHD who finally has an interface that works with their brain instead of against it. They're living in the terminal eight, ten hours a day. And that's when the second problem becomes visible.
The visual poverty.
The terminal is robust and fast and cognitively clean. But it's also a wall of monospaced text in one color — or maybe a handful of colors if you've configured things. There's no visual hierarchy. No information density through design. Every piece of output demands the same level of attention. Your brain has to read every character to understand what you're looking at, because nothing is visually distinct at a glance.
This is where Daniel's phrase "design punch" comes in. He's not asking for the terminal to be pretty. He's asking for visual scaffolding that helps his brain parse information faster.
And the good news is there's a whole ecosystem of modern terminal tools that do exactly this. They're mostly written in Rust — which matters because they're fast, they have zero runtime dependencies, and they install as single binaries. They're drop-in replacements for classic GNU tools, so you don't have to change your workflow. You alias ls to lsd and everything just works. But the output has visual hierarchy now.
Let's go through them. Start with lsd.
LSD — it stands for LSDeluxe. It's a replacement for the ls command. The core insight is that when you list files, your brain wants to answer several questions instantly: what type of file is this, what are the permissions, how big is it, is it a symlink. Traditional ls -la gives you all that information as text. lsd gives it to you as visual information. Directories get one color and an icon. Executables get another. Symlinks get an arrow indicator. File sizes get human-readable formatting with color coding. Permissions get visual distinction.
Instead of reading "d r w x r dash x r dash x" and mentally parsing each character, you see an icon and a color and your brain goes "directory" instantly.
And for someone with ADHD, that's the difference between "I can scan this directory listing" and "I have to read this directory listing." Scanning is fast and low-effort. Reading every character of every line is slow and fatiguing. Multiply that by dozens of directory listings per day, and the cognitive savings add up.
It also does tree view, right?
Yeah, lsd --tree gives you a visual directory tree with the same color coding and icons. You can see the structure of a project at a glance without having to mentally reconstruct it from flat listings. And it handles symlinks gracefully — shows you where they point with a little arrow indicator, so you never accidentally follow a symlink thinking it's a real directory.
Bat is a replacement for cat — the command that dumps file contents to the terminal. Bat adds syntax highlighting, line numbers, and Git integration. If you're reading code in the terminal all day, syntax highlighting is not cosmetic. It's a cognitive scaffold. Your brain uses color to parse structure — keywords in one color, strings in another, comments in another. That structure helps you understand what you're looking at before you've read a single word.
It's the same principle as lsd. You're adding visual hierarchy so the brain can parse faster.
Bat does a few other clever things. It automatically pipes output through a pager if it's longer than your screen, so you don't have to remember to pipe to less. It shows non-printable characters so you can spot encoding issues. And the Git integration shows you which lines have been modified, added, or deleted relative to the HEAD commit — little markers in the margin. For someone working with version-controlled code, that's context you'd otherwise have to run a separate git command to get.
Bat collapses three steps — read the file, check what's changed, handle long output — into one command with visual indicators.
And that's the pattern with all these tools. They're not adding features for the sake of features. They're collapsing multi-step workflows into single commands with visual output that your brain can parse at a glance.
This is the find replacement.
Fd is a faster, more intuitive find. The speed matters for ADHD users — slow tools break flow state. If you're deep in a task and find takes three seconds to return results, that's three seconds of dead air where your attention can drift. fd returns results instantly for most searches. It also has sensible defaults that reduce the cognitive load of constructing searches. It respects dot gitignore patterns by default, so you don't get results from node_modules or dot git directories unless you explicitly ask for them. It uses regex by default instead of glob patterns, which is more intuitive for most technical users. And it color-codes output by file type — same principle as lsd.
Give me a before and after.
Traditional find: find. rs' -type f -not -path '.You have to remember to exclude the build directory manually, remember the dash type flag, remember that dash name uses glob patterns. With fd: fd '.rs$'` — that's it. It automatically ignores target and dot git. It automatically only returns files. The regex pattern is more expressive than glob. And the output is color-coded.
The build directory exclusion alone — how many times have you run find and gotten a thousand results from node_modules or target and had to re-run with an exclusion?
And every re-run is a context switch. Every re-run is a moment where you might lose the thread. fd eliminates that entire class of friction.
This one's different — it's not a visual polish tool, it's a navigation tool.
Zoxide is a smarter cd. It learns your directory preferences over time. Instead of typing cd../projects/claude-code/src/utils, you type z claude utils and it jumps there. It uses a frecency algorithm — frequency plus recency — to rank directories. The more you visit a directory, and the more recently you've visited it, the higher it ranks in the fuzzy matching.
This solves a specific ADHD friction point: getting lost in the filesystem.
Deep directory trees are disorienting. You have to hold the whole path in your head, or keep running pwd to check where you are, or open a new terminal tab because you're not sure how to get back. Each of those is a context switch. Zoxide collapses all of that into a few keystrokes. You think "I want to be in the utils directory of the Claude Code project" and you type z claude utils and you're there. The cognitive load of navigation drops to nearly zero.
It works with multiple terminal tabs, right? It shares the database across sessions.
The database is a single file that all your terminal sessions read from and write to. So if you navigate somewhere in one tab, zoxide knows about it in all tabs. You can open a fresh terminal and immediately jump to your most-used directories without retracing your steps.
This is the git diff pager.
Delta is a syntax-highlighting pager for git diff output. Traditional git diff shows you a wall of green and red text. Lines that were added, lines that were removed. If you're reviewing a large changeset, you have to read every line carefully to understand what actually changed — the visual presentation doesn't help you parse the structure.
For someone with ADHD, that wall of undifferentiated color is exhausting.
It's exhausting and it's error-prone. Delta adds side-by-side view, line numbers, and language-aware syntax highlighting to the diff output. So you're not just seeing "this line was added" — you're seeing "this line was added and it's a function definition in Python and here's the function signature highlighted as a function signature." Your brain can parse the structure of the change before it parses the content.
That's the key phrase you keep coming back to: parse the structure before the content. That's what visual hierarchy does.
That's what all of these tools do. They add a layer of structural information that your visual system processes automatically, before your conscious attention engages. Color coding says "this is a directory, this is an executable, this is a symlink" in milliseconds. Syntax highlighting says "this is a keyword, this is a string, this is a comment" in milliseconds. Your brain gets the structure for free, and your conscious attention can focus on the content.
The last one — Starship.
Starship is a prompt — the thing that sits at the beginning of every command line. Traditional prompts show you a dollar sign or maybe your username and current directory. Starship shows you contextual information: current directory, Git branch, Python version, Node version, command duration, error status of the last command. All in a minimal, fast format that doesn't clutter the line.
The prompt as a "you are here" marker.
When you're deep in flow state, it's easy to lose track of context. What directory am I in? What branch am I on? What environment am I using? A good prompt answers those questions before you have to ask them. Starship does it with visual modules that you can configure — you turn on the modules that matter for your workflow and ignore the rest. And because it's written in Rust, it renders instantly. No perceptible delay between pressing enter and getting your prompt back.
The common thread across all six of these tools is striking. They're all Rust. They're all drop-in replacements. They all add visual information density without adding visual noise. And they're all designed for people who spend their entire day in the terminal and need to extract information quickly.
They all emerged from the same recognition: the terminal's power was never in question, but its usability was neglected for decades. The GNU coreutils were designed in an era when terminal output was constrained by teletype speeds and eighty-column displays. Visual hierarchy wasn't a design consideration because visual hierarchy wasn't possible. Now we have true color terminals, Unicode support, and GPU-accelerated rendering. The constraints are gone. These tools are filling a design gap that's been there since the seventies.
We've got the cognitive prosthetic — Claude Code removing the memory tax — and the visual polish — these Rust tools adding information hierarchy. What does this mean for someone who wants to actually set up their terminal this way?
Start with the tool that solves your biggest pain point. Don't try to replace everything at once — these are drop-in replacements, so each one works immediately and independently. If you get lost in the filesystem constantly, install zoxide first. If you read code in the terminal all day, install bat and delta. If you want visual clarity in directory listings, install lsd. Use it for a day. Notice where it reduces friction. Then install the next one.
The goal isn't a beautiful terminal. It's a terminal that works with your brain instead of against it.
That's what makes this moment interesting beyond just "here are some cool tools." The terminal is fifty years old and it's finally growing up. It's becoming an interface that adapts to humans, not the other way around. For decades, the implicit bargain was: the terminal is powerful, but you have to meet it on its terms. You have to memorize its syntax, tolerate its visual austerity, work around its limitations. That bargain is breaking down.
Because AI agents collapse the memory burden, and modern tooling adds the visual scaffolding. The terminal doesn't demand you adapt to it anymore.
I think that's going to accelerate. Claude Code is just the beginning. As AI agents get better at understanding intent and executing complex workflows, the CLI might become the most accessible interface in the stack — not the least. Text is the most flexible input modality we have. It's precise, it's composable, it's scriptable. The only thing holding it back was the learning curve. If AI flattens that curve, text becomes the universal interface.
The open question is whether we eventually move beyond text entirely. Voice interfaces, visual programming environments, spatial computing. But I think there's something durable about text. It's the highest-bandwidth output of the human brain. You can think faster than you can speak, and you can type almost as fast as you can think. Voice interfaces will always have a ceiling on information density.
Text is searchable, version-controllable, and automatable in ways that visual interfaces struggle with. I don't think we're abandoning text. I think we're finally making text work for everyone, not just the people who can memorize man pages.
If you're listening to this and you've been curious about living in the terminal — or you've tried and bounced off the way Daniel did for twenty years — the landscape has changed. Claude Code removes the memory tax. These Rust tools add the visual hierarchy. You can have an interface that's fast, powerful, and cognitively accessible in ways the terminal has never been before.
Install one tool this week. See where it reduces friction. Build from there. The terminal renaissance is real, and it's not about nostalgia. It's about accessibility.
And now: Hilbert's daily fun fact.
Hilbert: In the nineteen forties, microbiologists on Sakhalin Island discovered that a local cheese produced an audible crackling sound during fermentation — a phenomenon later traced to a strain of Lactobacillus that released carbon dioxide in rhythmic bursts, creating a faint acoustic signature that cheesemakers used to monitor ripeness without opening the aging vault.
Acoustic cheese monitoring. In the forties.
I have so many questions and I'm going to choose not to ask any of them.
This has been My Weird Prompts. Our producer is Hilbert Flumingtop. If you enjoyed this episode, tell someone who spends too much time squinting at git diffs. You can find us at my weird prompts dot com. I'm Corn.
I'm Herman Poppleberry. See you next time.
