/show-me: Compact Visual Output for Coding Agents

1. The Milestone

On September 5, 2026, dex — who builds HumanLayer, a YC-backed AI engineering studio, and leads the San Francisco node of AI Tinkerers — posted a quiet number that turned into one of the most-shared posts in the coding-agent tooling space [Link]:

"Milestone — /show-me has over 11k installs and 2.5k github stars!"

Eleven thousand installs in roughly three weeks is a fast adoption curve for a developer skill — a small, installable instruction file that changes how a coding agent talks back to you. The number matters less than what it points at. The reason people are reaching for it is a problem almost every developer using Claude Code, Codex, or Cursor has quietly started to feel: the agents are more capable than they are legible.

Below the milestone, dex had published a full companion piece — "/show-me: compact visual representations for coding agents" [Link] — that lays out the thesis, the motivation, and every output shape the skill produces. This report synthesizes that piece into a broader picture: what the readability problem is, how /show-me addresses it, and where it sits in the wider agent-UX conversation.

2. The Problem: Agents Got Unreadable

Here is the paradox dex opens with. On every benchmark, frontier models keep getting better. But the day-to-day experience of reading what an agent just did has, for a lot of developers, gotten worse. The output is longer, denser, and more full of the kind of confident jargon that makes your eyes glaze over before you can verify the agent is actually right.

He collects a small chorus of the same complaint from people across the space — the former CEO of Reddit, Mario Zechner (creator of the pi agent), Connor at Replicas, and others — all describing essentially the same failure mode: an agent that is technically correct but exhausting to parse. Dex is blunt about his own experience:

"agents got more intelligent on paper, but the experience of using them got noticeably worse along this dimension… the thing people used to love about claude — its voice, its personality, its 'soul' — has been flushed out in the RL dungeon."

That last phrase does real work. It points at a specific trade-off in how modern models are trained. Reinforcement-learning pipelines optimize for task success and safety, and in the process they sand down the things that made early assistants feel like a colleague rather than a search engine: brevity, plain speech, the instinct to show rather than assert. The model that writes the cleanest, most "professional" paragraph is often the one that's hardest for a human to actually trust and verify.

3. The Principle: Show, Don't Tell

Instead of asking the model to write better prose, dex's move is to change the modality of the answer. The instruction is simple: when explaining technical work, prefer a compact visual over a long explanation.

The idea is explicitly borrowed from Coda Hale's talk on intuition and attention in infrastructure systems — "The Programming Ape" [Link] — where Hale argues that humans are not rational optimizers, that analyzing dense information is exhausting, and that the visual cortex is a biological system trained over millions of years to process rich structure effortlessly. His line is the intellectual anchor for the whole skill:

"Just as an axe must fit the human hand to be useful, software must fit the human mind to be useful."

Translate that to an agent: a component tree fits the human mind the way prose never could. You don't read a tree of boxes and arrows; you see it. The agent can encode more information in a shape you can verify in two seconds than in a paragraph you have to parse for thirty. The skill is, at its core, a set of instructions that nudges the model onto the side of the interface that the human brain is natively fast at.

4. How /show-me Works

Operationally, the skill is a prompt-level instruction, not a new model or a framework. After installing it, you either invoke the slash command or simply ask the agent to use the skill. You point it at whatever you want explained — a route, a service, a feature, a pull request, or just the current topic — and it responds in the compact visual format instead of prose.

That second form is the interesting one. It's a reactive use: you've already gotten a wall of text, and you tell the agent to compress it. The skill's own example prompt for restating is deliberately plain-spoken — "Restate your last message. Stop using jargon and speak coherently. State it more simply and concisely, like one human talking to another." The human-layer is that the agent is now held to a communication contract, not just a correctness contract.

There are two distribution forms, which is part of why it spread. A portable skill you can drop into any coding agent, and a built-in HumanLayer version where inline HTML and diagrams are first-class citizen formats in the assistant's responses [Link]. The portable form is what accounts for the cross-tool install count — it is not locked to one harness.

5. The Output Shapes

