AI Ideation Framework: From Vibe to Spec Design

You open Claude or ChatGPT with an idea. You ask it to generate options. Twenty minutes later, you have 47 suggestions, none of which feel right. You've generated so much that you're paralyzed. Worse, you're not sure which direction to take because the AI just gave you... everything.

This is vibe design.

It's reactive. It's without criteria. It feels like the AI decided, and you're just picking from a menu.

There's a better way.

This framework describes how to work with AI in a structured way to generate thoughtful solutions instead of magical outputs with no reasoning behind them.

It's domain-agnostic. It works for research, development, design, data analysis, or anything else. It's not about the industry. It's about how you think.

It's tool-agnostic. It works in Claude, in Lovable, in Cursor, in VS Code. It doesn't matter where you work. What matters is how you think.

The core insight: Critical thinking is the skill. The tool is secondary.

Vibe Design

You ask the AI to generate ideas without structure. You get overwhelmed with options. You feel like the AI is deciding, and you're just consuming.

Result: paralysis, lack of direction, no clear justification for your choices.

Spec Design

You structure the problem before asking. You iterate with the AI until you have clarity. You document your decisions. Then you build.

Result: specific solutions, clear decision-making, sense of control.

The difference isn't the AI. It's you.

Your job in this phase is simple: discover what you don't know you don't know.

You start with something concrete. Not a vague question like "help me design a thing." Something structured. A user story. A requirement using EARS syntax. Something that has substance.

Then you ask the AI to expand. What would this require? What problems might this solve? What edge cases exist? What assumptions am I making?

The AI suggests things you didn't consider. Architectures you didn't think of. Edge cases that matter. Complexity you didn't see.

Example:

You didn't think of half of these. Now you do.

This is expansion. It's not about having more options. It's about understanding the problem more completely.

You know you have enough expansion when you feel like you've covered the main cases and the IA's suggestions make sense instead of feeling random.

Expansion without contraction leads to paralysis. This is where you actually start thinking.

This phase isn't linear. It's a loop. Each iteration brings you closer to clarity.

You ask for clarity. "Why that architecture and not this one? What are the trade-offs?" The AI explains. You understand better.

You expand the requirement. "Wait, what if the users do X, W or Z?" You add constraints. You define context. The scope refines. It's not random expansion. It's targeted.

You identify edge cases. "What happens if...?" The AI suggests cases you didn't consider. Your decisions become more robust.

The AI clarifies. It reformulates your assumptions. Brings external context. Questions what you said. You gain new knowledge.

Then you loop back. The answers generate new questions. The scope changes, refines, or confirms itself. The loop continues until you feel clear enough to stop.

Example of the loop:

(Loop continues)

You're not just consuming. You're actually thinking. You're questioning. You're refining. You're making decisions with reasoning behind them.

You know you have enough contraction when you can explain your decisions without doubt. When you've considered at least two alternatives. When you understand the trade-offs. When your scope is defined. When you don't have unanswered questions anymore.

When you have enough clarity, documentation emerges naturally. It's not a template exercise. It's synthesis.

You write it down because you need to. Not because someone told you to.

A product brief captures what this is, why it matters, and for whom. It's the synthesis of all the expansion and contraction you just did.

A roadmap defines phases, priorities, dependencies. It reflects the decisions you made during the loop.

An implementation plan details architecture, components, technical specifics. It's specific because it comes from conscious decisions, not generic suggestions.

This documentation is alive, not frozen. You version changes. You register decisions that happen during implementation. You adjust if context shifts. It serves as a reference for why each decision was made.

You know you documented well when someone without context can read it and understand. When decisions have clear justification. When there's no ambiguity about scope.

User Stories

User stories ground the AI in human narrative. They help the AI understand the "why."

The format is simple: "As [role], I need [action], because [benefit]."

Example: "As a researcher processing movement data, I need to automate dataset normalization so I can save time and reduce manual errors."

In the framework, user stories are your starting point for expansion. They give structure without being overly rigid.

EARS (Easy Approach to Requirement Syntax)

When you have enough clarity to get technical, EARS syntax makes it visible. Not just to the AI, but to yourself.

The structure is: Given [context], When [action], Then [expected result].

Example: "Given a CSV with contacts in mixed formats (uppercase, lowercase, compound names), when I run normalization, then each contact has separate columns (name, lastname) in title case format."

