Claude Code Tasks vs Todos: What Changed in 2026

Introduction

In January 2026, Anthropic shipped a significant upgrade to how Claude Code tracks work: the evolution from Todos to Tasks. If you've been using Claude Code for a while, you might have noticed that the TodoWrite and TodoRead tools have been replaced by a more powerful task management system. This isn't just a rename. It's a fundamental shift in how Claude Code handles complex, multi-step work.

The old Todo system served its purpose well for simple checklists within a single session. But as Claude Code matured and projects grew more ambitious, limitations became apparent. Tasks that needed to survive session restarts vanished. Dependencies between work items couldn't be expressed. Collaboration across multiple Claude instances was impossible.

The new Tasks system addresses all of these limitations. It introduces file-based persistence, dependency tracking, cross-session coordination, and broadcasting capabilities. For developers working on complex projects, this means Claude Code can finally manage work the way modern project management tools do.

The Old Way: Todos

The original Todo system in Claude Code was designed for simplicity. It provided basic checklist functionality through two tools: TodoWrite for creating and updating items, and TodoRead for viewing the current list.

> "Create a todo list for implementing the login feature"

Claude Code uses TodoWrite:
- [ ] Create login form component
- [ ] Add form validation
- [ ] Connect to authentication API
- [ ] Handle error states
- [ ] Add loading indicators

> "Mark the first item complete"

Claude Code uses TodoWrite:
- [x] Create login form component
- [ ] Add form validation
...

What Todos Did Well

For simple task tracking, Todos worked perfectly fine. They provided a quick way to organize thoughts, track progress through a feature, and maintain focus during a development session. The interface was intuitive: checkboxes that could be marked complete or incomplete.

The Limitations

Session-scoped storage. The biggest limitation was that Todos lived only in memory. Close your terminal, restart Claude Code, or even hit context limits, and your Todo list vanished. There was no persistence. Every session started fresh.

No dependencies. Todos were flat lists. You couldn't express that "Add form validation" needed to wait for "Create login form component" to complete. Complex projects have dependencies, and Todos couldn't model them.

No blockers. Similarly, you couldn't mark a task as blocked by an external factor. "Waiting for API documentation from backend team" wasn't something Todos could represent.

Single-session only. If you wanted to hand off work to a colleague, or continue in a different Claude session, Todos provided no mechanism. The state was trapped in one session's context.

The New Way: Tasks

The Tasks system represents a complete rethinking of work tracking in Claude Code. Instead of ephemeral in-memory checklists, Tasks are stored as files in your project, persist across sessions, support dependencies, and can coordinate work across multiple Claude instances.

> "Create tasks for implementing the login feature"

Claude Code creates tasks (stored in .claude/tasks/):

Task: implement-login-form
Status: pending
Priority: high
Description: Create the login form component with email and password fields

Task: add-form-validation
Status: pending
Depends on: implement-login-form
Description: Add client-side validation for email format and password strength

Task: connect-auth-api
Status: blocked
Blocked by: "Waiting for API documentation"
Depends on: add-form-validation
Description: Integrate with the authentication backend

File-Based Persistence

Tasks are stored as files in your project directory, typically under .claude/tasks/. This means they persist across sessions, can be committed to version control, and survive terminal restarts. When you start a new Claude Code session, your tasks are still there, exactly as you left them.

Dependencies and Blockers

Tasks can express relationships. A task can depend on other tasks, meaning it shouldn't start until its dependencies complete. Tasks can also be marked as blocked by external factors, with a description of what's blocking them. This models real-world project management where work items have prerequisites and obstacles.

Cross-Session Collaboration

Because tasks are files, multiple Claude sessions can read and update them. Start a task in one session, continue it in another. Have different Claude instances working on different parts of a project while sharing awareness of overall progress. The file system becomes the coordination layer.

Broadcasting Updates

The Tasks system includes mechanisms for broadcasting updates. When a task status changes, other components of the system can be notified. This enables workflows where completing one task automatically triggers related processes or alerts relevant parties.

Feature Comparison

The differences between Todos and Tasks are structural, not cosmetic. Here's a side-by-side comparison of capabilities.

