On April 14, 2026, Anthropic shipped the redesigned Claude Code desktop app alongside the Routines cloud automation feature. The Routines story got the headlines — but the desktop redesign is the more consequential change for developers who run Claude Code all day.
The previous desktop app was designed around single-session, human-in-the-loop coding. You prompt, Claude works, you review. That model made sense in 2024. It doesn’t map to how serious Claude Code users work in 2026: multiple agents running simultaneously across different repos, some in the background, some requiring mid-task decisions, with you moving between them as they surface results.
Anthropic’s framing for the redesign: “The new app is built for how agentic coding actually feels now: many things in flight, and you in the orchestrator seat.”
The Sidebar: Session Management That Actually Scales#
The most visible change is the session sidebar, which replaces the previous list of recent conversations with a full session management interface. Every active and recent session is visible, filterable, and groupable.
Filtering options: status (running, waiting for input, complete, failed), project (repository), and environment. If you’re working across five repos simultaneously, you can narrow the sidebar to a single project and see only its sessions.
Grouping by project is the detail that makes this usable at scale. When you’re running three sessions per repo across four repos, a flat list becomes cognitive overhead. Grouping means you’re seeing your sessions organized the way you think about your work — by project, not by creation time.
Status filtering is underrated. In a multi-session setup, the sessions that need your attention right now are the ones waiting for input or that have hit an error. The rest can run unattended. Being able to filter to just “waiting” means you’re not scanning past six in-progress sessions to find the one that needs a decision.
Git Worktrees: The Safety Layer That Makes Parallel Work Real#
The most important technical detail in the redesign is buried in the documentation: each session in a git repository gets its own isolated copy of your project using git worktrees.
Changes in one session don’t affect other sessions until you commit. This is the implementation detail that makes parallel agentic work actually safe, not just technically possible.
Without worktree isolation, running two Claude Code sessions on the same repo means they’re both reading and writing to the same working directory. Session A refactors a module while Session B writes tests for that module’s current interface. The result is either a race condition or a confusing mess of half-finished changes. With worktrees, Session A and Session B operate on isolated copies of the codebase. You see both sets of changes, review them, and decide what to merge.
This is the same principle behind feature branches, applied at the session level. It’s not a new concept — git worktrees have been around for years. But wiring worktree isolation directly into the session model means you get the isolation automatically, without having to manually create branches and switch contexts before starting each agent.
Side Chats: The Sleeper Feature#
Side chats (⌘+; on Mac, Ctrl+; on Windows) let you open a branching conversation off the main thread. The side chat pulls context from the main session but doesn’t add anything back to it.
The use case: you’re running a complex agent task and you want to ask a question — “what’s the current state of X?” or “is this approach correct?” — without injecting that exchange into the main thread’s context. Every message in the main thread influences how the agent continues. A clarifying question, a half-formed thought, a quick sanity check — these don’t belong in the main session context. They create noise that can misdirect subsequent agent behavior.
Side chats let you think out loud without polluting the agent’s working context. That’s a subtle but significant workflow improvement for developers who use Claude Code for complex, multi-step tasks where context quality matters.
The Integrated Toolkit#
The redesign moves four tools into the app that previously required switching to a separate terminal or editor:
Integrated terminal. Run tests, builds, or CLI commands alongside your session. The agent proposes a fix; you run the test suite in the same window to verify. This is the workflow that felt clunky before — tab to terminal, run tests, tab back to Claude Code, paste results — now collapsed into a single view.
In-app file editor. Open files and make spot edits without leaving the session. For the inevitable “Claude got 95% right but I want to tweak this one line myself” moment, you don’t have to switch to VS Code or another editor.
Faster diff viewer. Rebuilt for performance on large changesets. If you’ve ever watched Claude Code scroll through a large diff in the old viewer, this is the fix. The rebuild prioritizes rendering speed, which matters when an agent has touched 40 files and you need to review the whole changeset quickly.
HTML and PDF preview. Open in-app. For agents generating reports, documentation, or frontend HTML, you can preview the output without exporting to a browser.
All four panes are drag-and-drop. Arrange terminal, preview, diff viewer, and chat in whatever grid matches how you work. The app doesn’t enforce a layout.
Three View Modes#
Verbose, Normal, and Summary — three ways to look at what Claude is doing.
Verbose shows every tool call, every intermediate step, every reasoning token the model emits. Useful for debugging why an agent went in a direction you didn’t expect, or for learning how Claude Code handles a class of task.
Normal shows the default level of detail — tool calls and key decisions, but not every intermediate step.
Summary collapses the session to high-level progress updates. If you have five sessions running and you want a quick status scan without reading detailed tool call logs, Summary mode lets you do that without switching to a different view.
The mode switch is per-session. A session where you’re actively debugging gets Verbose; a background session refactoring a module gets Summary.
The Bigger Picture#
The redesigned desktop app is making an argument: the Claude Code desktop is the environment for agentic development, not a side panel bolted onto your existing editor.
This positions Anthropic differently from Cursor and Copilot, which are IDE-embedded and therefore architecturally tied to the editor-centric workflow. Claude Code’s terminal-native and now desktop-native approach means the environment scales to multi-agent orchestration in a way that an IDE plugin cannot — you can’t run five parallel Cursor Composers across five repos in a single organized interface the way you can now with Claude Code’s session sidebar.
The worktree isolation, the side chats, the integrated toolkit, the view modes — none of these are features you’d design for a tool that assumes one developer, one task, one file at a time. They’re features you design for a tool that assumes the developer is an orchestrator managing multiple simultaneous workstreams.
That assumption is increasingly accurate.
Sources:
- Redesigning Claude Code on desktop for parallel agents — Anthropic
- Claude Code desktop docs — Anthropic
- Anthropic rebuilds Claude Code desktop app around parallel sessions — MacRumors
- Claude Code gets automated routines and a desktop makeover — SiliconANGLE
- We tested the redesigned Claude Code desktop app — VentureBeat
- Claude Code desktop redesign — The New Stack