Plan mode, grill me, superpowers

Claude Code Planning Tools Compared: Plan Mode vs Grill Me vs Superpowers

Byalexrusin

Introduction

The quality of AI-generated code doesn’t start with the prompt — it starts with the plan. If you’ve ever fired a vague request at an AI agent and wondered why the output missed half your requirements, the problem wasn’t the model. It was the lack of context, constraints, and edge cases you gave it before a single line of code was written.

In this post, we put three planning tools for Claude Code head-to-head using the exact same task: building controller-based CRUD API routes for a posts model in a Node.js TypeScript project using Express, Prisma ORM, and Joi validation.

The three contenders:

  • 🤖 Claude Code’s built-in Plan Mode
  • 🔥 Grill Me Skill
  • ⚡ Brainstorming Skill from the Superpowers Plugin

All three share the same fundamental goal — extract as much useful information as possible before writing code. But their approaches, trade-offs, and results are dramatically different. Here’s what happened.

🚀 Complete Claude Code & Coding Agents Course

The Project Setup

Before diving in, here’s the context. The project is a Node.js API built with:

  • TypeScript
  • Express 5
  • Prisma ORM with a PostgreSQL database running in Docker
  • ESLint and Prettier
  • Context7 plugin for up-to-date package documentation

The existing codebase had a single route — a health check endpoint — and one Prisma model: Post.

The task: generate full CRUD routes for the Post model using a controller/repository pattern, with Joi validation, centralized error handling, and consistent structured error responses.

Contender #1: Claude Code Plan Mode

How It Works

Plan Mode is Claude Code’s native planning feature. You trigger it with /plan, point it at a feature file, and Claude takes over — reading your project context and generating an implementation plan automatically.

What Happened

Claude Code read the project, generated a plan file, and started executing — without asking a single question. With auto mode enabled, it created all necessary files and implemented the full feature in approximately 10 minutes.

What It Got Right

  • Added Joi v18 (the current version) to package.json — correctly following the instruction to use the latest packages
  • Created a clean feature-based module structure: modules/post/ containing controller, repository, routes, and validation
  • Implemented a centralized error handler with structured error contracts (error code, message, details)
  • Tests passed out of the box (npm run test)
  • Used Express 5’s res.locals for validated data instead of mutating req — a subtle but important design choice for Express 5 compatibility
  • All CRUD endpoints were functional: GET /posts, GET /posts/:id, POST /posts, PATCH /posts/:id, DELETE /posts/:id
  • Even added pagination unprompted

What It Got Wrong (or Decided For You)

  • Routes were mounted without an /api prefix — a common convention that wasn’t discussed
  • Used HTTP 400 for validation errors instead of the more semantically correct 422 Unprocessable Entity
  • Pagination was added without being asked — useful, but an assumption
  • Every design decision was made by the model, not the developer

Verdict

Plan Mode is fast, capable, and largely correct. But you are a passenger. Claude makes architectural decisions on your behalf, and you only find out what those decisions were after the fact.

Contender #2: Grill Me Skill

How It Works

Grill Me is a community skill designed to do the opposite of Plan Mode — instead of making decisions for you, it interviews you relentlessly until a shared understanding is reached. You install it via the Claude Code skills system and invoke it with /grill-me.

Installation

bash

# Install via the grill me skill repository
# Then move the skills folder into your .claude directory

Once installed, you invoke it the same way as Plan Mode — point it at your feature file and hit enter.

What Happened

Rather than diving straight into implementation, Claude Code — guided by the Grill Me skill — started asking structured questions about every aspect of the feature:

  • Project structure: Feature-based, layer-based, or hybrid? (Recommendation: feature-based)
  • Route mounting: /posts vs /api/posts vs /api/v1/posts
  • HTTP verbs: PUT vs PATCH for updates
  • Validation strategy: How should errors be structured?
  • Repository design: What methods should be exposed?
  • Error handling: What HTTP codes map to what scenarios?
  • Testing strategy: Unit tests, integration tests, or both?

In total: 37 questions.

What It Got Right

  • Every design decision was explicitly made by the developer, not defaulted by the model
  • The resulting code reflected intentional architectural choices — /api prefix, PATCH for partial updates, 422 for validation errors
  • Added filtering by published status (because it asked whether you wanted it)
  • The process forces you to genuinely think through your architecture before a single file is created
  • The recommendations provided alongside each question were consistently sensible — when in doubt, the suggested defaults were good