Feature              | Todos (Old)           | Tasks (New)
---------------------|-----------------------|------------------------
Storage              | In-memory only        | File-based (.claude/tasks/)
Persistence          | Session-scoped        | Permanent until deleted
Session survival     | No                    | Yes
Dependencies         | Not supported         | Full dependency graph
Blockers             | Not supported         | Supported with reasons
Priority levels      | Not supported         | Supported
Cross-session work   | Not possible          | Native support
Version control      | Not applicable        | Git-friendly
Broadcasting         | Not available         | Update notifications
API tools            | TodoWrite, TodoRead   | Task-specific tools
Complexity handling  | Simple lists only     | Complex projects

The pattern is clear: Todos optimized for simplicity within a single session, while Tasks optimized for managing real projects that span multiple sessions and involve complex dependencies.

When You'd Still Want Simple Checklists

Not every use case needs the full power of Tasks. For quick, throwaway checklists during a single session, the overhead of file-based tasks might feel excessive. The good news is that Claude Code can still maintain simple mental checklists in conversation without formally creating task files. Use the right tool for the complexity at hand.

Why Anthropic Made This Change

The evolution from Todos to Tasks wasn't arbitrary. It reflects fundamental changes in how Claude Code is being used and where it's heading.

Opus 4.5 Can Run Autonomously Longer

With the release of Claude Opus 4.5, the model can handle significantly longer autonomous work sessions. When Claude can work independently for extended periods, it needs better tools for tracking what it's doing, what's completed, and what's next. Simple checklists don't scale to multi-hour autonomous sessions.

Projects Are More Complex

Early Claude Code usage often involved simple, single-file changes. As adoption grew, projects became more ambitious: full features spanning multiple files, cross-platform implementations, multi-day development efforts. These projects need project management, not just checklists.

Coordination Across Sessions

Developers increasingly work with Claude Code across multiple sessions, sometimes with multiple instances running simultaneously. A task might start in a morning session, continue in an afternoon session, and finish the next day. Without persistent state, every session started from scratch, requiring developers to re-explain context.

Inspired by Community Projects

The community had already started building persistence solutions. Projects like Beads demonstrated the value of file-based state tracking and cross-session memory. Anthropic observed these patterns and incorporated them into Claude Code natively, providing official support for workflows the community had already validated.

Migration: What You Need to Do

The good news is that migrating from Todos to Tasks requires almost no effort on your part. Anthropic designed the transition to be seamless.

It's Automatic

You don't need to run migration scripts or update configuration. Claude Code handles the transition automatically. New sessions use the Tasks system natively. There's no manual conversion process.

Old Commands Still Work

If you have muscle memory around asking Claude to "create a todo," it still understands. Natural language requests are interpreted by Claude, not parsed by strict command syntax. Asking for a "todo list" or a "task list" produces the same result: Claude uses the Tasks system to track the work.

Tasks Are Additive

The Tasks system adds capabilities without removing any. Everything you could do with Todos, you can still do with Tasks. The difference is that you now have additional options: persistence, dependencies, blockers, and cross-session coordination. Use them when you need them, ignore them when you don't.

> "Make a todo list for this feature"
// Works - Claude creates tasks

> "Add a task for writing tests"
// Works - Claude adds a task

> "What's left on my list?"
// Works - Claude shows pending tasks

> "Mark the validation task as done"
// Works - Claude updates task status

One Thing to Know

The main behavioral difference you might notice: tasks persist. If you create tasks in one session and start a new session later, those tasks will still be there. This is a feature, not a bug, but it might surprise you if you're used to every session starting clean. If you want a fresh start, explicitly ask Claude to clear or archive completed tasks.

Going Further

The Tasks system handles work coordination within Claude Code sessions. It tracks what needs to be done, what's in progress, and what's blocked. But coordination is only part of effective AI-assisted development.

Tasks Handle Coordination

Tasks excel at the "what" and "when" of work: what needs to be done, when it can start, what's blocking it. They provide the project management layer that complex development requires.

But Specialist Expertise Matters Too

Knowing what to do is different from knowing how to do it well. A task might say "implement login form," but the quality of that implementation depends on Claude having the right context: your coding standards, your component patterns, your accessibility requirements.

This is where persistent project context becomes essential. Tasks track work items, but files like CLAUDE.md and ECOSYSTEM.md provide the expertise context that shapes how that work is done.

The Complete Picture

Effective AI-assisted development combines:

• Work tracking (Tasks) - What needs to be done
• Project context (CLAUDE.md) - How work should be done
• Shared schemas (ECOSYSTEM.md) - What the data looks like
• Session memory (COORDINATION.md) - What happened before

Tasks are one piece of this puzzle. They're an important piece, especially for complex projects, but they work best alongside the other structural elements that give Claude Code the context it needs.