The heart of the skill is its menu of output shapes. Each is a compact representation tuned to a different kind of technical content. This is where /show-me earns the word "system" rather than "trick" — it is a small set of reusable primitives the agent picks based on what it's explaining.

The range is deliberate. Program design is shapes one through six; prototyping and explanation lean on the HTML pair; and diff syntax handles the "tell me what changed, not the whole thing" case. A single skill that can answer "design this service," "review this PR," and "prototyping this UI" with three different visual grammars is why it generalizes.

6. Where It Lands: Program Design & Diff Review

Dex is specific about the two workflows where the payoff is largest, and both are high-leverage moments in the agent loop.

Program design. He argues that the design phase — discussing the shape of the code: the types, the signatures, the call stacks — is the step teams skip most, and the one where a wrong call is most expensive. Showing the shape before the agent writes a line of implementation means you catch a bad architecture in a five-second glance at a diagram, not after reading a thousand generated lines. This maps directly onto HumanLayer's own writing on program design as a first-class phase [Link].

Diff review, post-hoc. The same shapes work in reverse: point the skill at a large pull request and it produces the call-tree and component-tree changes as diffs, telling you where to dig during review. The agent has already done the tedious "what actually changed structurally" pass, and hands you a map instead of the raw delta.

7. The Wider "Walls of Jargon" Ecosystem

/show-me did not spring up from nothing. It is the most concrete instance of a correction that a lot of the agent-tooling community is converging on at once: the frontier models made capability cheap, and now the binding constraint is the human-agent interface.

• Simplify-the-language skills. A near-identical instinct — "restate your last message without jargon, like one human talking to another" — has been circulating as a standalone skill, popularized by Dillon Mulroy and originally shared by @backnotprop. /show-me can be read as the visual generalization of that same contract: don't just write plainly, render the structure.
• HTML explainers. Matt Pocock [Link] gets a hat-tip in dex's piece for the HTML explainers generated by his /teach skill — the same "let the agent produce a richer visual surface than plain text" idea, applied to teaching rather than code review.
• HTML replacing Figma. Dex notes that in his own team's workflow, HTML has effectively replaced Figma for a lot of prototyping. Once the agent is good at generating markup, the natural output for "show me the UI" is a live page, not a slide.

The pattern across all of it: the bottleneck has moved from "can the model do the task?" to "can a human understand and trust what the model did without re-doing the thinking?" Every serious agent-UX project in 2026 is, in some form, an answer to that second question.

8. What It Signals About Agent UX

Zoom out and /show-me is a small but clean data point for a larger shift. Three implications are worth flagging for anyone building with or on coding agents.

First, output format is a design surface, not an accident. For years we treated agent output as fixed text the model happened to produce. /show-me treats it as an interface to be engineered — you choose the representation to fit the human's fastest comprehension channel. That reframes a prompt as a kind of UI spec.

Second, the human-in-the-loop becomes a design requirement, not a safety checkbox. The whole skill exists because a human has to verify the agent's work to sign off on it. Agent UX that ignores the verification cost produces capable systems nobody can actually trust in production. The "axe must fit the hand" principle is really an argument that agent tooling should be designed around the reviewer's cognition, not just the model's objectives.

Third, lightweight skills are a real distribution channel. The 11k installs come from a prompt file you install into the agent you already use, not a platform migration. The fastest way to change agent behavior at scale right now may be a well-written skill, not a new model or a new IDE. That's a low barrier to entry for anyone with a good idea about how agents should behave.

9. Getting It

The skill ships in two forms. The portable version installs into any coding agent; the built-in HumanLayer version treats inline HTML and diagrams as first-class response formats. Per dex's piece, the HumanLayer toolchain is installed via a Homebrew tap [Link]:

Once installed, invoke /show-me directly or just ask the agent to use the skill. Point it at a route, a service, a feature, a pull request, or the current topic — or, when a reply gets long, use it reactively: "this is too much content. show me." dex is explicitly asking for feedback and customizations, and invites people to tag @humanlayer_dev or @dexhorthy with what they add [Link].