Claude's New Coder Works While You Sleep

Anthropic maintains an aggressive development cadence, continuously pushing the boundaries of AI-assisted coding. Recent months have seen the release of Claude Routines and a complete redesign of the Claude Code desktop app, underscoring the company's commitment to rapid iteration and enhanced developer experience. This relentless pace introduces new tools that fundamentally alter established workflows, promising significant shifts in developer productivity.

This rapid evolution now brings Ultraplan, a groundbreaking research preview feature designed for Claude Code. Ultraplan fundamentally shifts the complex process of code planning from a developer's local command-line interface (CLI) directly to a robust cloud-based environment. This innovative approach allows Claude to study an entire repository within a secure cloud container, crafting detailed implementation plans without requiring local computation resources or direct interaction with the user's machine.

Developers can invoke Ultraplan with a simple `/ultraplan` command or by typing `ultraplan` within Claude Code, triggering a cloud session. The system then clones the user's GitHub repository into this remote environment, enabling Claude to thoroughly analyze the codebase and propose solutions. This cloud-first strategy means Ultraplan can even draft and implement code changes remotely, allowing development to progress while the user's local hardware remains free. More technical details are available in the Ultraplan Docs.

Ultraplan's arrival sets up a compelling head-to-head comparison with a well-established community favorite: the superpowers plugin. For months, superpowers has been the go-to solution for many Claude Code users, offering more thorough and interactive planning capabilities than the built-in modes. This article will meticulously pit Anthropic's official, cloud-native planning tool against the popular, locally-run community plugin, evaluating each on critical metrics like output quality, token consumption, and the overall developer experience to determine which truly streamlines the coding process.

Ultraplan represents Anthropic’s bold step into cloud-native AI development, fundamentally changing how developers approach project planning. This feature initiates by cloning your GitHub repository directly into a secure cloud container, allowing Claude to thoroughly understand your codebase without ever touching your local hardware. It establishes a dedicated cloud session, analyzing your project's structure, dependencies, and existing code base remotely.

Developers trigger this powerful capability with a simple `/ultraplan` command in their terminal, followed by a specific prompt outlining the desired feature or task. This action immediately prompts an interactive planning session on the Claude Code web interface. The shift from local CLI processing to a web-based environment is critical, offloading intensive analysis and planning from the user's machine.

Once activated, Ultraplan seamlessly sets up its cloud environment, clones the designated GitHub repo, and employs bash tools to read and comprehend the code. Within approximately two to three minutes, the AI generates a detailed, actionable plan. Users can then review this plan directly in the web interface, adding comments or requesting revisions collaboratively, ensuring the AI's output aligns perfectly with their vision.

Ultraplan's core value proposition lies in its autonomous planning capabilities. Developers can start a planning session on one machine, close their laptop, and trust the AI to work independently in the cloud. The generated plan, and any subsequent revisions, become accessible from any device with an internet connection, fostering a truly asynchronous and flexible development workflow. This empowers teams to initiate complex tasks and receive comprehensive planning while they focus on other priorities.

For comprehensive, in-depth planning within Claude Code, developers have long relied on superpowers, an established plugin. This alternative operates entirely locally, granting it direct access to the user's file system. Unlike cloud-based solutions, superpowers eliminates the need to clone a repository into a separate environment, streamlining its initial setup.

superpowers employs a sophisticated, two-phase planning methodology. It begins with a 'design plan' to meticulously capture all project requirements and scope the problem. Following this, it generates a detailed 'implementation plan,' breaking down the design into manageable, bite-sized tasks ready for execution.

A signature feature of superpowers is its highly interactive, Socratic method. The plugin asks numerous clarifying questions, often double the amount posed by other tools, ensuring a more thorough and robust understanding of the project. This rigorous questioning leads to exceptionally detailed plans, which can span over 800 lines compared to plans under 200 lines from less interactive methods.

This meticulous approach extends to code generation, where superpowers prioritizes writing test cases first. It prompts the model to generate tests, then verifies their failure, before proceeding with the actual implementation for each task. While its extensive planning can consume a significant amount of tokens—a full design and implementation plan might use around 75.1k tokens—many developers find the resulting clarity and robustness invaluable for complex projects. For more insights into these advanced AI capabilities, explore the latest developments from Anthropic.

