Cursor Subagents and Claude Code /simplify: A Practical Workflow

TL;DR

• On January 22, 2026, Cursor 2.4 introduced Subagents and Skills, giving Cursor a cleaner way to split research and execution into parallel, specialized work streams.
• Cursor’s model for persistent guidance is now clearer: use .cursor/rules or AGENTS.md for always-on instructions, and use SKILL.md files for dynamic, task-specific workflows.
• Claude Code now has similarly strong primitives on the terminal side: custom subagents, Plan Mode, git worktree isolation, and, in Claude Code v2.1.63, the bundled slash commands /simplify and /batch.
• The best combined workflow is not “pick one tool forever.” It is: research and parallel exploration in Cursor, implementation in the tool you are already using for the task, then a Claude Code cleanup and review pass with /simplify before opening the PR.
• One important caveat from my source audit: Anthropic’s public changelog clearly confirms /simplify, but the official docs currently document subagents, slash commands, Plan Mode, and worktrees much more deeply than /simplify itself. Treat /simplify as a strong cleanup pass, not as a substitute for code review or tests.

There is a real convergence happening between AI coding tools. Cursor is getting better at parallel, IDE-native delegation. Claude Code is getting better at structured terminal workflows, worktree isolation, and reusable agent behavior. The interesting question is no longer “which tool wins?” It is “where does each tool create the most leverage?”

For me, the answer is surprisingly practical: use Cursor to fan out research and codebase exploration, then use Claude Code to tighten the implementation and review loop.

What Cursor Actually Added

The biggest shift in Cursor over the last few months is not just “better autocomplete.” It is the move toward parallel agent orchestration.

Cursor 2.0, released on October 29, 2025, introduced a more explicitly agent-first interface and the ability to run up to eight agents in parallel on a single prompt, using git worktrees or remote machines to avoid file conflicts. That matters because it changed Cursor from a single conversational assistant into a coordination surface.

Then on January 22, 2026, Cursor 2.4 added two pieces that make that orchestration much more usable:

1. Subagents

Cursor’s own announcement describes subagents as independent agents that handle discrete parts of a parent task in parallel, each with its own context and configuration. That is the key design idea.

This solves two annoyances that show up constantly in long AI sessions:

• the main conversation gets polluted by exploratory dead ends
• one noisy task, like repository exploration or terminal output, steals attention from the higher-value planning thread

Subagents are a clean answer to both. They let the parent agent stay focused while side tasks happen elsewhere.

2. Skills

Cursor’s Skills are a better mental model than many people realize. According to Cursor’s 2.4 announcement, Skills are an open standard built around SKILL.md files, and they are meant for domain-specific knowledge, scripts, and procedural workflows that are discoverable and only applied when relevant.

That makes Skills meaningfully different from rules:

• Rules are persistent guidance
• Skills are dynamic capabilities

This is an important distinction, because a lot of AI-tool frustration comes from putting everything into one giant instruction file and then wondering why context gets bloated or contradictory.

Cursor’s Configuration Stack Is Now Much Clearer

From Cursor’s docs, the most useful model is:

• .cursor/rules for versioned, scoped project rules
• AGENTS.md for a simpler markdown-based instruction file at the project root
• SKILL.md files for reusable workflows that should only load when relevant

Cursor’s CLI docs also note that it reads AGENTS.md and CLAUDE.md at the project root, alongside .cursor/rules. That detail matters if you work across both Cursor and Claude Code, because it means one repository can support both toolchains without duplicating all of its guidance.

Why Subagents Matter More Than They First Appear

The feature headline is “parallelism,” but the deeper value is context hygiene.

When an agent can delegate repo exploration, terminal-heavy investigation, or narrow implementation work to isolated subagents, three good things happen:

1. The main thread stays readable.
2. The delegated work can happen in parallel.
3. The parent agent can reason at a higher level instead of being forced to carry every intermediate detail.

That is why subagents are especially strong for:

• large-repo codebase archaeology
• comparing multiple approaches before implementing one
• breaking a broad feature into a few low-overlap work streams

They are weaker when several tasks need to edit the same files. Parallelism only helps when file ownership is reasonably separable. Otherwise, you create merge work, not leverage.

That last point is partly documented and partly operational judgment. Cursor’s announcements emphasize parallel work streams and isolated execution. The practical consequence is obvious: the more your agents touch the same hot files, the less useful the parallelism becomes.

Where Claude Code Fits Better

Cursor is strongest when I want an IDE-native, multi-threaded research and implementation surface.

Claude Code is strongest when I want a terminal-native, explicit, inspectable engineering loop.

Anthropic’s documentation now makes several parts of that loop unusually solid:

Plan Mode

Claude Code’s Plan Mode is built around read-only analysis first and implementation second. Anthropic documents it explicitly as a safe code-analysis workflow, and the common-workflows guide recommends it for multi-step changes, code exploration, and interactive planning.

