Mastering `cm-brainstorm-idea`: The Complete Guide

The allure of “Vibe Coding” is undeniable. You describe a feature, the AI generates the code, and within minutes, you have a working prototype. It feels like magic—until it doesn’t. We’ve all been there: three hours into a session, the codebase is a tangled web of “just-in-case” logic, the UI is a Frankenstein of inconsistent components, and the original business goal has been buried under a mountain of hallucinated technical debt.

The problem isn’t the AI’s ability to code; it’s the speed at which we bypass the most critical phase of software development: Strategic Thinking.

In the Cody Master ecosystem, we solved this with a specialized gate called cm-brainstorm-idea. This isn’t just a “chat” tool. It is a structured, multi-dimensional analysis engine designed to ensure that before you write a single line of code, your idea has been battle-tested against technical feasibility, design integrity, and business value.

This guide will walk you through the mechanics of cm-brainstorm-idea, the frameworks that power it (TRIZ, 9 Windows, Double Diamond), and how to use it to transform vague “vibes” into production-grade architectural blueprints.

The Core Problem: The “Implementation Trap”

In traditional Vibe Coding, the workflow is usually: Idea -> Code -> Debug -> Regret.

We call this the Implementation Trap. Because the cost of generating code has dropped to near zero, we treat code as disposable. But while the generation is cheap, the maintenance and integration are expensive. Every “quick feature” added without thought increases the cognitive load of the system.

cm-brainstorm-idea introduces a “Strategic Pause.” It forces the agent (and you) to operate in the Problem Space before jumping into the Solution Space.

The Jobs-To-Be-Done (JTBD) of `cm-brainstorm-idea`

When I have a new feature request or a complex bug to solve…
I want to evaluate the idea across four critical dimensions (Tech, Product, Design, Business)…
So that I can select the most viable path and create a plan that doesn’t break my existing system.

How It Works: The Architectural Pillars

cm-brainstorm-idea doesn’t just “think” randomly. It follows a rigorous methodology derived from high-level product management and systems engineering.

1. The 9 Windows (TRIZ) Framework

This is the “secret sauce” of the skill. Derived from the Theory of Inventive Problem Solving (TRIZ), the 9 Windows framework forces the AI to look at your idea across two axes: Time and Space.

The Space Axis:
- Sub-system: What are the internal modules, functions, and data structures affected? (e.g., the database schema).
- System: The application itself. How does this feature fit into the current UI/UX?
- Super-system: The environment. How does this interact with external APIs, the browser, or the user’s operating system?
The Time Axis:
- Past: What was the previous state? Why wasn’t this built before? What are the legacy constraints?
- Present: The current problem we are solving.
- Future: How will this scale? What happens when we have 10,000 users? Does this create a “dead end” for future features?

By filling these 9 windows, cm-brainstorm-idea identifies hidden dependencies that a standard coding prompt would miss.

2. The Double Diamond Process

The skill facilitates a structured divergence and convergence:

Discover/Define (Diamond 1): The agent asks clarifying questions to narrow down the “vibe.” It looks for the why behind the what.
Develop/Deliver (Diamond 2): The agent proposes 2-3 distinct options, ranging from “The Quick Fix” to “The Robust Architecture,” allowing you to choose the path that fits your current constraints.

3. The Quadrant Evaluation

Every proposed option is scored against:

Technical Feasibility: Does our current stack support this? What is the risk of breaking changes?
Product Impact: Does this solve the user’s actual pain point?
Design Excellence: Does this align with our DESIGN.md and branding?
Business Value: What is the ROI? Does this move our core metrics?

Practical Example: Adding “AI Analytics” to a SaaS Dashboard

Imagine you have a project called “SaaS-Flow,” and you want to add an “AI-powered insight” feature that tells users when their churn rate is increasing.

The Mistake (Skipping Brainstorming)

You might prompt: “Add a card to the dashboard that uses an LLM to analyze the churn data and show a summary.” The AI will likely write a messy useEffect that calls an API, ignores error states, and uses a hardcoded prompt that costs you $0.50 per refresh.