To rigorously test Anthropic's new Ultraplan feature against the established superpowers plugin, we devised a concrete, real-world development challenge. Our test case involved creating a complete release pipeline for `hance`, a command-line interface (CLI) tool from Orva-Studio designed for film emulation. This open-source project, available on GitHub, provided a robust and representative codebase, simulating a common developer task. The pipeline needed to encompass everything from versioning and artifact generation to automated testing and deployment, mirroring the complexities of a production-ready system.

Our primary objective was to compare the two AI coding assistants across several critical dimensions. We meticulously evaluated the quality of the generated development plan, assessing its comprehensiveness, accuracy, and the actionable nature of its steps. Did it account for edge cases, propose robust testing strategies, and map out a clear path to completion? Equally important was the developer experience, which included factors like interaction fluidity, the clarity of prompts, the ease of reviewing and refining the AI's output, and its ability to adapt to feedback. Finally, we tracked resource consumption, specifically focusing on token usage, to understand the efficiency of each tool in generating a viable plan.

Ensuring a fair and unbiased comparison was paramount. We supplied both Ultraplan and superpowers with the *exact same prompt*, detailing the precise requirements for the `hance` release pipeline. This consistent input eliminated variables related to prompt engineering, allowing for a direct, head-to-head assessment of their planning capabilities when faced with an identical problem. This standardized methodology would reveal which tool offered a more effective, efficient, and user-friendly path to generating a comprehensive implementation strategy for a complex software project.

Initiating Ultraplan, developers issue the `/ultraplan` command, or simply `ultraplan` for a visual rainbow effect, then paste their prompt. For our film emulation CLI tool, hance, the goal was a complete release pipeline. The initial attempt quickly hit a snag, failing at approximately 4% of the usage allowance. Restarting in debug mode provided a crucial link, opening the process within the redesigned Claude Code for Mac desktop app.

Ultraplan first established a secure cloud container, then attempted to clone the GitHub repository. It launched Claude Code in this cloud environment, using bash tools to scan the repo's contents and execute additional commands. After a few minutes and some clarifying questions from Claude, a terminal notification confirmed the plan was ready for review.

Inspecting the first draft revealed a critical flaw: Ultraplan incorrectly reported the repository as "empty with no commits and no code." Despite this fundamental misstep, the generated plan was remarkably comprehensive. It outlined the overall shape of the required changes, proposed build scripts, and even included a minimal CLI for a future smoke test, suggesting rapid processing via sub-agents.

This initial plan consumed 15% of the user's token allowance, bringing the total usage to 19% after the debugging issue. To correct the fundamental error, users leverage the web interface. Here, they select problematic text and add comments, like querying "what repo are you referring to?" and asking for a revision. Claude then initiated a new planning cycle, successfully cloning the correct repository this time.

Within roughly a minute, Claude proposed a revised plan. This iteration demonstrated a significantly improved understanding of the project's existing codebase, providing a much more accurate blueprint. The updated plan featured a detailed flow diagram, listed the exact files requiring modification, and refined the GitHub action for releases, showcasing a deeper grasp of the project's needs.

However, this iterative improvement came at a substantial cost. The revision process alone pushed token usage from 19% to 37%. In total, generating the initial flawed plan and its subsequent, more accurate revision consumed approximately 33% of the user's total allowance—a considerable expenditure for planning alone.

Superpowers, the established Claude Code plugin, adopts a ground-up strategy, leveraging its local integration to drive a more intensive planning process. Diverging from Ultraplan's initial three questions, superpowers commenced its session by probing with six distinct queries. This doubled engagement allows for a more thorough understanding of the project's nuances, directly accessing the codebase without the need for cloud-based cloning or container setup.

This deeper local interaction translates directly into the generated plan's structure and detail. Superpowers operates through two distinct planning phases: first, a design plan meticulously captures the problem statement and overarching requirements; subsequently, an implementation plan meticulously breaks down that design into granular, actionable chunks. This two-tier approach ensures comprehensive coverage from high-level vision to low-level execution.

The resulting implementation plan provides an exceptionally rich blueprint. It explicitly articulates the project's goal, defines the architectural considerations, and specifies the underlying tech stack. Moreover, it maps out the precise file structure required for the release pipeline and lists every task for implementation, including source code snippets. This level of detail empowers developers with a clear roadmap for feature delivery.