That makes it ideal when I want to pause before writing code and force the agent to make its reasoning legible.

Custom subagents

Claude Code also supports custom subagents through .claude/agents/ at the project level and ~/.claude/agents/ at the user level. Anthropic’s docs are much more explicit here than many people realize: Claude can automatically delegate to specialized subagents, you can restrict their tools, and you can share project-specific ones with your team.

In other words, Claude Code is no longer just “one terminal agent.” It has become a structured multi-agent system in its own right.

Worktree isolation

This is one of the most important pieces in the stack.

Anthropic’s docs now cover:

• claude --worktree
• subagent worktree isolation
• automatic cleanup behavior
• separate branches per worktree

That matters because parallel agents without isolation quickly turn into branch and diff chaos. Worktrees make the parallelism real instead of aspirational.

What /simplify Changes

The part of your draft I most wanted to verify was /simplify.

The cleanest confirmed source I found is Anthropic’s official claude-code changelog on GitHub. In Claude Code v2.1.63, Anthropic added /simplify and /batch as bundled slash commands.

That is enough to confidently say the command is real and officially shipped.

What is less fully documented, at least publicly as of March 24, 2026, is the deeper behavioral contract. Anthropic’s docs are extensive on slash commands, subagents, worktrees, and planning, but much thinner on /simplify specifically than your original note suggested.

So the responsible mental model is:

• /simplify is an official built-in command
• it belongs in the post-implementation cleanup and review stage
• you should still inspect the diff and run tests

I would use it the same way I use a strong human code-review pass: not to replace correctness checks, but to catch code that technically works while still feeling clumsy, repetitive, or heavier than it needs to be.

And /batch?

/batch shipped in the same Claude Code release. Paired with Claude Code’s worktree support, it is the signal that Anthropic is leaning hard into parallel large-scale changes, not just single-threaded coding sessions.

That makes /batch the “big migration” counterpart to /simplify:

• use /batch for broad, decomposable work
• use /simplify for tightening and cleanup after implementation

The Most Useful Combined Workflow

If you are already switching between Cursor and Claude Code, I think the highest-leverage workflow looks like this:

1. Explore in Cursor

Use Cursor subagents to split research into parallel threads:

• one subagent maps the relevant code paths
• another inspects existing abstractions and conventions
• another checks tests, examples, or prior implementations

This is where Cursor’s subagents shine. They keep the main thread clean while the repo gets explored from multiple angles.

2. Store the right kind of guidance

Keep persistent team rules in:

• .cursor/rules
• AGENTS.md
• CLAUDE.md

Then keep procedural workflows in SKILL.md.

The trick is to avoid mixing these layers. Rules should be stable. Skills should be situational.

3. Implement in the environment that best fits the task

If you are already deep in the IDE, stay in Cursor.

If the task is shell-heavy, Git-heavy, or benefits from explicit worktree management and Plan Mode, move to Claude Code.

This is less about ideology than friction. Use the tool that makes the next 30 minutes simpler.

4. Run a Claude Code cleanup pass

After the feature works, switch to Claude Code and run:

claude
# then inside Claude Code
/simplify

If the change was large enough that parallelization itself is the main challenge, consider Claude Code’s worktree-oriented workflows or /batch instead.

5. Review the diff like a human reviewer

This part still matters.

The best AI workflow is not “trust the last agent.” It is:

• let the agent produce the cleanup
• inspect the diff
• run tests
• open the PR only after the code looks intentionally shaped, not just technically complete

Cursor vs. Claude Code: The Real Split

After auditing the docs, the cleanest distinction I can make is this:

That is why I do not think /simplify is really a “Cursor alternative” story.

It is a finishing tool inside a broader workflow.

Cursor helps you think and fan out. Claude Code helps you tighten and land.

What I Would Actually Recommend

If you want a practical adoption path, keep it simple:

1. Use Cursor subagents for codebase exploration and plan decomposition.
2. Use Skills for reusable workflows and Rules / AGENTS.md for persistent repo guidance.
3. Use Claude Code Plan Mode when the change is risky enough that you want an explicit read-only planning pass.
4. Use Claude Code /simplify before the PR to improve shape, not to replace review.
5. Use worktrees when parallel agents might otherwise collide.

That workflow gets you most of the upside without forcing the whole team to become dogmatic about a single tool.

Sources

• Cursor 2.0: New Coding Model and Agent Interface
• Cursor Docs: Rules and AGENTS.md
• Cursor Docs: CLI Usage
• Cursor Docs: Background Agents
• Cursor 2.4: Subagents, Skills and Image Generation
• Cursor 2.4: Subagents
• Cursor 2.4: Skills
• Claude Code Docs: Common Workflows
• Claude Code Docs: Slash Commands
• Claude Code Docs: Settings and Subagent Configuration
• Anthropic Release Notes: Claude Code
• anthropics/claude-code CHANGELOG.md
• shinpr/sub-agents-mcp
• shinpr/sub-agents-skills