The Cody Master Way (Using `cm-brainstorm-idea`)

Step 1: Activation You invoke the skill: gemini activate_skill cm-brainstorm-idea gemini run "I want to add AI-powered churn insights to the dashboard."

Step 2: The Agent’s Analysis The agent will scan your tech-stack.md and product.md. It notices you are using Supabase and Vercel. Using the 9 Windows, it realizes that:

Sub-system: You don’t have a “Logs” table to track AI usage.
Super-system: Calling an LLM on every dashboard load will hit Vercel’s execution limits.
Past: You recently refactored the data layer to be async-first.

Step 3: The Options Proposal The agent returns a structured report:

Option	Tech Approach	Complexity	Business Value	Recommendation
A: Edge Function	Live call to OpenAI on page load.	Low	Medium	Avoid: High cost and latency.
B: Background Worker	Cron job analyzes data nightly; stores in Postgres.	Medium	High	Winner: Consistent UI, predictable costs.
C: On-Demand	User clicks a “Generate Insight” button.	Low	Low	Secondary: Good for MVP, but lacks proactiveness.

Step 4: Decision & Transition You select Option B. The agent now has the context it needs to feed into cm-planning, ensuring the generated code includes a database migration and a scheduled job, rather than just a “vibey” React component.

Best Practices for High-Signal Brainstorming

To get the most out of cm-brainstorm-idea, you need to provide high-quality “fuel” for the engine.

1. Feed the Context Files

The skill is only as smart as the documentation it can read. Ensure your project has:

product.md: Defining your target audience and core “Jobs.”
tech-stack.md: Explicitly listing your libraries, versions, and deployment strategy.
DESIGN.md: Your design tokens, spacing rules, and component philosophy.

If these don’t exist, use cm-project-bootstrap first to generate them.

2. Embrace the “Negative Space”

When the agent asks questions, don’t just give one-word answers. Explain what you don’t want.

Bad: “Just make it look good.”
Good: “It needs to follow our minimalism guidelines. Avoid heavy shadows and don’t add any new third-party CSS libraries.”

3. Use the “TRIZ Parallel”

If you are stuck on a technical problem, ask the agent to perform a “Parallel TRIZ.” This tells the agent to look at how other industries or domains solve similar problems. For example, if you are struggling with “data synchronization,” the agent might look at how “aircraft flight controllers” or “logistics tracking” handle real-time state consistency. This often leads to “Aha!” moments that standard coding prompts never reach.

4. The “Pre-Mortem” Check

Ask the agent: “Perform a pre-mortem on Option B. Why will this fail in three months?” cm-brainstorm-idea is excellent at spotting “Scalability Traps”—places where your current logic works for 5 items but will crash the browser at 500.

Actionable Steps: Your First Brainstorming Session

Identify a “Vague” Requirement: Find something you’ve been putting off because you aren’t sure how to start (e.g., “Improve the onboarding flow”).
Run the Skill: Use gemini run "Brainstorm the onboarding flow improvement using cm-brainstorm-idea".
Review the 9 Windows: Look closely at the “Super-system” and “Future” windows. Are there external factors (like GDPR or mobile responsiveness) you’ve ignored?
Select an Option: Choose the path that balances “Time-to-Market” with “Technical Debt.”
Chain to Planning: Immediately follow up with cm-planning to turn the brainstormed strategy into a phased implementation plan.

Conclusion: From Coder to Architect

Vibe Coding is often criticized as “shallow” or “unstable.” But that’s only true if you treat the AI as a replacement for your hands, rather than a replacement for your research assistant.

cm-brainstorm-idea elevates you from a person who “prompts for code” to a System Architect. It ensures that your application has a cohesive soul, a stable foundation, and a clear path forward. By spending 10 minutes in the brainstorming gate, you save 10 hours of debugging hallucinated spaghetti code later.

Stop vibing in the dark. Start architecting with intent. Your codebase (and your future self) will thank you.

Mastering cm-brainstorm-idea: The Complete Guide