A pivotal differentiator for superpowers lies in its unwavering commitment to Test-Driven Development (TDD). Unlike Ultraplan, superpowers consistently generates test cases *before* writing any corresponding implementation code. For instance, in the task of adding a version flag, it first crafts the test to verify versioning functionality. Developers then run this test, observe its failure, and only then proceed to write the minimal code necessary to make the test pass. This ensures robust, validated code from the outset.

This rigorous, test-first methodology contributes to the sheer scale of the output. The final superpowers plan for the release pipeline spanned an impressive 833 lines. This dwarfs Ultraplan's comparable plan, which totaled just 195 lines, highlighting the significant difference in depth and prescriptive guidance. The local execution and detailed questioning of superpowers deliver a radically more extensive and actionable development strategy. For further insight into the alternative cloud-based planning, consult the Ultraplan Docs.

A direct comparison of raw resource consumption reveals distinct approaches. superpowers, operating locally, consumed approximately 75.1k tokens for its comprehensive design and implementation plans. This figure, encompassing 57k for messaging and 1.9k for skill usage, represents a complex aggregate influenced by local caching and iterative skill application. Ultraplan, leveraging cloud compute, presented a different metric: its initial draft consumed around 15% of a timed usage limit. A subsequent revision pushed the total for the complete Ultraplan output to approximately 33% of the same limit, offering a clearer, percentage-based cost.

Output quantity further underscored these divergent philosophies. Ultraplan delivered a concise initial plan of 195 lines, prioritizing rapid iteration and a quick first look. In stark contrast, superpowers produced a massive 833-line blueprint. This extensive output included a dedicated design plan, a detailed implementation plan, and even generated test cases before implementation code, reflecting a commitment to thoroughness and structured development.

Interaction patterns also varied significantly. Ultraplan streamlined its initial planning phase, requiring only three upfront questions and generating a first draft in an impressive two to three minutes. This speed offers a clear advantage for quick prototyping or initial explorations. Conversely, superpowers demanded more upfront engagement, posing six initial questions to deeply understand the project context. While this required more immediate user input, it directly contributed to the richer, more detailed initial plan it ultimately produced, optimizing for depth over initial velocity.

Ultraplan’s design champions a hands-off, automated workflow, positioning itself as the ideal tool for delegating complex planning tasks. Developers initiate the process with a simple `/ultraplan` command, confirm remote execution in the web interface, and then largely 'fire and forget' as the AI clones the GitHub repo into a secure cloud container. This approach minimizes direct developer dialogue, asking only three initial questions before proceeding to generate a comprehensive plan and even implement code remotely, effectively working while you attend to other tasks.

superpowers, in stark contrast, cultivates a deeply conversational and collaborative developer experience. It embodies the essence of an AI pair programmer, engaging the user in a Socratic dialogue right from the start. This interaction begins with a more extensive query phase, posing six initial questions—double Ultraplan’s count. This iterative questioning allows superpowers to build a granular understanding of the problem and requirements directly with the developer, fostering a sense of shared ownership over the plan’s evolution.

This fundamental difference in interaction model leads to distinct trade-offs. Ultraplan’s powerful remote execution within a cloud container offers efficiency but can feel somewhat disconnected from the local development environment. While it can implement changes, the absence of pre-configured GitHub credentials in the remote sandbox necessitates manual steps for creating new branches and Pull Requests (PRs). This adds a post-execution task to an otherwise automated flow, potentially breaking the seamless delegation Ultraplan aims for. The option for local execution wasn't immediately obvious, highlighting a friction point for developers seeking more control.

superpowers’ multi-phase planning, encompassing both a design plan and an implementation plan, coupled with its Socratic dialogue, demonstrably leads to a deeper understanding for the developer. By prompting for test cases *before* code implementation and breaking down the design into bite-sized tasks, superpowers guides the developer through the rationale behind each step. This collaborative introspection yields a more granular insight into the proposed solution, evidenced by its 833-line plan compared to Ultraplan's 195-line output. The higher initial token usage of superpowers (~75k tokens) reflects this investment in detailed, collaborative planning, ultimately fostering a more profound grasp of the generated solution.

Choosing the right AI coding assistant hinges entirely on the task at hand and a developer's preferred workflow. Ultraplan excels when convenience and remote execution are paramount. It is ideal for:

