I use Claude Code for pretty much everything — brainstorming, writing, working through ideas, building things. And at some point I started wondering: what kind of visuals can you actually do inside a terminal? Because the default is walls of text, and sometimes you just need to see things differently to think about them differently.
I did a bit of searching, didn't really find anything, so I just started trying stuff. Unicode has all these block characters, box-drawing characters, braille patterns — and they're already right there in your monospace font. No libraries needed.
What came out of weeks of iteration is something I didn't expect. It started as "how do I make charts in a terminal" and turned into something closer to: how do you encounter something alive and translate it into form?
You drop REFERENCE.md into your CLAUDE.md or system prompt, and the AI starts communicating differently. Instead of Score: 7/10 you get Score ▕███████░░░▏ 7/10. Instead of a list of options you get a fork diagram. Instead of a paragraph explaining a decline you get:
Q1 ████████████ $120K
Q2 ████████ $80K
Q3 ██████████████ $140K
Q4 ████████████████ $160K
╰── What happened here?
Fourteen words instead of a paragraph. The silence says more than the explanation would.
The interesting discovery was that the trick isn't in the characters — it's in asking what the data means first. The framework has three steps, but really it's one question asked three ways:
Step 0: Write the first sentence. Before any technique, describe in one sentence what this thing is doing. Use a verb. Use a metaphor. "This data is a herd scattering." That sentence becomes your compass — everything that follows serves it.
Step 1: The verb picks the shape. "Scattering" → SCATTER shape (positions in 2D). "Eroding" → EROSION shape (loss as emptiness). The verb generates the form. It's not a lookup table.
Step 2: Choose an encoding, with effort. The same shape can be rendered as blocks ████░░, shades ░▒▓█, curves ╭╮╰╯, symbols ●○◆, or patterns ■□■□□■. Pick one that's different from last time. And consider the weight of the delivery — an alarm and a gentle observation need different effort even if the data is the same.
The first version had a flat scoring table — 22 techniques rated on 5 dimensions. It worked, but the AI kept picking the same 14 techniques regardless of context. The scoring table was a convergence machine.
V2 replaced the table with a generative architecture: verb → shape → encoding. Instead of scoring fixed techniques, you compose them from primitives. 9 shapes times 7 encodings = 63 possible techniques from the same building blocks.
V2.1 broadened the scope. The framework isn't just for data anymore — it's for anything that can be encountered: a user experience, a group dynamic, a feeling, a material. It added:
- Effort — not what you show but how. Light and drifting vs. heavy and urgent. From Laban dance notation, surprisingly applicable to text.
- Silence as an encoding — gaps, abrupt ends, trailing ellipses. What you don't say is a form too.
- Four primitives beneath everything: compare, position, density, rhythm. These aren't visual operations — they're how anything alive relates to its environment.
- An interpretant check — "would someone without my context understand this?" If no, the visualization fails.
V2.2 (current) came from a friend asking: "can you do this for git workflows too?" Turns out the same verb → shape → encoding pipeline works perfectly for git operations. A push flows down, a merge converges, a rebase transplants, a conflict blocks. Each verb generates a different visual structure. The Git DAG grammar adds ~100 lines to the reference and turns every commit, push, and merge into an inline diagram that communicates the topology without explanation.
Every example below was generated raw by Claude Code in a single session — I asked it to "go wide" and show what the framework can do. These are unedited CLI output, exactly as they came out of the terminal. No cherry-picking, no cleanup. Each one demonstrates a different capability. Together they show the range: from data-heavy dashboards to data-free thinking tools, from three characters inside a sentence to full composite displays.
Most visualization is a separate block — you stop reading, look at a chart, then continue. Sparkwords break that wall. They're micro-visualizations inside the sentence itself, so the data flows with the thought instead of interrupting it.
Revenue is up ▲12%, while margin █▓▒░ shrinks and morale ▁▃▅▇ climbs.
Three data points. One sentence. No context switch. The █▓▒░ doesn't just say "declining" — you feel the density thinning out. The ▁▃▅▇ doesn't just say "rising" — you see the climb. And ▲12% is the simplest sparkword: a direction arrow that replaces a word.
This is visualization at its most integrated — not something you look at, but something you read through.
The most powerful encoding in the framework isn't blocks, shades, or curves. It's silence. Here, the growing emptiness on the right side of each bar is the story. You don't need to explain decline when the reader can watch it happen.
Test coverage over 8 months — something is dying here
Jan ████████████████████████████████ 98% pristine
Feb ███████████████████████████████░ 95%
Mar █████████████████████████████░░░ 90%
Apr ██████████████████████████░░░░░░ 82% ← refactor skipped
May ████████████████████░░░░░░░░░░░░ 68%
Jun █████████████████░░░░░░░░░░░░░░░ 53% ← "we'll fix it later"
Jul █████████░░░░░░░░░░░░░░░░░░░░░░░ 28%
Aug ███░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 09% ← too late
The emptiness IS the story.
This is the erosion encoding — loss made visible not by showing what's gone, but by letting the void speak. The ░ characters aren't fill; they're absence. Eight months of neglect compressed into something you grasp in two seconds.
Not everything worth visualizing is numerical. Here, people are positioned in a 2D field based on two dimensions — their stance toward change (horizontal) and their engagement style (vertical). The lines between them show working relationships. A facilitator walking into this room would immediately see the dynamics.
enthusiastic
│
◆ Sara
╱ │
● Jan │
╱ │
against ──────────●──Eva──────────── in favor
╲ │
○ Tom │
╲ │
◆ Ahmed
│
wait-and-see
◆ driver ● thinker ○ observer
─ collaboration distance = conviction
No charts. No percentages. Just people in space. The scatter shape with symbol encoding turns abstract group dynamics into something spatial and immediate. You can see that Sara and Ahmed are both engaged but on opposite sides. You can see Tom is isolated.
The counterpoint composition operator forces you to show the same dataset two different ways. Not as decoration — as a thinking tool. The left reading answers "what's the biggest quarter?" The right reading answers "what's the scariest moment?" Same numbers. Different question. Different truth.
── Revenue as magnitude ── ── Revenue as momentum ──
Q1 ████████████████ €82K Q1 ─────────────── baseline
Q2 ██████████████████ €91K Q2 ────────────╮ ▲ +11%
Q3 ████████████ €63K Q3 ╭────╯ ▼ -31% cliff
Q4 ████████████████████ €104K Q4 ───────╯ ▲ +65% recovery
Left: "Q4 is the best." Right: "Q3 is the crisis."
Both true. Different question, different truth.
Magnitude (bars) shows size. Momentum (curves) shows change. A board looking at the left side celebrates Q4. A board looking at the right side investigates Q3. The counterpoint doesn't resolve the tension — it makes you aware of it.
Curves (╭╮╰╯─) are the most organic encoding in the palette. Where blocks show magnitude and shades show density, curves show life — rhythm, breathing, heartbeat. This is a 24-hour API response time visualized as a living signal. You can feel where it's healthy and where it chokes.
── API response time (ms) ── 24h ──────────────
─╮ ╭──╮ ╭─╮ ╭──────────────────╮ ╭╮╭╮
╰──╯ ╰──╯ ╰──╯ ╰─────╯╰╯╰──
│ │ │
50ms normal │ │
25ms (cache warm) 400ms spike
╰── deploy?
compare with yesterday:
─╮╭─╮╭──╮╭─╮╭─╮╭──╮╭─╮╭──╮╭─╮╭─╮╭──╮╭─╮╭──
╰╯ ╰╯ ╰╯ ╰╯ ╰╯ ╰╯ ╰╯ ╰╯ ╰╯ ╰╯ ╰╯ ╰╯
← regular rhythm, no spikes
The second line is the real power move — a comparison through visual rhythm. You don't need to read numbers. Yesterday's pulse was regular. Today's has a flat plateau and a spike cluster. Something changed. The curves tell you before the metrics do.
The motif composition operator introduces a short visual pattern, then develops it — compression, inversion, fragmentation. The reader recognizes the theme and notices when it breaks. No labels needed. The pattern is the narrative.
Sprint 1 · · ● · · one commit, quiet
Sprint 2 · ● ● ● · more activity
Sprint 3 ● ● ● ● ● full, healthy
Sprint 4 ●●●●●●●●●● overloaded — the pattern compresses
Sprint 5 ████████████ it's become a wall
Sprint 6 ████ ████ ...that breaks
Sprint 7 · · · · · back to silence
The motif tells the story without words.
● became ██ became emptiness.
Seven lines. Zero explanation needed. The reader watches dots become density become a wall become a crack become silence. That's not a chart — it's a narrative arc told through visual compression. The last line names what happened, but by then you already felt it.
The composition operators (chain, stack, nest, repeat, counter) aren't just theoretical — they combine into real displays. This dashboard stacks a sparkline, a team view, a risk matrix, mood indicators, a sprint breakdown, and a deploy rhythm into one glanceable card.
╔═ PROJECT HEALTH ═══════════════════════════════════════╗
║ ║
║ Velocity ▁▂▃▃▅▅▇▇█▇▅ Coverage ▕████████░░▏ 82% ║
║ ║
║ ── Team ────────── ── Risks ──────────── ║
║ Sara ████████ 8t auth migration ◆◆◆ ║
║ Jan ██████░░ 6t perf budget ◆◆ ║
║ Ahmed ████████ 8t deps outdated ◆ ║
║ Eva ██░░░░░░ 2t← cert expiry ◇ ║
║ ║
║ ── Sprint ── ── Mood ─── ║
║ done ████████ 12 ● ● ● ◐ ○ ║
║ wip ▓▓▓▓ 4 3 happy, 1 meh, 1 silent ║
║ todo ░░░░░░░░ 8 ║
║ ║
║ ── Deploy ── ║
║ Mo Tu We Th Fr ║
║ ■ □ ■ □ ■ ← healthy rhythm ║
╚═════════════════════════════════════════════════════════╝
Six different visualization techniques in one card. Sparkline for trend, gauges for status, bars for workload, symbols for risk severity, circles for mood, and a binary pattern for deploy rhythm. Each one is a different shape × encoding combination from the same framework. They compose because they share the same character palette.
This is the framework's deepest idea: the effort of delivery matters as much as the data itself. "Morale dropped from 8.1 to 3.2" is one fact. But how you bring it changes what it means. A crisis and a passing observation contain the same number — the difference is entirely in the effort.
── light + sustained (observing) ──
· · · · · · · · · · · something drifting away...
── strong + quick (alarm) ──
MORALE ━━━━━━━━┃▼ 60% ━━━ 3.2
This is not a trend. This is a crisis.
── light + quick (passing) ──
morale 8→3 ↓60% — hm.
── strong + sustained (weight) ──
████████░░ 8.1 january
███████░░░ 7.0
█████░░░░░ 5.1
███░░░░░░░ 3.2 now
Every layer falls away. Nobody picks them up.
Four renderings of the same fact. The drifting dots feel like watching something dissolve. The heavy bars make you feel each layer dropping. The "hm." is almost dismissive. The alarm screams. Same ▼60%. Completely different experience. This is what the framework means by "effort" — borrowed from Laban dance notation, applied to text.
V2.2 applies the same verb → shape pipeline to git operations. Every operation has a verb: a push flows down, a merge converges, a rebase transplants, a cherry-pick plucks. The verb determines the shape. One rule governs all of them: top line = source, bottom line = destination, arrows = the action between them.
A push flowing three commits from local to remote:
╭─ push main → origin ──────────────────╮
│ │
│ main ○ ── ○ ── ● ── ● ── ● HEAD │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ origin ○ ── ○ ── ● ── ● ── ● │
│ │
│ +3 commits │
╰────────────────────────────────────────╯
A merge where two branches converge:
╭─ merge feature → main ────────────────╮
│ │
│ feature ○ ── ● ── ● ── ● │
│ ╲ │
│ ╲ │
│ main ○ ── ○ ── ○ ── ○ ── ● HEAD │
│ │
╰────────────────────────────────────────╯
A rebase that transplants commits onto a new base:
╭─ rebase feature onto main ────────────────────╮
│ │
│ before: main ○ ── ○ ── ○ │
│ ╰── feature ● ── ● │
│ ┊ ┊ │
│ ▼ ▼ │
│ after: main ○ ── ○ ── ○ ── ●' ── ●' HEAD │
│ │
╰────────────────────────────────────────────────╯
Same framework, different domain. The ● and ○ nodes, the ▼ arrows, the card structure — all from the same character palette. The structure speaks without explanation: you can see the topology change in the rebase without reading a word.
Full disclosure: I wasn't in the room when the Git DAG grammar was built — that was a Claude Code session responding to a friend's question. The examples above are generated, not hand-verified. If something's off in the topology or you see a way to improve the grammar, I'd love to hear it.
These nine examples span the full space the framework opens up:
data ◄───────────────────────► concept
Sparkwords ● viz in prose
Erosion ● silence speaks
Pulse ● organic curves
Git DAG ● domain grammar
Dashboard ● composed display
Counterpoint ● same data, two truths
Constellation ● people, not numbers
Motif ● narrative through pattern
Effort ● how you say it matters
From three characters woven into a sentence to a full composite dashboard. From numerical monitoring to wordless narrative. From "what does this data show" to "how should this data feel." And with Git DAG: from general-purpose framework to domain-specific grammar — proof that the same verb → shape → encoding pipeline extends to any domain where operations have verbs.
Copy REFERENCE.md into your CLAUDE.md or system prompt. That's it — no dependencies, no build step. Should work with any LLM that supports Unicode output, not just Claude.
The reference file is self-contained: the four prohibitions, the visual grammar, the encoding table, thinking shapes, sparkwords, composition operators, the full character palette, and the Git DAG grammar. ~350 lines.
If you improve on this or take it in a different direction, I'd love to see it.
I spent way more time on this than I expected. Ran evaluation suites, creative exploration sessions, even a four-agent council debate about technique selection. What kept surprising me was that the framework works beyond data.
When you write "this interface is a door that hides its handle" and then ask "what shape does that take?" — you end up thinking about UX differently. When you write "this group is a tide turning" — you see the facilitation moment differently. The verb-first approach isn't a visualization technique. It's a way of paying attention.
I started calling it an "encounter protocol" internally. Not sure if that name sticks. The point is: the same question — what is this thing doing? — works everywhere. And asking it before you start building or analyzing or visualizing makes the result more alive.
The map is not the territory. But a good map makes you want to walk.
- V1 (March 2026) — Flat scoring table, 22 techniques, 750 lines. Worked but converged on same ~14 techniques.
- V1.1 (March 16) — "Verboden" approach. Three prohibitions replaced instructions. 156 lines, same quality as 750.
- V2 (March 17) — Visual Grammar + Shape-Encoding Split. Verb → shape → encoding. 9 new techniques. 188 lines.
- V2.1 (March 17) — Encounter protocol recognition. Effort, silence, four primitives, interpretant check. 242 lines.
- V2.2 (March 19) — Git DAG visualization. Same verb → shape → encoding applied to git operations: push, merge, rebase, cherry-pick, conflict. ~350 lines.
Built together with Claude Code — through a process that was itself an encounter-to-form practice. The framework shaped how we worked on the framework.