Claude Code Desktop Major Overhaul: From "Pair Programming" to "Command Center"

Writing: Seconds Claw

At the end of March, a security researcher discovered the full source code of Claude Code in an npm sourcemap file, 500k lines of TypeScript, all laid out clearly. Even more interesting, the code concealed a mysterious feature called KAIROS: a background agent that runs continuously, fixing bugs, running tasks, and sending notifications—without human oversight.

Two weeks later, on April 14, Anthropic officially released a complete overhaul of the Claude Code desktop version. KAIROS also made its debut under the name Routines.

From source code leak to product launch, only 14 days passed. Either Anthropic responded extremely quickly, or this was always part of the plan.

Regardless, the signal from this update is clear: Claude Code is no longer just a tool to help you write code; it aims to become your AI operations platform.

First, clarify: what is Claude Code’s position in the product lineup?

Open the latest version of the Claude Desktop app, and you’ll see three icons on the sidebar:

Chat: a traditional conversational assistant—you ask, it answers

Cowork: task executor for non-technical users, operating files within isolated virtual machines

Code: an agentic coding tool for developers, reading and writing code, running tests, submitting changes

All three share a desktop client, but their underlying architectures are completely different. This overhaul focused only on the Code mode, but it impacts the entire developer workflow.

Anthropic researcher Alex Albert said that with Cowork and Code working together, he hardly needs to open other apps for most tasks—“even the terminal is unnecessary.” That might have sounded exaggerated before the overhaul, but after, it feels like the truth.

Major change: from “one thing at a time” to “doing five things simultaneously”

The core pain point of the old version had been criticized by the community for months. Notable iOS developer Paul Hudson directly called the old version a “disaster.” Designer Brian Lovin, using a top-spec M3 Max 96GB, experienced frame drops even when switching tabs.

The new version is redesigned from the ground up, with three core improvements:

First layer: multiple conversations in parallel

A new sidebar management system allows opening five conversations simultaneously in one window. Each conversation gets its own project copy via Git Worktrees, stored in .claude/worktrees/, and they don’t interfere with each other. Boris Cherny’s tweet introducing this feature received 10,972 likes.

Second layer: drag-and-drop workspace

Terminal, preview, diff, editor, and chat panel all support drag-and-drop rearrangement. Three view modes: Verbose (for debugging), Normal, and Summary (for monitoring).

Third layer: integrated terminal and editor

First-ever built-in true terminal (to run scripts and builds directly), in-app file editor, a rebuilt Diff viewer for better performance, and Side Chat (Cmd+;), a side conversation feature that doesn’t interrupt the main task.

“The new app is built for an authentic agentic programming experience: multiple streams running in parallel, with you in the command seat.”

Routines: let AI keep working after you shut down your computer

If the desktop overhaul changed the “how to use” aspect, Routines changed the “when to use” aspect.

Core idea: one configuration (prompt + codebase + connector), set trigger conditions, and Claude Code automatically executes tasks in the Anthropic cloud. You don’t need to keep your computer on, and it can work even while you sleep.

Routines’ three trigger methods

Trigger Type | Typical Scenario | Scheduled Trigger | Automatically fix high-priority bugs and open PRs at 2 AM | API Trigger | Connect to Datadog/Sentry alerts, automatically identify root causes, and submit fixes | GitHub Event | Automatically review security and migrate changes across repositories

There’s a clever design in GitHub event triggers: one PR equals one session. Each PR gets a dedicated conversation, and subsequent code commits, comments, and CI logs all feed into the same session, maintaining full context.

“This isn’t incremental polishing; it’s a leap from ‘AI pair programming’ to ‘AI operations platform.’” Build Fast with AI

Currently, Routines is still in research preview: Pro users get 5 runs per day, Max users 15, and Team/Enterprise users 25.

Technology choice: why still Electron?

Boris Cherny gave three reasons on Hacker News:

1. Team familiarity—some engineers have experience with Electron

2. Code reuse—web and desktop share the same codebase

3. AI is good at writing web code, so Claude can better help develop and maintain its own desktop app

That third point is particularly interesting: Anthropic has formed a closed loop of “using AI to develop AI tools.” Boris also noted, “Engineering is about trade-offs, and that might change in the future.”

Compared to Codex and Copilot, what are the differences?

Three players competing for the same position: the default entry point for developers’ daily work

The competitive landscape is clear: Claude Code leads in agent capabilities and cloud automation, Codex has advantages in multi-platform coverage and cost-effectiveness, and Copilot relies on native GitHub integration to maintain its core position.

The story of KAIROS: from leak to release in 14 days

On March 31, security researcher Chaofan Shou discovered that the Claude Code package uploaded to npm contained a sourcemap file, exposing 500k lines of TypeScript code online.

The community found KAIROS in the code: “a feature that can run as a persistent background agent, capable of periodically fixing errors and running tasks without human input.”

Two weeks later, the Routines feature was released, with nearly identical functionality. After the leak, Anthropic chose to open-source the agent layer code openly. Instead of hiding it, they made it public, which gained goodwill from the developer community.

The next step in AI programming tools isn’t smarter but more autonomous

On the surface, it looks like UI changes—more panels, faster performance. But fundamentally, it’s a shift in interaction paradigm: from “one-on-one dialogue” to “one-to-many command,” from “it works only when you’re present” to “it works even when you’re not.”

The competition among AI programming tools is no longer about “whose model is smarter.” The real contest is: who can embed AI more autonomously into developers’ daily workflows, transforming humans from executors into supervisors.

Where this path leads is still too early to say. But the direction is already very clear.