• 1Kicking off complex tasks while commuting or traveling, away from your primary development machine.
• 2Delegating standardized, well-defined problems that require minimal human intervention.
• 3Initiating code generation that you plan to review and refine at a later time.

Conversely, superpowers shines in scenarios demanding deep context and iterative refinement. This local-first plugin is best suited for:

• 1Tackling complex, nuanced problems where a full local toolset and direct repo access are crucial.
• 2Developers who favor an interactive, highly conversational planning process.
• 3Projects requiring thorough test case generation *before* implementation, a core strength of superpowers.

For my primary workflow, superpowers remains the champion, accounting for roughly 90% of my Claude Code interactions. Its ability to ask more probing questions — six compared to Ultraplan's three — leads to a significantly more thorough plan, often 833 lines versus Ultraplan's 195. This deep dive, coupled with local control, provides an unparalleled sense of command over the development process. For those interested in exploring superpowers further, check out the project's GitHub repo Superpowers for Claude Code.

Ultraplan’s "fire and forget" model, while powerful for hands-off delegation, often incurs a higher token cost over time due to remote execution and revision cycles. The initial Ultraplan run, even after debugging, consumed 33% of my usage, compared to superpowers' 75.1k raw tokens. While cost figures are complex, superpowers' local processing often feels more efficient for deep dives.

Ultimately, neither tool is objectively "better"; they simply serve different purposes. Ultraplan offers a tantalizing glimpse into cloud-native AI coding, perfect for when you need a capable assistant working autonomously. superpowers, however, provides the granular control and interactive depth that many developers crave for their most intricate challenges. The choice empowers developers to select the champion that best fits their immediate needs and working style.

Ultraplan signals a significant shift in AI-assisted development, moving beyond real-time conversational partners to asynchronous, autonomous agents. This isn't merely a new feature; it's a fundamental redefinition of how developers interact with AI, allowing complex, time-consuming tasks to run in the background, freeing human cognitive load.

Consider the profound implications for team workflows and the very definition of a 'workday'. Developers can now delegate intricate tasks, like building a complete release pipeline for a command-line tool designed for film emulation, before stepping away. AI agents then work autonomously overnight or during commutes, presenting a near-complete draft for review, radically accelerating iteration cycles.

Code reviews will evolve dramatically. Instead of scrutinizing every line of newly written code, engineers will increasingly focus on validating AI-generated solutions, ensuring architectural integrity, security, and adherence to organizational best practices. This shifts the review's scope from basic implementation correctness to higher-level design and strategic oversight.

Expect Ultraplan-like capabilities to become standard across development platforms. Future iterations of Claude Code, and similar AI tools, will likely integrate even more deeply with CI/CD pipelines, automating not just planning and implementation, but also comprehensive testing, robust deployment, and continuous monitoring. This extends AI's reach far beyond the initial coding.

These features will also roll out to more platforms beyond the current CLI, appearing in web-based IDEs and integrated development environments. Imagine kicking off a complex refactor or a new feature from a tablet while commuting, with the AI agent diligently working on your codebase in a secure cloud container, ready for morning review.

This isn't just about convenience; it's a glimpse into a future where development happens around the clock, 24/7. AI agents transform into persistent, always-on members of engineering teams, continuously contributing, learning, and optimizing. The dawn of asynchronous AI development promises a future of unprecedented productivity, enabling human developers to focus on creativity.

What is Claude Code Ultraplan?

It's a research preview feature that moves project planning from your local machine to a cloud environment. It allows Claude to clone your GitHub repo, analyze it, and generate implementation plans remotely.

Is Ultraplan better than the Superpowers plugin?

It depends on the use case. Ultraplan excels at remote, 'set-it-and-forget-it' tasks, while Superpowers offers a more detailed, locally-controlled planning experience with deeper developer interaction.

Does Ultraplan work for any project?

Currently, Ultraplan requires your project to be hosted on GitHub so it can clone the repository into its cloud environment for analysis. It is activated via the Claude Code CLI.

How does token usage compare between Ultraplan and Superpowers?

Both can be token-intensive. In the reviewed test, a revised Ultraplan used about 33% of the user's limit, while a full Superpowers plan used significantly more raw tokens, though this is offset by caching.