> ## Documentation Index
> Fetch the complete documentation index at: https://docs.monolex.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Constitutional AI, Flickering UX
> They wrote a constitution for AI safety. They forgot to write one for user experience.
# Constitutional AI, Flickering UX
```
╔═══════════════════════════════════════════════════════════════════════════════╗
║ ║
║ "We've written a Constitution for AI. ║
║ Just not for our terminal." ║
║ ║
║ — So Anthropic ║
║ ║
╚═══════════════════════════════════════════════════════════════════════════════╝
```
***
## The Beautiful Irony
Anthropic, the company that:
* Published papers on "Constitutional AI"
* Talks about "AI Safety" at every conference
* Claims to build "the most advanced AI"
* Has a manifesto about responsible AI development
Also ships a terminal that:
* Flickers like a broken slot machine
* Crashes your IDE after 10 minutes
* Shows you content from 9 seconds ago
* Deletes your scrollback history to "fix" rendering
```
┌─────────────────────────────────────────────────────────────────┐
│ THE ANTHROPIC MANIFESTO │
├─────────────────────────────────────────────────────────────────┤
│ │
│ "We believe in building AI that is: │
│ │
│ ✓ Safe │
│ ✓ Beneficial │
│ ✓ Transparent │
│ ✓ Aligned with human values" │
│ │
│ Meanwhile, their terminal: │
│ │
│ ✗ Causes seizure-like flickering │
│ ✗ Crashes your workflow │
│ ✗ Hides scrollback (not transparent) │
│ ✗ Makes you wait 9 seconds to see current state │
│ │
│ ─────────────────────────────────────────────────────────── │
│ │
│ The Constitution protects Claude. │
│ Nothing protects Claude Code users. │
│ │
└─────────────────────────────────────────────────────────────────┘
```
***
## Soul Without Body
```
┌─────────────────────────────────────────────────────────────────┐
│ THE "SOUL" OF CLAUDE │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Anthropic talks about: │
│ │
│ • "Claude's soul" (their training methodology) │
│ • "Constitutional AI" (safety through principles) │
│ • "Harmlessness" (avoiding dangerous outputs) │
│ • "Helpfulness" (being genuinely useful) │
│ │
│ ─────────────────────────────────────────────────────────── │
│ │
│ But when Claude tries to HELP you through Claude Code: │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ FLICKERING ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ │ │
│ │ ░░░░░░░░░░░░░░░ FLICKERING ░░░░░░░░░░░░░░░░░░░░ │ │
│ │ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ FLICKERING ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ │ │
│ │ ░░░░░░░░░░░░░░░ FLICKERING ░░░░░░░░░░░░░░░░░░░░ │ │
│ │ │ │
│ │ "Is this... helpful?" │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ The soul is willing. The terminal is weak. │
│ │
└─────────────────────────────────────────────────────────────────┘
```
***
## The 240fps Paradox
They say: "Use a faster terminal! Alacritty runs at 240fps!"
We ask: **240fps of what?**
```
┌─────────────────────────────────────────────────────────────────┐
│ THE 240FPS PARADOX │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Native Terminals: "We render at 240fps!" │
│ │
│ Alacritty: GPU-accelerated, ~240fps │
│ Ghostty: Metal/Vulkan, ~240fps │
│ WezTerm: wgpu, ~240fps │
│ Kitty: GPU-rendered, ~240fps │
│ │
│ ─────────────────────────────────────────────────────────── │
│ │
│ Claude Code: "Great! I'll generate 4,000 redraws/sec!" │
│ │
│ Result: Even 240fps can't keep up with 4,000/sec. │
│ │
│ ─────────────────────────────────────────────────────────── │
│ │
│ The problem isn't terminal SPEED. │
│ The problem is Claude Code's ARCHITECTURE. │
│ │
│ Faster at the wrong thing is still wrong. │
│ │
└─────────────────────────────────────────────────────────────────┘
```
***
## The Producer-Consumer Disaster
This is a **concurrency problem**, not a rendering problem.
```
┌─────────────────────────────────────────────────────────────────┐
│ THE PRODUCER-CONSUMER MISMATCH │
├─────────────────────────────────────────────────────────────────┤
│ │
│ PRODUCER (Claude LLM) CONSUMER (Renderer) │
│ ───────────────────── ──────────────────── │
│ │
│ Speed: 1000+ chunks/sec Speed: ~66 renders/sec │
│ Pattern: Continuous stream Pattern: 15ms per render │
│ State: Always generating State: Always behind │
│ │
│ ═══════════════════════════════════════════════════════════ │
│ │
│ Math doesn't lie: │
│ │
│ 1000 chunks × 15ms render = 15,000ms work per second │
│ Available time per second = 1,000ms │
│ │
│ Deficit: 14,000ms IMPOSSIBLE per second │
│ │
│ You need 15 seconds to render 1 second of output. │
│ │
└─────────────────────────────────────────────────────────────────┘
```
***
## The Time Axis Shift
At T=10 seconds, what does the user see?
```
┌─────────────────────────────────────────────────────────────────────────────┐
│ TIME AXIS SHIFT: YOU'RE LIVING IN THE PAST │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ Chunks arriving: 1000/sec │
│ Chunks processable: 1000ms ÷ 15ms = ~66/sec │
│ Backlog growth: 934 chunks/sec │
│ │
│ ───────────────────────────────────────────────────────────────────── │
│ │
│ Second 1: Arrived: 1000 Processed: 66 Backlog: 934 │
│ Second 2: Arrived: 1000 Processed: 66 Backlog: 1868 │
│ Second 5: Arrived: 1000 Processed: 66 Backlog: 4670 │
│ Second 10: Arrived: 1000 Processed: 66 Backlog: 9340 │
│ │
│ ───────────────────────────────────────────────────────────────────── │
│ │
│ REAL TIME ────────────────────────────────────────────────────────▶ │
│ 0s 1s 2s 3s 4s 5s 10s │
│ │ │ │ │ │ │ │ │
│ ▼ ▼ ▼ ▼ ▼ ▼ ▼ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ S0 S1000 S2000 S3000 S4000 S5000 ... S10000 │ ACTUAL │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
│ DISPLAY TIME ─────────────────────────────────────────────────▶ │
│ 0s 1s 2s 3s 4s 5s 10s │
│ │ │ │ │ │ │ │ │
│ ▼ ▼ ▼ ▼ ▼ ▼ ▼ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ S0 S66 S132 S198 S264 S330 ... S660 │ DISPLAYED │
│ └────┬────────────────────────────────────────────────────────┘ │
│ │ │
│ └───▶ At T=10s, user sees state from T=0.66s │
│ USER IS 9.34 SECONDS IN THE PAST │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
```
**60fps doesn't mean "current"**. When the renderer can only process 66 chunks per second but receives 1000 per second, every frame shows you the **past**. The "fps" measures how fast you're shown history, not how current you are.
***
## The Reflow Cascade
Each full buffer redraw triggers a **synchronous cascade** of layout operations:
```
┌─────────────────────────────────────────────────────────────────┐
│ REFLOW CASCADE (LAYOUT THRASHING) │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Each full buffer redraw triggers: │
│ │
│ 1. Clear scrollback buffer ──┐ │
│ │ │
│ 2. Recalculate all line positions │ │
│ │ MAIN THREAD │
│ 3. Recompute scroll position ├─▶ BLOCKED │
│ │ (~15ms) │
│ 4. Trigger scroll event │ │
│ │ Meanwhile: │
│ 5. Update scrollbar DOM │ 15 more chunks │
│ │ arrive │
│ 6. Repaint entire viewport ──┘ │
│ │
│ ─────────────────────────────────────────────────────────── │
│ │
│ At 4,000 chunks/sec, this cascade runs 4,000 times/sec. │
│ Each cascade takes ~0.2ms minimum. │
│ Total: 800ms+ of layout work per second (80% CPU blocked). │
│ │
│ This is why your IDE freezes. │
│ This is why your scrollbar jumps. │
│ This is why you see "slot machine" flickering. │
│ │
└─────────────────────────────────────────────────────────────────┘
```
***
## The Community Data
These aren't theoretical numbers. These are **measured** by frustrated users:
```
┌─────────────────────────────────────────────────────────────────┐
│ MEASURED DATA (GitHub Issue #9935) │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Scroll events per second: 4,000 - 6,700 │
│ Normal terminal usage: 10 - 100 │
│ Difference: 40x - 600x higher │
│ │
│ Burst pattern: 94.7% within 0-1ms │
│ ANSI overhead: ~189 KB/sec (escape codes) │
│ │
│ ─────────────────────────────────────────────────────────── │
│ │
│ Community reaction: │
│ │
│ Issue #769: 278 upvotes (one of most upvoted ever) │
│ User quote: "Like a broken slot machine" │
│ User quote: "Screen looks like it's having a seizure" │
│ User quote: "VSCode crashes after 10-20 minutes" │
│ │
│ ─────────────────────────────────────────────────────────── │
│ │
│ Anthropic response: │
│ │
│ "We're working on it" (December 2024) │
│ "Radio silence" (January 2025) │
│ "85% fixed!" (February 2025) │
│ │
│ Translation: "We deleted the scrollback." │
│ │
└─────────────────────────────────────────────────────────────────┘
```
***
## The Question They Can't Answer
```
┌─────────────────────────────────────────────────────────────────┐
│ THE ELEPHANT IN THE ROOM │
├─────────────────────────────────────────────────────────────────┤
│ │
│ AI companies claim: │
│ ───────────────── │
│ │
│ "AI will revolutionize software development" │
│ "AI will replace engineers" │
│ "AI will write better code than humans" │
│ │
│ Meanwhile, their own AI tools: │
│ ───────────────────────────── │
│ │
│ • Can't render text without flickering │
│ • Use React for a terminal UI │
│ • Need 60fps game engine for a loading spinner │
│ • Crash IDEs after 10 minutes of use │
│ • Take 15 seconds to display 1 second of output │
│ │
│ ─────────────────────────────────────────────────────────── │
│ │
│ If Claude can't even architect its own CLI tool correctly, │
│ why should we trust it to architect ours? │
│ │
│ "Physician, heal thyself." │
│ │
└─────────────────────────────────────────────────────────────────┘
```
***
## What a Real Solution Looks Like
```
┌─────────────────────────────────────────────────────────────────┐
│ MONOLEX: DIFFERENT ARCHITECTURE │
├─────────────────────────────────────────────────────────────────┤
│ │
│ The question they ask: │
│ ────────────────────── │
│ │
│ "How do we RENDER 4,000 updates/sec faster?" │
│ │
│ → Differential renderer │
│ → Faster diffing │
│ → Better ANSI generation │
│ │
│ Result: Still 15% broken. Faster at wrong thing. │
│ │
│ ─────────────────────────────────────────────────────────── │
│ │
│ The question we ask: │
│ ──────────────────── │
│ │
│ "Why RENDER 4,000 times when user sees 60 frames?" │
│ │
│ → Don't render old states │
│ → Parse all, render current │
│ → Frame boundary, not chunk boundary │
│ │
│ Result: 0% broken. Right architecture from start. │
│ │
└─────────────────────────────────────────────────────────────────┘
```
The history of failed renderer rewrites and the "85% lie"
When in doubt, delete it out — the family resemblance
***
## References
| Source | Description |
| --------------------------------------------------------------------------- | ---------------------------------------- |
| [GitHub Issue #769](https://github.com/anthropics/claude-code/issues/769) | Original flickering report (278 upvotes) |
| [GitHub Issue #9935](https://github.com/anthropics/claude-code/issues/9935) | Measured scroll events (4,000-6,700/sec) |
| [Claude Chill Extension](https://github.com/ArnoldoR/claude-chill) | Community workaround (not by Anthropic) |
| [Hacker News Discussion](https://news.ycombinator.com/item?id=42951388) | "We've lost the tech" commentary |
***
*Dear Anthropic. This letter is written in your son's hand only, never touched a single letter.*