The Trade-Off

37 questions sounds exhausting, and it does take longer upfront. But the payoff is code that matches your mental model of the feature — not the model’s best guess at what you probably want.

Verdict

If you want control over your architecture, Grill Me is surprisingly powerful. The interrogation process isn’t a bug — it’s the feature. You end up with a codebase that you designed, not one you inherited from an AI’s defaults.

Contender #3: Brainstorming Skill — Superpowers Plugin

How It Works

Superpowers is an official Claude Code plugin — a full development workflow system with multiple skills including brainstorming, git worktrees, spec-driven development, test-driven development, and code review. You install it via /plugins in Claude Code.

The brainstorming skill is invoked with /brainstorming, pointed at your feature file, and it follows a structured multi-phase process:

  1. Explore project context
  2. Ask clarifying questions
  3. Propose architecture approaches
  4. Generate a spec document
  5. Generate an implementation plan
  6. Execute via sub-agent-driven development

What Happened

The brainstorming phase asked 6 focused questions — fewer than Grill Me, but well-targeted:

  • Which endpoint set to use (with pagination/filtering options)
  • Success response structure
  • PUT vs PATCH
  • Testing strategy preference (unit tests without hitting the database)

After answering, it presented a full architecture review including:

  • Module structure with a service layer between controller and repository
  • Error class hierarchy: AppError → ValidationError, NotFoundError, ConflictError
  • Prisma error mapping in the repository layer
  • Validation schema contracts
  • Full API contract with response shapes

It then wrote and committed a spec document (docs/superpowers/), followed by a detailed implementation plan with individually reviewable tasks. This is a genuinely powerful workflow — you can implement task by task, pause and review, iterate on the plan, and resume.

Where It Stumbled

At the implementation phase, using sub-agent-driven development, execution stalled at Task 5 (validate middleware) at the 31-minute mark. The multi-agent execution consumed significant tokens and didn’t recover on its own.

What It Got Right

  • Most ambitious and thorough planning phase of the three tools
  • Spec document and implementation plan are durable artifacts you can return to, modify, and re-run
  • Incremental task execution means you’re not doing everything in one high-stakes shot
  • Native async handling awareness for Express 5 (no express-async-errors wrapper needed)
  • Multi-agent code review and testing baked into the workflow

Verdict

Superpowers showed the highest ceiling but hit a wall at execution. The brainstorming phase is excellent. The spec-driven, incremental approach is the right idea for complex features. It’s a tool to keep watching — especially as multi-agent execution matures.

Side-by-Side Comparison

Plan ModeGrill MeSuperpowers
Questions asked0376
Time to complete~10 minLonger upfront31+ min (stalled)
Design control❌ AI decides✅ You decide✅ You decide
Spec document❌❌✅
Incremental plan❌❌✅
Code qualityGoodGoodIncomplete
Token costLowMediumHigh
Best forSpeedControlComplex features

Key Takeaways

  1. No planning tool is universally best — the right choice depends on how much control you want and how complex the feature is.
  2. Plan Mode is impressive but passive. It gets you to working code fast, but the AI owns the architecture. Great for prototypes or when you trust the model’s judgment.
  3. Grill Me changes the relationship. 37 questions forces intentional design. When the code ships, it reflects your decisions. That’s a fundamentally different — and often better — developer experience.
  4. Superpowers has the best ideas but needs time to mature. Spec documents, reviewable plans, and incremental multi-agent execution are exactly the right direction for AI-assisted development at scale. Watch this space.
  5. The better the plan, the better the output. All three tools prove the same thesis: front-loading context extraction produces better code than jumping straight to a prompt.

Conclusion

The era of the one-line AI prompt is over. As AI agents become more capable, the bottleneck shifts from can the AI write the code to can you articulate clearly enough what you want built. Planning tools are the bridge between a vague idea and a well-architected feature.

Plan Mode, Grill Me, and Superpowers each approach that bridge differently — speed vs. control vs. depth. Understanding the trade-offs means you can choose the right tool for the right moment.

Which approach would you reach for on your next project? Drop it in the comments.

Share this article

Similar Posts