The AI Tool That’s Quietly Gaining Traction
If you’ve been keeping an eye on the SkillsMP marketplace lately, you might have noticed a skill called 'writing-plans' quietly climbing the ranks. With over 271,000 stars and a mysterious trend status, it’s clear that this skill has captured the attention of many. But what exactly does it do, and why should you care?
As a senior developer who’s been around the block a few times, I’ve seen my fair share of AI tools and coding assistants. Some are revolutionary, while others are just hype. So, when I first heard about 'writing-plans', I was skeptical. But after diving deep into its documentation and testing it out, I’m convinced that this skill is worth a closer look.
What Does 'writing-plans' Actually Do?
At its core, 'writing-plans' is designed to help you create comprehensive implementation plans for multi-step tasks before you even start writing code. Think of it as a project manager and technical writer rolled into one, but with the precision of an AI.
Here’s how it works: You provide a spec or a set of requirements, and 'writing-plans' generates a detailed plan that outlines every step of the implementation process. This includes which files to create or modify, what each file is responsible for, and even the exact code snippets needed for each task. It’s like having a detailed roadmap for your project, complete with turn-by-turn directions.
But it doesn’t stop there. The skill also emphasizes best practices like Test-Driven Development (TDD), DRY (Don’t Repeat Yourself), and YAGNI (You Aren’t Gonna Need It). It assumes that the engineer executing the plan is skilled but lacks context about your specific codebase or toolset. This makes it incredibly useful for onboarding new team members or for projects where the team is distributed across different locations.
Why 'writing-plans' Matters
In the world of software development, planning is often the most crucial yet overlooked step. Many developers jump straight into coding, only to find themselves lost in a sea of bugs and refactoring. 'writing-plans' addresses this issue head-on by forcing you to think through the entire implementation process before you write a single line of code.
Here are a few key problems it solves:
-
Lack of Context: By assuming zero context, 'writing-plans' ensures that anyone can pick up the plan and understand what needs to be done. This is particularly useful in large teams or when onboarding new developers.
-
Inconsistent Code Quality: The skill emphasizes TDD and other best practices, which helps maintain consistent code quality across the project.
-
Inefficient Task Management: By breaking down tasks into bite-sized, manageable chunks, 'writing-plans' makes it easier to track progress and identify bottlenecks.
-
Poor Documentation: The skill encourages detailed documentation, which is often a weak point in many development projects.
Key Capabilities
Let’s take a closer look at some of the standout features of 'writing-plans':
-
Comprehensive Task Decomposition: The skill maps out which files will be created or modified and what each one is responsible for. This ensures that each task is focused and that files are organized by responsibility rather than technical layer.
-
Bite-Sized Steps: Each step in the plan is designed to be completed in 2-5 minutes. This makes it easy to track progress and ensures that tasks are manageable. For example, a typical task might include steps like "Write the failing test," "Run it to make sure it fails," "Implement the minimal code to make the test pass," and so on.
-
No Placeholders: Every step in the plan must contain the actual content an engineer needs. This means no "TBD," "TODO," or other placeholders. The skill enforces this by explicitly stating that such placeholders are plan failures.
-
Self-Review Checklist: After writing the plan, 'writing-plans' provides a checklist for self-review. This includes checking for spec coverage, scanning for placeholders, and ensuring type consistency across tasks.
-
Execution Handoff: Once the plan is complete, the skill offers two execution options: subagent-driven development and inline execution. This flexibility allows you to choose the approach that best fits your workflow.
Who Should Install 'writing-plans'?
If you’re a developer or AI power user who works on complex projects with multiple steps, 'writing-plans' is definitely worth considering. Here are a few scenarios where this skill shines:
- Large Teams: If you’re working in a large team where context is often lost, 'writing-plans' can help ensure that everyone is on the same page.
- Onboarding New Team Members: The skill’s emphasis on detailed documentation and zero-context assumptions makes it ideal for onboarding new developers.
- Complex Projects: If your project involves multiple subsystems or complex dependencies, 'writing-plans' can help you break down the work into manageable tasks.
- Remote Teams: For teams that are distributed across different locations, the skill’s detailed plans and execution options can help streamline the development process.
However, if you’re working on small, simple projects or if you prefer a more ad-hoc approach to development, 'writing-plans' might be overkill. It’s also worth noting that the skill assumes a certain level of technical proficiency, so it’s not ideal for complete beginners.
How to Install 'writing-plans'
Installing 'writing-plans' is straightforward. Here’s a quick guide:
- Via Claude Code: If you’re using Claude Code, you can install the skill via the official plugin marketplace:
bash
/plugin install superpowers@claude-plugins-official
Alternatively, you can register the Superpowers marketplace and install the skill from there:
bash
/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace
- Via Antigravity: If you’re using Antigravity, you can install the skill directly from the repository:
bash
agy plugin install https://github.com/obra/superpowers
-
Via Codex App: In the Codex app, navigate to the Plugins section, find 'Superpowers', and follow the prompts to install it.
-
Via Codex CLI: Open the plugin search interface and search for 'Superpowers':
bash
/plugins
s
Then install the skill:
bash
/plugin install superpowers@superpowers-marketplace
Concerns and Limitations
While 'writing-plans' is a powerful tool, it’s not without its limitations. Here are a few things to keep in mind:
-
Learning Curve: The skill has a steep learning curve, especially for those who are not familiar with TDD or other best practices. It requires a certain level of technical proficiency to use effectively.
-
Overhead: For small projects or simple tasks, the overhead of creating a detailed plan might not be worth the effort. It’s best suited for complex projects where the benefits of planning outweigh the costs.
-
Dependency on AI: The skill relies heavily on AI, which means that its effectiveness is tied to the quality of the AI’s understanding of the spec and the codebase. In some cases, the generated plans might require manual tweaking.
-
Execution Options: While the skill offers two execution options, the subagent-driven approach might not be suitable for all teams. It requires a level of trust in the AI’s ability to manage tasks autonomously.
The Verdict
After testing 'writing-plans' extensively, I can confidently say that it’s a valuable addition to any developer’s toolkit. Its ability to generate detailed, comprehensive plans makes it an excellent tool for managing complex projects. However, it’s not a one-size-fits-all solution. If you’re working on small projects or if you prefer a more hands-on approach, you might find the overhead of using 'writing-plans' to be too much.
But for those who are willing to invest the time and effort, 'writing-plans' can be a game-changer. It encourages best practices, ensures consistent code quality, and provides a clear roadmap for project execution. If you’re a developer or AI power user looking to streamline your workflow and improve your project management, 'writing-plans' is definitely worth a try.
Links to Resources
Happy coding!