EARS forces precision. You can't be vague. The AI understands exactly what you expect. No assumptions.

Your Own Subprompts

Here's something most people miss: you can codify your own opinions.

When you tell the AI, "When suggesting architectures, prioritize portability, then maintainability, then simplicity, in that order". You're being opinionated in the best way.

It's conscious. It's visible. It's adjustable. It's yours.

This is different from hidden subprompts that tools inject without you knowing. Those limit you. Your own subprompts guide you.

Here's the truth that changes everything: if you master the framework, any tool works.

Lovable, Replit, Figma Make, whatever tool. They all use the same models underneath. The difference isn't the tool. It's how you think.

If you don't have a framework, no tool will save you. You'll generate mediocre outputs with any of them.

If you have a framework, any tool becomes useful. Because you know what you're doing.

The real work is internalizing the framework. Not memorizing steps, but integrating it into how you think.

This framework isn't about design. It's not about code. It's not about research.

It's about structured thinking.

A researcher processing data applies it the same way a designer thinking about user flows applies it. A developer deciding on architecture uses the same process as someone analyzing written content.

Why? Because the framework is about reducing your own bias.

Expansion pulls you out of your bubble. Contraction forces you to justify your thinking. Documentation makes explicit what you assumed.

That works everywhere.

Recognize your own biases. Your domain, experience, and emotions limit what you see. That's not weakness. It's human. The AI can help you see the edges.

Structure before you ask. Don't ask the AI for ideas. Ask it to expand on your structured thinking. "Here's a user story, what am I missing?" That allows useful expansion.

Question with criteria. Don't accept answers without understanding. Ask why. Ask about trade-offs. Ask about alternatives. Question your own assumptions and the AI's too.

Document decisions. Write down why you chose X over Y. Register what you considered and dismissed. This is critical thinking made explicit.

Iterate consciously. It's not about perfection. It's about decisions you can defend. Live documentation lets you adjust when context changes.

Expansion without contraction: You ask for infinite ideas and never decide. Result: paralysis.

Contraction without expansion: You decide quickly without questioning. Result: mediocre solutions.

Documentation without process: You generate documents with no thinking behind them. Result: empty artifacts.

Confusing tool with framework: You think Lovable or Cursor is the framework. Result: tool dependency.

Accepting hidden subprompts: You don't question how the tool modifies your responses. Result: lack of control.

You have enough clarity to document when:

You can explain your decision without doubt. You've considered at least two alternatives. You've identified the main trade-offs. Your scope is defined; what's in, what's out. You have no unanswered questions.

If you're still doubting between options, if you can't justify why you chose this, if there's a trade-off you don't understand, if your scope is vague, or if new questions keep coming up. You need more contraction.

In expansion, the AI is a structured thinking facilitator. It broadens your perspective. It suggests what you didn't see. It asks uncomfortable questions. It brings external context.

In contraction, the AI clarifies trade-offs. It explains why one option versus another. It identifies implications. It questions your assumptions.

In documentation, the AI synthesizes. It organizes your thinking into artifacts. It verifies coherence. It generates variations if needed.

In execution, the AI is the executor. It implements according to spec. You validate the output. You adjust if needed.

The key point: in every phase, YOU decide. The AI expands information. You process it with criteria.

It's not about AI being smarter than you. It's about AI being a tool for clearer thinking.

The AI amplifies. Without critical thinking, it amplifies noise. With critical thinking, it amplifies clarity.

This framework is:

Domain-agnostic. It works anywhere. In research. In design. In development. In analysis.

Portable. Once you internalize it, it's yours. You carry it between tools.

Scalable. It works the same for a small script as for complex architecture.

Verifiable. Your decisions are documented. They're questionable. They're defensible.

The real work isn't learning the steps. The real work is integrating this into how you think.

Once you do, any tool becomes useful. Without it, none of them will.

Most people treat AI like a magic box. You ask it something, it gives you an answer, you use it or you don't.

That's vibe design.

This framework is different. It's about directing the AI with criteria. It's about thinking better, not harder. It's about making decisions you can defend, not decisions you just fell into.

It's about recognizing that the thinking happens inside you. The AI just helps you think more completely.

That's spec design.

And once you understand it, you can apply it anywhere. With any tool. In any domain.

Because the framework is about how you think. Everything else is just scaffolding.