Cursor 1.2 Released: Built-in Task Decomposition Enhances AI Programming Experience
Cursor 1.2 adds built-in task decomposition, making AI execution visible and controllable
Cursor 1.2 rolls out automatic task decomposition (To-Do List) to early access users. When handling complex development requests, AI automatically breaks tasks into clear step-by-step lists and completes them sequentially. This replaces previous approaches requiring Task Manager MCP plugins or complex prompts. The decomposition logic follows human development conventions, works best with project Rules files, and marks AI programming tools' shift from black-box execution to white-box collaboration.
Overview
Cursor recently pushed the 1.2 version update to early access subscribers. Although the official changelog hasn't been formally published yet (reportedly to be released when the update rolls out to all users), users have already discovered an extremely practical new feature — automatic task decomposition (To-Do List). This feature enables AI to automatically break down complex requirements into a clear list of steps and complete them sequentially, greatly improving the controllability and transparency of the development process.
The Evolution of Task Management in AI Programming Assistants
AI programming assistants have evolved from initial code completion (like GitHub Copilot's line-level suggestions), to conversational programming (like ChatGPT-assisted coding), and now to Agent mode (AI autonomously executing multi-step development tasks). Each leap has been accompanied by higher demands for task management capabilities. When AI transitions from "answering questions" to "autonomous execution," developers' greatest anxiety lies in losing control over the process — What is the AI doing? What step is it on? What's next? Cursor 1.2's automatic task decomposition feature is a direct response to this core pain point.
Cursor 1.2 Core New Feature: Automatic Task Decomposition
How It Works
In Cursor 1.2, when a user submits a development request to the AI, it automatically breaks the requirement into multiple subtasks, displayed as a To-Do List. For example, when a user asks to create an interface, the AI automatically decomposes it into:
- Create API file
- Create page
- Route configuration
- API documentation
As each subtask is completed, the corresponding item gets crossed out as done. This visual progress display allows developers to clearly understand the AI's execution progress and reasoning logic.
Complex Scenario Validation
In more complex backend service development scenarios, this feature performs equally well. When a user presents a relatively complex feature requirement, the AI automatically decomposes tasks following standard development workflows:
- Design SQL statements
- Generate Entity
- Generate DTO
- Handle Map and XML files
- Write Manager layer
- Write Service layer
- Write Controller layer
You might not have noticed, but this bottom-up implementation order is completely consistent with human developers' habits, indicating that the AI's task decomposition logic is both reasonable and professional.
This involves the layered architecture pattern common in enterprise-level Java backend development: Entity is the database table mapping object, DTO (Data Transfer Object) is used for inter-layer communication, the Manager layer encapsulates common business logic, the Service layer handles core business rules, and the Controller layer is responsible for receiving HTTP requests and returning responses. The bottom-up development order ensures that each layer's dependencies are ready when being written — this is a practice widely adopted by experienced developers. The AI's ability to automatically identify and follow this order demonstrates genuine engineering understanding rather than simple text splitting.
More importantly, this feature works properly even in normal mode (non-Think mode).
Comparison with Previous Approaches
The Old Way
Before version 1.2, developers who wanted to achieve similar task management effects typically needed external tools:
- Task Manager MCP Plugin: Using third-party task management plugins to assist AI with task decomposition
- Carefully crafted prompts: Explicitly requiring AI to execute step-by-step and display execution plans in prompts
- Rules file configuration: Guiding AI behavior patterns through project rule files
MCP (Model Context Protocol) is an open protocol released by Anthropic in late 2024, designed to provide AI models with standardized interfaces for interacting with external tools and data sources. In the Cursor ecosystem, MCP plugins allow AI to call external services to enhance its capabilities. The Task Manager MCP plugin is one such example — it helps AI plan and track multi-step task execution through external task management services. However, external plugin solutions suffer from complex configuration, response latency, and insufficient editor integration, which is a key reason Cursor chose to build task decomposition capabilities natively.
Advantages of the Built-in Approach
Cursor 1.2 has built task decomposition capabilities directly into the product, similar to the capability upgrades that came with the earlier Agentic mode. This means:
- No extra configuration needed: No more installing Task Manager plugins or writing complex prompts
- Higher accuracy: Natively integrated decomposition logic is more precise than external tools
- Smoother experience: Task progress is visible in real-time, giving developers stronger control over the AI's execution process
Better Results When Combined with Project Rules
From the demo, we can see that the user configured a Rules file in the project, requiring the AI to read the project's service overview document (an MD file) before execution to understand the existing service landscape and avoid duplicate creation. This combination of Rules + automatic task decomposition enables the AI to plan and execute tasks more reasonably based on a comprehensive understanding of the project.
Rules files are essentially a project-level AI behavior configuration mechanism provided by Cursor, where developers can define code style preferences, architectural constraints, naming conventions, and other rules. When Rules files are combined with automatic task decomposition, the AI knows not only "what to do" but also "how to do it" and "what not to do," forming a complete AI development behavior constraint system.
How to Get the Update
Currently, Cursor 1.2 is in a staged rollout phase, only pushed to subscribers who have enabled Early Update Access. Staged rollout (also known as canary release) is a progressive release strategy in software engineering — the new version is first pushed to a small subset of users, and after observing stability and user feedback, it's gradually expanded. Cursor's Early Update Access mechanism is essentially an implementation of staged rollout — subscribers willing to accept early version risks serve as "pioneers," helping the team discover and fix potential issues before a full rollout. This strategy is also widely adopted in products like VS Code and Chrome.
The official team has opened a dedicated discussion thread on the forum for users to report issues encountered during use. When the full rollout occurs, the complete changelog will be published simultaneously.
Summary
Cursor 1.2's automatic task decomposition feature addresses a long-standing pain point in AI programming — developers' difficulty in understanding the AI's execution plan and progress. By visualizing tasks as a To-Do List, it not only improves transparency but also enables developers to detect deviations and make corrections during AI execution. This seemingly simple feature improvement actually significantly enhances the efficiency and experience of human-AI collaboration.
From a broader perspective, this feature marks AI programming tools' transition from "black-box execution" to "white-box collaboration." When the AI's thinking process and execution plan are fully transparent to developers, humans can truly play the roles of "architect" and "reviewer," while AI focuses on efficient output at the execution level. This division of labor may well become the mainstream paradigm for human-AI collaborative programming in the future.
Key Takeaways
- Cursor 1.2 adds automatic task decomposition — AI automatically breaks complex requirements into a To-Do List and executes them step by step
- Task decomposition logic follows human development habits, implementing from bottom to top, and works even in normal mode
- This feature replaces task management approaches that previously required Task Manager MCP plugins or complex prompts
- Version 1.2 is currently in staged rollout, only available to subscribers with Early Update Access enabled
- When combined with project Rules files, AI can plan tasks more effectively based on a comprehensive understanding of the project
Related articles
Product ReviewsQoder vs Cursor Real-World Comparison: Which $20/Month AI IDE Is Better?
Hands-on comparison of Qoder vs Cursor AI IDEs: Agent autonomy, human interaction count, and architecture decisions. Qoder needed only 2 interactions vs Cursor's 8.
Product ReviewsCursor Cloud Agent Demo: Eliminating Bottlenecks Across the Entire Software Development Lifecycle
Deep analysis of Cursor's Cloud Agent demo showing how cloud VMs, automated test artifacts, and a full-chain control plane systematically eliminate human bottlenecks across the software development lifecycle.
Product ReviewsCursor 3.0 Deep Dive: Multi-Agent Parallelism, Design Mode, and Best-of-N Model Comparison
Cursor 3.0 evolves from an AI coding assistant into an Agent fleet command center. Explore multi-agent parallelism, Design Mode, and Best-of-N model comparison.