Framework: From Vibe Design to Spec Design
A structured process for working with AI
Introduction
This framework describes how to work with AI models in a structured way to generate thoughtful solutions, instead of magical outputs without criteria.
The framework is domain-agnostic (works for research, development, design, data analysis) and tool-agnostic (works in Claude directly, Lovable, Cursor, any medium). What matters is not where you work, but how you think.
Core Concepts
Vibe Design vs Spec Design
Vibe Design
- Asking AI to generate massive ideas without structure
- Result: 20 options, paralysis, feeling like "the AI decided"
- Characteristic: reactive, no criteria
Spec Design
- Structure the problem before asking, document afterward
- Result: specific solutions, clear decisions, sense of control
- Characteristic: intentional, human criteria
The Role of Critical Thinking
Critical thinking is not about rejecting AI. It's about directing it.
Without critical thinking: everything is magic.
With critical thinking: everything is process.
The Framework: Three Phases
Phase 1: Expansion
Objective: Discover what you don't know you don't know.
How it works:
- Start with a user story or EARS requirement (not a vague question)
- AI expands: suggests components, architecture, technologies, implications
- You receive information you hadn't considered
- Your understanding of the problem grows
Example:
- You: "I need to normalize spreadsheet contacts: separate first/last name, apply title case"
- AI: "What about compound names? Prefixes? How to handle special characters? Could you have duplicate data?"
- You: "Ah, I hadn't considered that"
Sign you need more expansion:
- There are still unanswered questions
- AI suggests things I don't understand
- I'm not sure if my initial solution is correct
Phase 2: Contraction (The Iterative Loop)
Objective: Make conscious decisions, not magical ones.
It's not linear. It's a loop where each iteration brings you closer to clarity:
- Ask for clarity
- "Why this architecture versus that one?"
- "What are the trade-offs?"
- Result: You understand better
- Expand the requirement
- Include new constraints
- Define additional context
- "What if users do this?"
- Result: The scope is refined
- Identify edge cases
- Ask "what if...?" questions
- AI suggests cases you didn't see
- Result: More robust decisions
- AI clarifies
- Reformulates, defends, or questions your assumptions
- Brings external context (research, documentation, patterns)
- Result: New knowledge
- Return to step 1
- Answers generate new questions
- Scope can change, refine, or be confirmed
- Loop continues until sufficient clarity
Loop example:
- You: "I need a CLI tool to normalize contacts"
- AI: "CLI versus web? They have different implications"
- You: "Hmm, I hadn't thought about that. What are they?"
- AI: "CLI is more portable, web is more accessible for non-technical users"
- You: "Ah, that changes everything. I'll need a web app then"
- AI: "Then you need this, this, and this..."
- You: "What if I do this differently?"
- (Loop continues)
Signs you're in contraction:
- You ask specific questions, not general ones
- AI makes you think differently
- You discover you were missing information
- Scope is refined, not expanded
Sign you need more contraction:
- There are still decisions to be made
- I'm not sure why I would choose X over Y
- There are trade-offs I haven't considered
Phase 3: Documentation
Objective: Transform conversation into action.
When to document:
When you have sufficient clarity. This is a "feel", not a checklist:
- I've covered most use cases
- I've identified the main trade-offs
- Decisions have justification
- Scope is closed
What to document:
The artifacts that emerge are synthesis of thought, not templates:
- Product Brief
- What it is, why, for whom
- Synthesis of expansion + contraction
- Roadmap
- Phases, priorities, dependencies
- Reflects decisions made in the loop
- Implementation Plan
- Architecture, components, technical details
- Specific because it comes from conscious decisions
Important: This documentation is living, not frozen:
- Version changes (changelog)
- Record decisions during implementation
- Adjust if context changes
- Serves as reference for why each decision was made
Sign you documented well:
- Someone without context can read and understand
- Decisions have clear justification
- There's no ambiguity about scope
Tools and Artifacts Within the Framework
User Stories
Purpose: User narrative + need.
Basic format: "As a [role], I need [action], to [benefit]"
In the framework:
- Used as starting point for expansion
- Allows AI to understand the human "why"
- Can be combined with EARS for more precision
Example: "As a researcher processing movement data, I need to automate dataset normalization, to save time and reduce manual errors"
EARS (Easy Approach to Requirement Syntax)
Purpose: Clear technical specification.
Structure:
- Given [context]
- When [action]
- Then [expected result]
In the framework:
- Used when there's sufficient clarity to specify technically
- Allows AI to understand the "what" without ambiguity
- Makes exactly what is expected visible
Example: "Given a CSV with contacts in mixed formats (uppercase, lowercase, compound names), when I run normalization, then each contact has separate columns (first name, last name) with title case format"
Custom Subprompts
Purpose: Codified opinions that you control.
Concept: "Opinionated" in a good sense.
In the framework:
- You define the opinion (structure, constraints, preferences)
- This is conscious, visible, adjustable
- Different from hidden tool subprompts
Example: "When suggesting architectures, consider first: portability, maintainability, simplicity. In that order."
Opinionated versus Unopinionated Tools
Opinionated
Define how you work:
- Lovable: "Answer these 5 questions, then we implement"
- Plan Mode: Predefined structure
- Hidden subprompts: Codified opinions you don't control
When they're useful:
- For someone without an internalized framework
- For rapid prototyping where decision quality doesn't matter
Limitation:
- They restrict if you have your own criteria
Unopinionated
Give you tools, you decide:
- Claude directly in chat
- IDE + Claude Code
- Any medium where you control the conversation
Advantage:
- The opinion is yours
- Flexible to your framework
- Portable between tools
For this framework: Unopinionated is preferable because you control each decision.
Key Difference: Framework versus Tool
Fundamental Truth
If you master the framework, any tool works.
- Lovable, Cursor, Claude directly, Figma plugin: all use the same model
- The difference is in how you think, not where you write
- The framework is agnostic
Implication
- If you don't have a framework, no tool will save you
- If you have a framework, any tool is useful
- The real work is in internalizing the framework
Domain-Agnostic Applicability
The framework works in any context because it's not about design, nor code, nor research.
It's about structured thinking.
Application Examples
Data Research
- User story: I need to process movement datasets
- Expansion: what formats? what validations? what output?
- Contraction: trade-offs between speed versus accuracy
- Documentation: algorithm specification, validation plan
Product Design
- User story: I need an accessible onboarding flow
- Expansion: what user types? what devices? what existing data?
- Contraction: trade-offs between speed versus features
- Documentation: product brief, wireframes, specification
Feature Development
- EARS: given this context, when the user does this, then this happens
- Expansion: what edge cases? what performance? what scalability?
- Contraction: technical trade-offs
- Documentation: technical plan, architecture
Why It Works Everywhere
Because the framework is about reducing your own bias:
- Expansion gets you out of your bubble
- Contraction forces you to justify
- Documentation makes explicit what you thought
That applies in any domain.
How to Internalize the Framework
Step 1: Recognize You Have Biases
- Your domain, experience, and emotions limit what you see
- It's not a weakness, it's a human characteristic
- AI can help you see them
Step 2: Structure Before Asking
- Don't: "give me ideas"
- Do: "Here's a user story, what am I missing"
- Structure enables useful expansion
Step 3: Ask With Criteria
- Don't accept answers without understanding
- Ask why, trade-offs, alternatives
- Question assumptions (yours and AI's)
Step 4: Document Decisions
- Write why you chose X over Y
- Record what you considered and discarded
- This is explicit critical thinking
Step 5: Iterate Consciously
- It's not about perfection
- It's about conscious decisions
- Living documentation allows you to adjust
Antipatterns
Antipattern 1: Expansion without Contraction
- You ask for infinite ideas, never decide
- Result: paralysis
Antipattern 2: Contraction without Expansion
- You decide quickly without questioning yourself
- Result: mediocre solutions
Antipattern 3: Documentation without Process
- You generate documents without thought behind them
- Result: empty artifacts
Antipattern 4: Confusing Tool with Framework
- Thinking that Lovable/Cursor = the framework
- Result: tool dependency
Antipattern 5: Accepting Hidden Subprompts
- You don't question how the tool modifies your responses
- Result: lack of control
Clarity Metrics
How do you know you have sufficient clarity to document?
Positive Signs:
- I can explain the decision without doubt
- I've considered at least 2 alternatives
- I identified the main trade-offs
- Scope is defined (what's in, what's out)
- I have no unanswered questions
Negative Signs:
- I'm still doubting between options
- I can't justify why I chose this
- There's a trade-off I don't understand
- Scope is vague
- New questions constantly arise
If negative signs predominate, you need more contraction.
The Role of AI in Each Phase
Expansion
AI as sparring partner that broadens perspective
- Suggests what you didn't see
- Poses uncomfortable questions
- Brings external context
Contraction
AI as trade-off clarifier
- Explains why one option versus another
- Identifies implications
- Questions your assumptions
Documentation
AI as synthesizer
- Organizes thought into artifacts
- Verifies coherence
- Generates variants if needed
Execution
AI as validated executor
- Implements according to specification
- You validate output
- Adjust if necessary
Key point: In each phase, YOU decide. AI expands information. You process it with criteria.
Conclusion
This framework is not about AI. It's about how you think.
AI is an amplifier. Without critical thinking, it amplifies noise. With critical thinking, it amplifies clarity.
The framework is:
- Agnostic: works in any domain, any tool
- Portable: once internalized, it's yours
- Scalable: applies equally to a small script or complex architecture
- Verifiable: decisions are documented, questionable
What matters is internalizing the process, not memorizing steps.
Once you integrate it into how you think, any tool is useful. Without it, none are.