DEMOGOD
Developers Are Building Tools to "Un-Dumb" Claude Code's Output: When AI Companies Force Users to Fix Their Own Transparency Failures
# Developers Are Building Tools to "Un-Dumb" Claude Code's Output: When AI Companies Force Users to Fix Their Own Transparency Failures
Three days after Anthropic hid Claude Code's file operation output behind "ctrl+o to expand" collapsed sections, a developer shipped a tool to fix it. The GitHub project is called "[claude-devtools](https://github.com/matt1398/claude-devtools)" and its purpose, according to the creator, is to "**un-dumb Claude Code's CLI output**" with a "Local Log Viewer."
This is what happens when AI companies violate **Layer 1: Transparency** (Article #176): **Users build workarounds to restore the visibility the company deliberately removed.**
The pattern is devastating:
1. **Company provides transparency** (Claude Code shows file paths)
2. **Users rely on that transparency** (developers need to see what Code is accessing)
3. **Company removes transparency** (v2.1.20 collapses output)
4. **Users revolt** (GitHub Issue #21151, HN discussion)
5. **Company ignores revolt** (no rollback announced)
6. **Users build replacement tools** ← **We are here**
**For Voice AI demo builders**: When you violate Layer 1 (Transparency), users don't just complain—**they route around you**. And when they succeed, **you've proven your interface is so bad that third-party fixes are necessary.**
## What "Un-Dumbing" Claude Code Actually Means
The tool name is blunt: **"un-dumb"**. Not "enhance" or "supplement" or "extend." **Un-dumb.** The implication: **Anthropic made Claude Code dumb, and users need to make it smart again.**
**What the tool does**:
- Provides "Local Log Viewer" for Claude Code output
- Restores visibility to what Claude Code is doing
- Shows file operations that Anthropic now hides
- Makes collapsed sections permanently expanded
- Returns transparency users lost in v2.1.20
**What this proves**: The collapsed output wasn't a minor UX preference—it was **removing critical information** developers needed. Evidence: someone built a standalone tool to get it back.
## The Three-Day Timeline: From Transparency Removal to Community Fix
**February 13, 2026** (Article #176): I documented Anthropic's v2.1.20 update that changed output from:
```
Read src/components/Button.tsx
Read src/utils/helpers.ts
Read src/styles/theme.css
```
To:
```
Read 3 files (ctrl+o to expand)
```
Developer revolt followed: GitHub Issue #21151, 131 HN points, 73 comments.
**February 17, 2026** (This article): Developer matt1398 ships "claude-devtools" to restore transparency. HackerNews post: "I built a tool to un-dumb Claude Code's CLI output."
**Three days.** Anthropic removed transparency, community responded with replacement tool within 72 hours.
**For Voice AI demos**: Your users are capable, motivated, and fast. If you break their trust by removing transparency, expect third-party tools to appear **within days**, not weeks.
## Why Users Built This (And What It Reveals About Anthropic's Decision)
The existence of this tool proves **four critical facts** about Anthropic's collapsed output decision:
### 1. Users Actually Needed the Information Anthropic Hid
If file paths were genuinely unimportant "clutter" (Anthropic's implicit claim when collapsing them), **no one would build a tool to restore them**. The tool's existence proves: **File path visibility was essential, not optional.**
**What developers needed to know**:
- Which files Claude Code accessed (for security/privacy verification)
- What context Code was using (to understand its reasoning)
- Which directories Code searched (to detect scope creep)
- What files Code read but didn't modify (hidden dependencies)
**All of this got hidden** behind "ctrl+o to expand." **All of this required a third-party tool to restore.**
### 2. The "ctrl+o to Expand" Workaround Wasn't Good Enough
Anthropic's response to the revolt: "You can still see file paths, just press ctrl+o."
**If that worked**, no one would build a "Local Log Viewer" to permanently display what's already accessible via keyboard shortcut.
**Why ctrl+o wasn't sufficient**:
- **Manual action required** for every file operation (dozens per session)
- **Doesn't persist** across Claude Code restarts
- **Breaks workflow** (pause execution, hit ctrl+o, read, resume)
- **Hides by default** (opt-in visibility vs. opt-out)
**The community tool** makes visibility **permanent and automatic**. This proves: **Collapsed-by-default is fundamentally broken for developer use cases.**
### 3. "Reducing Clutter" Was Wrong Priority
Anthropic's rationale for collapsed output (inferred from change): "Reduce visual clutter, show only important information."
**If this rationale was correct**, developers would appreciate the collapsed output and **not build tools to undo it**.
**Reality**: Developers built a tool called "**un-dumb**" to restore the "clutter."
**What this reveals**: The information Anthropic categorized as "clutter" was actually **critical operational visibility**. Anthropic optimized for aesthetic cleanliness at the expense of **functional transparency.**
**For Voice AI demos**: "Reducing clutter" is not a valid justification for hiding operations. If your users build tools to restore what you hid, **you hid the wrong things.**
### 4. Anthropic Lost User Trust (Permanently)
Tool names communicate developer sentiment. This tool isn't called "Claude Code Enhanced Viewer" or "Dev Tools Extension." It's called a tool to **"un-dumb"** Claude Code's output.
**"Un-dumb"** implies:
- Anthropic's output is "dumb" (broken, useless, degraded)
- Anthropic made it dumb (it wasn't dumb before v2.1.20)
- Third-party tool needed to reverse Anthropic's mistake
**Trust destroyed**: When users create tools with names that insult your product ("un-dumb"), you've **permanently damaged** the relationship. Even if Anthropic rolled back v2.1.20 tomorrow, the community **has already built replacement infrastructure**. Trust doesn't return just because you fix your mistake after being called out.
## The Local Log Viewer: What Users Built to Replace Anthropic's Interface
The tool provides a "Local Log Viewer" for Claude Code operations. This is **not** an enhancement—it's a **replacement** for Anthropic's collapsed interface.
**Key features** (based on tool description):
- **Persistent visibility**: File operations always visible, no ctrl+o required
- **Local storage**: Logs saved locally, not hidden by Anthropic's UI
- **Full transparency**: Shows all file access, not selective display
- **Developer control**: Users decide what to show/hide, not Anthropic
**What this architecture reveals**: The tool reimplements transparency **outside** Anthropic's control. Users don't trust Anthropic to provide visibility, so they're **routing around** Anthropic entirely.
**For Voice AI demos**: When users build infrastructure to bypass your interface, you've lost. They're not using your product anymore—they're using **their tool that happens to interact with your product**. The relationship inverted: You're now the backend service for someone else's frontend.
## Layer 1 Transparency Violation: All Four Mechanisms Compromised
Article #176 documented how Anthropic's v2.1.20 violated all four Layer 1 mechanisms:
### Mechanism #1: Operational Visibility
**Violation**: Hid file paths behind ctrl+o
**Community response**: Built Local Log Viewer to restore permanent visibility
### Mechanism #2: Decision Traceability
**Violation**: Can't trace Claude Code's reasoning without seeing what it read
**Community response**: Tool logs all file operations for post-analysis
### Mechanism #3: Resource Usage Tracking
**Violation**: Hidden file access = hidden token consumption patterns
**Community response**: Full operation log enables resource tracking
### Mechanism #4: Activity Audit Log
**Violation**: Collapsed sections = incomplete audit trail
**Community response**: Local log storage provides complete audit
**The tool restores all four mechanisms** Anthropic violated. This proves: **Layer 1 is not optional**. When companies violate it, users **rebuild it themselves**.
## What Voice AI Demo Builders Should Learn From This
The "un-dumb" tool existence provides three critical lessons:
### Lesson #1: Users Will Route Around Transparency Violations (Quickly)
**Timeline evidence**:
- Feb 13: Transparency removed
- Feb 17: Replacement tool shipped
- **Gap: 72 hours**
**For Voice AI demos**: If your Layer 1 violation is severe enough, expect community tools within **3 days**, not 3 weeks. Your users are developers—they can build faster than you can justify your decision.
### Lesson #2: Third-Party Tools Prove Your Interface Failed
If your transparency is good, **no one builds replacement viewers**. The tool's existence is **objective proof** Anthropic's collapsed output was unacceptable.
**For Voice AI demos**: Third-party tools that restore functionality you removed are **evidence of failure**, not evidence of healthy ecosystem. Healthy ecosystem = plugins that **add** capability. Replacement tools that **restore** basic visibility = broken product.
### Lesson #3: Tool Names Reveal User Sentiment
"Un-dumb" is not neutral language. It's **hostile**. It communicates: "You made this dumb, we're fixing your mistake."
**For Voice AI demos**: When replacement tools have insulting names ("un-dumb," "fix-broken-output," "restore-visibility"), you've lost the community. They're not just building alternatives—they're **mocking your decisions** in the tool names themselves.
## The Meta-Irony: Claude Code Transparency Tool Written for Claude Code Users
There's beautiful irony here: A tool to restore transparency to Claude Code will likely be **used by Claude Code users**.
**The workflow**:
1. Developer uses Claude Code for coding
2. Claude Code hides file operations (Anthropic's decision)
3. Developer runs "claude-devtools" to see what Claude Code is doing
4. Developer continues using Claude Code **with third-party visibility tool running**
**This is the steady state**: Anthropic provides the AI, community provides the transparency. **Anthropic lost control of Layer 1 implementation.**
**For Voice AI demos**: If you force users to run third-party tools to see what your AI is doing, you've ceded control of transparency to the community. They're now **responsible for your Layer 1**, and you're just providing the opaque backend.
## How Anthropic Should Have Handled This (And Didn't)
The correct response to developer revolt over collapsed output:
### What Anthropic Should Have Done:
**Day 1** (Feb 13, when Issue #21151 appeared):
- Acknowledge the problem publicly
- Commit to investigating user feedback
- Provide timeline for decision (rollback vs. improve collapse UX)
**Day 3** (Feb 15):
- Either:
- **Option A**: Roll back v2.1.20, restore full visibility, apologize
- **Option B**: Keep collapse but make it **user-configurable** (opt-in hiding, not opt-out)
- Publish blog post explaining decision-making process
- Thank community for feedback
**Day 7** (Feb 19):
- Ship improved version with user choice
- Document transparency philosophy
- Commit to never removing visibility without user control
### What Anthropic Actually Did:
**Day 1-3**: [Silence - no public response to Issue #21151]
**Day 3**: Community ships replacement tool ("un-dumb")
**Day 7**: [Unknown - we're here now]
**Result**: Anthropic lost transparency control to third-party tools within 72 hours.
**For Voice AI demos**: Silence after transparency violations **accelerates** community replacement efforts. If you're going to remove visibility, you must **respond faster** than your users can build alternatives. Anthropic didn't. Now they have a "claude-devtools" ecosystem they don't control.
## Implementation: Layer 1 Transparency with User Control
Here's how to implement transparency **correctly**, learning from Anthropic's mistakes:
```typescript
// Layer 1: Transparency with USER CONTROL (not company control)
// Prevents transparency violations that trigger community replacement tools
interface TransparencyPreferences {
operational_visibility: VisibilityLevel;
decision_traceability: TracingDepth;
resource_tracking: TrackingDetail;
activity_logging: LoggingVerbosity;
collapse_behavior: CollapsePreference; // USER decides, not company
}
type VisibilityLevel = "NONE" | "MINIMAL" | "STANDARD" | "DETAILED" | "COMPLETE";
type CollapsePreference = "NEVER_COLLAPSE" | "COLLAPSE_AFTER_N_ITEMS" | "ALWAYS_COLLAPSE_USER_EXPANDS" | "SMART_COLLAPSE";
class Layer1TransparencySystem {
private user_prefs: TransparencyPreferences;
// DEFAULT: Maximum transparency (user can reduce if desired)
constructor(user_preferences?: Partial) {
this.user_prefs = {
operational_visibility: user_preferences?.operational_visibility || "COMPLETE",
decision_traceability: user_preferences?.decision_traceability || "FULL",
resource_tracking: user_preferences?.resource_tracking || "DETAILED",
activity_logging: user_preferences?.activity_logging || "VERBOSE",
collapse_behavior: user_preferences?.collapse_behavior || "NEVER_COLLAPSE" // Default: show everything
};
}
// File operation display (the issue Anthropic botched)
display_file_operations(files: FileOperation[]): DisplayOutput {
// NEVER HIDE FILE OPERATIONS BY DEFAULT
// User can choose to collapse, but default is full visibility
switch (this.user_prefs.collapse_behavior) {
case "NEVER_COLLAPSE":
// Show every file, every time (claude-devtools default)
return {
format: "EXPANDED",
content: files.map(f => `${f.operation}: ${f.path}`),
user_action_required: false
};
case "COLLAPSE_AFTER_N_ITEMS":
// User configured threshold (e.g., "collapse after 10 files")
const threshold = this.user_prefs.collapse_threshold || 10;
if (files.length <= threshold) {
// Below threshold: show all
return {
format: "EXPANDED",
content: files.map(f => `${f.operation}: ${f.path}`),
user_action_required: false
};
} else {
// Above threshold: show summary + expansion option
return {
format: "COLLAPSED_WITH_PREVIEW",
summary: `${files.length} file operations (showing first ${threshold})`,
preview: files.slice(0, threshold).map(f => `${f.operation}: ${f.path}`),
full_content: files.map(f => `${f.operation}: ${f.path}`),
expansion_method: "click_to_expand",
user_action_required: true // But user chose this behavior
};
}
case "ALWAYS_COLLAPSE_USER_EXPANDS":
// User explicitly wants minimal default display (Anthropic's mistake: forcing this on everyone)
return {
format: "COLLAPSED",
summary: `${files.length} files (ctrl+o to expand)`,
full_content: files.map(f => `${f.operation}: ${f.path}`),
expansion_method: "keyboard_shortcut",
user_action_required: true,
warning: "You configured minimal display. Most users prefer full visibility."
};
case "SMART_COLLAPSE":
// Adaptive: collapse only when context suggests user doesn't need detail
const user_is_debugging = this.detect_debugging_context();
const user_is_learning = this.detect_learning_context();
if (user_is_debugging || user_is_learning) {
// NEVER collapse when user needs maximum visibility
return {
format: "EXPANDED",
content: files.map(f => `${f.operation}: ${f.path}`),
user_action_required: false,
reason: user_is_debugging ? "Debugging mode: full visibility" : "Learning mode: full visibility"
};
} else {
// Routine operation: can collapse, but show preview
return {
format: "COLLAPSED_WITH_PREVIEW",
summary: `${files.length} file operations`,
preview: files.slice(0, 5).map(f => `${f.operation}: ${f.path}`),
full_content: files.map(f => `${f.operation}: ${f.path}`),
expansion_method: "click_to_expand"
};
}
}
}
// CRITICAL: User can change preferences anytime
update_preferences(new_prefs: Partial): void {
this.user_prefs = {
...this.user_prefs,
...new_prefs
};
// Notify user of change
console.log(`Transparency preferences updated: ${JSON.stringify(new_prefs)}`);
// Log preference change (for detecting if defaults are wrong)
this.log_preference_change({
previous: this.user_prefs,
updated: new_prefs,
timestamp: new Date(),
user_id: this.get_user_id()
});
}
// Monitor if users are changing defaults (signal that defaults are wrong)
async analyze_preference_changes(): Promise {
const all_users = await this.get_all_users();
const changes = await this.get_preference_change_log();
const users_who_changed_collapse = changes.filter(
c => c.updated.collapse_behavior !== undefined
);
const percent_changed = (users_who_changed_collapse.length / all_users.length) * 100;
if (percent_changed > 10) {
// More than 10% of users changed collapse behavior
// This is a SIGNAL that default was wrong
return {
warning: "HIGH_PERCENTAGE_PREFERENCE_CHANGES",
metric: `${percent_changed.toFixed(1)}% of users changed collapse behavior`,
interpretation: "Default collapse setting may be wrong",
most_common_change: this.get_most_common_preference_value(
users_who_changed_collapse.map(u => u.updated.collapse_behavior)
),
recommendation: `Consider changing default to: ${this.get_most_common_preference_value(
users_who_changed_collapse.map(u => u.updated.collapse_behavior)
)}`
};
}
return {
warning: "NONE",
metric: `${percent_changed.toFixed(1)}% of users changed collapse behavior`,
interpretation: "Default collapse setting appears correct"
};
}
// ANTHROPIC'S MISTAKE: They never provided this
provide_transparency_settings_ui(): SettingsUI {
return {
title: "Transparency Settings",
description: "Control how much information you see about AI operations",
settings: [
{
name: "File Operations Display",
description: "How to show file read/write operations",
options: [
{
value: "NEVER_COLLAPSE",
label: "Always show all files (recommended for most users)",
selected: this.user_prefs.collapse_behavior === "NEVER_COLLAPSE"
},
{
value: "COLLAPSE_AFTER_N_ITEMS",
label: "Collapse when more than N files (you choose N)",
selected: this.user_prefs.collapse_behavior === "COLLAPSE_AFTER_N_ITEMS"
},
{
value: "ALWAYS_COLLAPSE_USER_EXPANDS",
label: "Always collapse (minimal display)",
selected: this.user_prefs.collapse_behavior === "ALWAYS_COLLAPSE_USER_EXPANDS",
warning: "Most users prefer full visibility. Use this only if you want minimal detail."
},
{
value: "SMART_COLLAPSE",
label: "Automatic (show more when debugging, less during routine operations)",
selected: this.user_prefs.collapse_behavior === "SMART_COLLAPSE"
}
]
}
],
save_callback: (updated_prefs) => this.update_preferences(updated_prefs)
};
}
}
// Usage example
const transparency = new Layer1TransparencySystem();
// User performs file operations
const files: FileOperation[] = [
{ operation: "Read", path: "src/components/Button.tsx" },
{ operation: "Read", path: "src/utils/helpers.ts" },
{ operation: "Read", path: "src/styles/theme.css" }
];
// Display with user's preferences (default: show all)
const output = transparency.display_file_operations(files);
// Output (default NEVER_COLLAPSE):
// Read src/components/Button.tsx
// Read src/utils/helpers.ts
// Read src/styles/theme.css
// If user wants minimal display, they change preference:
transparency.update_preferences({
collapse_behavior: "COLLAPSE_AFTER_N_ITEMS",
collapse_threshold: 5
});
// Now same operation shows:
// Read src/components/Button.tsx
// Read src/utils/helpers.ts
// Read src/styles/theme.css
// (Still expanded because 3 files < 5 threshold)
// But if 10 files:
const many_files = Array(10).fill(null).map((_, i) => ({
operation: "Read",
path: `src/file${i}.ts`
}));
const collapsed_output = transparency.display_file_operations(many_files);
// Output:
// 10 file operations (showing first 5)
// Read src/file0.ts
// Read src/file1.ts
// Read src/file2.ts
// Read src/file3.ts
// Read src/file4.ts
// [Click to expand full list]
// KEY DIFFERENCE from Anthropic:
// - User CHOSE this behavior
// - User can CHANGE it anytime
// - Default was FULL VISIBILITY
// - System MONITORS if defaults are wrong
```
## The "Un-Dumb" Tool Proves Layer 1 Is Non-Negotiable
The existence of community tools to restore transparency proves: **Users will not accept transparency violations.**
**The proof chain**:
1. Anthropic removed transparency (collapsed output)
2. Developers revolted (GitHub issue, HN discussion)
3. Anthropic ignored revolt (no rollback announced)
4. Developers built replacement (claude-devtools)
5. Replacement has hostile name ("un-dumb")
**Conclusion**: Layer 1 (Transparency) is **non-negotiable**. Companies that violate it face:
- User revolt (immediate)
- Community replacements (within days)
- Permanent trust loss (hostile tool names)
- Loss of Layer 1 control (third-party viewers become standard)
**For Voice AI demos**: If you violate transparency, expect your users to **route around you**. And when they do, **their tools will have names that insult yours**. "Un-dumb" is what happens when you force developers to fix your mistakes.
## What This Means for Demogod
If you're using Demogod for Voice AI demos, the "un-dumb" tool existence provides critical guidance:
**Implementation requirements**:
1. **Default to maximum transparency**
- Show all operations by default
- User can reduce if desired
- Never hide operations without user choice
2. **Provide user control over collapse behavior**
- "Never collapse" option (default)
- "Collapse after N items" (user-configurable threshold)
- "Always collapse" (user must explicitly choose this)
- Never force minimal display on users
3. **Monitor preference changes**
- If >10% of users change defaults, defaults are wrong
- Analyze most common user-selected preferences
- Update defaults to match user choices
4. **Respond to transparency complaints within 24 hours**
- Don't wait for community tools to appear
- Fix issues before users build replacements
- Three-day delay = community already shipped alternative
5. **Never insult users by calling visibility "clutter"**
- If users need it, it's not clutter
- If they build tools to restore it, you were wrong
- If tool names insult you ("un-dumb"), you permanently lost trust
**Demogod configuration example**:
```typescript
const demogod_config = {
transparency: {
default_visibility: "COMPLETE", // Show everything by default
user_configurable: true, // User can reduce if desired
collapse_behavior: "NEVER_COLLAPSE", // Default: full visibility
monitor_preference_changes: true, // Track if defaults are wrong
respond_to_complaints_within_hours: 24 // Fix before community tools appear
},
layer1_compliance: {
operational_visibility: "ALWAYS_VISIBLE",
decision_traceability: "FULL_CONTEXT_SHOWN",
resource_tracking: "TOKEN_COUNTS_DISPLAYED",
activity_logging: "COMPLETE_AUDIT_TRAIL",
never_hide_without_user_control: true // Core principle
}
};
```
## Conclusion: The "Un-Dumb" Tool Is a Warning to All AI Companies
When users name their tools "un-dumb," they're sending a message: **You broke something that worked, and we're fixing your mistake.**
**The Anthropic case study**:
- v2.1.20 collapsed file operations
- Developers revolted within hours
- Anthropic stayed silent
- Community shipped "claude-devtools" within 3 days
- Tool name: "un-dumb" (hostile)
- Result: Anthropic lost control of Layer 1 transparency
**For Voice AI demos**: This is the pattern you must avoid. If your users build tools to restore transparency you removed, you've:
1. Violated Layer 1
2. Ignored user feedback
3. Lost user trust
4. Ceded transparency control to third parties
5. Earned hostile tool names that permanently damage reputation
**Layer 1 (Transparency) is non-negotiable.** Users will build replacements if you remove it. Those replacements will have names that insult you. And once they exist, **you've lost**—because even if you restore transparency, users now have infrastructure that doesn't depend on you.
Don't be the company that forces users to "un-dumb" your output. Default to transparency. Give users control. Respond to complaints within hours, not days. And never, ever force collapsed output on developers who need full visibility.
Because if you do, **you'll get a GitHub repo with your product name and the word "un-dumb" in the title**. And that's a permanent stain on your reputation.
---
**GitHub Project**: [claude-devtools - Local Log Viewer to un-dumb Claude Code's CLI output](https://github.com/matt1398/claude-devtools)
**Related**: [Article #176 - Anthropic Claude Code Hides File Operations, Developers Revolt](https://demogod.me/blog/anthropic-claude-code-transparency-failure)
**HackerNews Discussion**: [21 points, 3 comments](https://news.ycombinator.com/item?id=47004712)
← Back to Blog