[UX] Console output doesn't scale for modern multi-agent workflows - code diffs need condensation

Problem

Claude Code condenses most tool outputs with "(ctrl+o to expand)", but code modifications (Write/Edit) always show full diffs. This was acceptable for simple single-agent tasks, but breaks down completely in modern multi-agent parallel workflows.

Real-World Impact: Multi-Agent Workflows

When spawning multiple specialized agents in parallel (increasingly common pattern):

// Modern workflow: 5 agents working concurrently
Task("Backend Developer", "Build REST API...", "backend-dev")
Task("Frontend Developer", "Create React UI...", "coder")
Task("Database Architect", "Design schema...", "architect")
Task("Test Engineer", "Write tests...", "tester")
Task("DevOps Engineer", "Setup CI/CD...", "cicd-engineer")

Console output becomes:

• Agent 1: 300-line diff (backend code)
• Agent 2: 450-line diff (frontend code)
• Agent 3: 200-line diff (schema)
• Agent 4: 350-line diff (tests)
• Agent 5: 150-line diff (CI config)

= 1,450+ lines of diff output before seeing summary/results

Current vs Expected Behavior

❌ Current (unusable at scale):

Agent 1 Write(backend/api.js)
  [300 lines of diff...]
Agent 2 Write(frontend/App.jsx)
  [450 lines of diff...]
Agent 3 Write(database/schema.sql)
  [200 lines of diff...]
[Impossible to see what's actually happening]

✅ Expected (scalable):

Agent 1 Write(backend/api.js)
  ⎿  Created api.js with 300 lines (ctrl+o to expand)
Agent 2 Write(frontend/App.jsx)
  ⎿  Created App.jsx with 450 lines (ctrl+o to expand)
Agent 3 Write(database/schema.sql)
  ⎿  Created schema.sql with 200 lines (ctrl+o to expand)
Agent 4 completed: "API endpoints implemented with auth"
Agent 5 completed: "CI/CD pipeline configured"
[Clear view of progress and outcomes]

Why the Original Design No Longer Fits

1. Git is the safety net - We don't need diffs in console for trust; git diff handles review
2. Usage has scaled up - From "fix this bug" to "build this entire feature with 5 agents"
3. Parallel agents multiply the problem - Each agent's diffs compound in the same console
4. Cognitive overload - Can't track what's happening when buried in 1000+ lines of code

Proposed Solutions

Quick Win (Immediate Value):

• Condense code diffs like all other outputs
• Show: Updated file.java with +349/-363 lines (ctrl+o to expand)
• Same pattern as Bash, Read, Grep - zero learning curve

Long-term (Architectural):

• Sub-agent outputs in separate tabs/panels
• Collapsible agent sections in main console
• Dedicated "diff view" mode
• Real-time filtering (show only summaries, expand on demand)

Why Quick Win Matters Now

Even if a full UI overhaul is planned (tabs, panels, etc.), condensing diffs provides immediate relief:

• ✅ One-line change in CLI output formatter
• ✅ Consistent with existing UX patterns
• ✅ Doesn't preclude future architectural improvements
• ✅ Helps TODAY while better solutions are designed

Evidence of Need

All other tools already condense because developers recognized this need:

• Bash(mvn test) → condensed (could be 1000+ lines of Maven output)
• Read(file.java) → condensed (could be entire source file)
• Grep(pattern) → condensed (could be hundreds of matches)

Only code diffs don't condense - creating UX inconsistency at the worst possible place (most verbose output).

Environment

• OS: Windows/Linux/Mac (affects all platforms)
• Use case: Multi-agent parallel workflows (becoming standard practice)
• Scale: 3-10 agents × 100-500 lines/diff = 300-5000 lines of console pollution

Analogy

This is like if git log always showed full commit diffs instead of summaries. We have git log -p for when we want diffs - same principle should apply here.

---

Related: Multi-agent workflows are becoming the standard pattern for complex development tasks. The CLI UX needs to evolve to support this reality.