The TDVC Pattern: Discovery Through Structured Dialogue
Part 2 of the Test-Driven Vibe Coding series
The key insight behind Test-Driven Vibe Coding lies in treating AI as a sophisticated interviewing partner rather than a code generation service. This approach transforms the traditional requirement-gathering phase from a solitary exercise into a structured dialogue that systematically exposes assumptions, identifies edge cases, and builds comprehensive understanding before a single line of code is written.
The Discovery Pattern
Most AI-assisted development failures begin with insufficient discovery. Developers, eager to leverage AI's code generation capabilities, skip the crucial phase of requirement crystallization. The Discovery Pattern addresses this by establishing a systematic approach to AI-assisted requirement elicitation.
Pattern Structure
Intent: Use AI's conversational capabilities to systematically explore and document requirements through structured interviews.
Participants:
- Human developer (domain expert, architectural decision-maker)
- AI assistant (interviewer, requirement synthesizer)
Collaboration Model: The human provides business context and constraints; the AI conducts systematic questioning to expose gaps and inconsistencies.
Product Discovery Dialogue
The first phase focuses on business context and user requirements. The AI assumes the role of an experienced product manager, systematically exploring the problem space.
Implementation Template
I need to build a [project type] but require systematic requirement exploration.
Act as a senior product manager and interview me to understand:
1. The core problem and its business context
2. Target user personas and their specific needs
3. Success metrics and acceptance criteria
4. Business constraints and priorities
Conduct this as a structured interview—ask one focused question at a time,
probe for specifics, and challenge assumptions where appropriate.
Structured Dialogue Example
AI: What specific problem are you solving, and what evidence do you have that this problem exists?
Human: I want to build a fitness tracking app focused on consistency rather than performance metrics.
AI: Interesting distinction. Can you quantify the consistency problem? What data suggests current solutions fail at consistency specifically?
Human: Personal experience—I've tried five different apps and always quit after 2-3 weeks when progress slows.
AI: That's valuable insight. Have you validated this beyond personal experience? What would constitute evidence that others share this pattern?
This dialogue structure forces explicit articulation of assumptions and drives toward measurable, testable requirements.
Technical Architecture Discovery
The second phase shifts focus to technical constraints and architectural decisions. The AI assumes the role of a senior architect, systematically exploring technical requirements.
Implementation Template
Now conduct a technical architecture interview to understand:
1. Performance and scalability requirements
2. Integration constraints and dependencies
3. Budget and timeline limitations
4. Technology stack preferences and rationale
5. Deployment and operational requirements
Challenge my assumptions about technical choices and suggest alternatives
where my reasoning appears insufficient.
Structured Technical Dialogue
AI: What are your specific scalability requirements? How many concurrent users, what response times, what data volumes?
Human: Maybe 1,000 users initially, but I hope to reach 50,000 within three years.
AI: That's significant growth. Are you prepared for 50x scaling, or would you prefer to optimize for current needs and refactor later? What's your budget for infrastructure at both scales?
Human: Budget is tight—under $200/month initially.
AI: Given that constraint, serverless architecture seems appropriate for the initial scale. However, your real-time notification requirements complicate serverless approaches. Which is more critical—cost optimization or real-time features?
This dialogue exposes trade-offs and forces explicit prioritization of conflicting requirements.
Requirement Synthesis and Validation
After conducting discovery dialogues, the AI synthesizes findings into structured documentation. This phase transforms conversational insights into formal requirements.
Synthesis Template
Based on our discovery interviews, synthesize the following:
1. Comprehensive user stories with acceptance criteria
2. Technical requirements with priority rankings
3. Identified assumptions that require validation
4. Architecture decisions with documented rationale
5. Success metrics and measurement approaches
Highlight any gaps or inconsistencies in the requirements.
Quality Gates for Discovery
The Discovery Pattern includes validation checkpoints to ensure requirement quality:
Completeness Check: Can a developer unfamiliar with the project understand the requirements?
Consistency Check: Do technical decisions align with business priorities?
Testability Check: Can each requirement be validated through specific tests?
Feasibility Check: Are technical requirements achievable within stated constraints?
Advanced Discovery Techniques
Assumption Mapping
The AI can systematically identify and categorize assumptions:
Review our requirements and identify assumptions in these categories:
1. User behavior assumptions
2. Technical feasibility assumptions
3. Business model assumptions
4. Market assumptions
For each assumption, suggest specific validation approaches.
Edge Case Exploration
AI excels at systematic edge case identification:
For each major user story, identify potential edge cases:
1. Data validation failures
2. Network connectivity issues
3. Concurrent user scenarios
4. Integration failures
5. Performance degradation scenarios
Prioritize these based on likelihood and impact.
Constraint Analysis
The AI can explore constraint interactions:
Analyze how these constraints interact:
- Budget limitation: $200/month
- Performance requirement: <2 second response time
- Scalability target: 50,000 users
- Real-time feature needs
Identify constraint conflicts and suggest resolution strategies.
Implementation Guidelines
Dialogue Structure Best Practices
Single Question Focus: Each AI prompt should address one specific area to maintain focused discussion.
Progressive Depth: Begin with broad questions, then drill down into specifics.
Assumption Challenges: Explicitly request that AI challenge assumptions and suggest alternatives.
Documentation Integration: Regularly synthesize dialogue outcomes into structured documentation.
Common Discovery Pitfalls
Premature Solution Focus: Avoid jumping to technical solutions before thoroughly understanding problems.
Insufficient Validation: Don't accept requirements without exploring evidence and assumptions.
Constraint Avoidance: Address difficult constraints early rather than deferring them.
Documentation Neglect: Ensure dialogue outcomes are captured in structured formats.
Measuring Discovery Quality
Effective discovery should produce:
- Requirements that can be implemented without additional clarification
- Technical decisions with documented rationale
- Identified assumptions with validation strategies
- Clear prioritization of conflicting requirements
- Measurable success criteria
Transition to Implementation
The Discovery Pattern sets the foundation for disciplined implementation. Part 3 of this series explores how these well-defined requirements translate into sustainable production code through systematic testing and development patterns.
The goal of structured discovery is not to eliminate uncertainty—that's impossible in software development. Instead, it's to make uncertainty explicit, manageable, and addressable through systematic validation.
This is Part 2 of the Test-Driven Vibe Coding series. Part 3 will explore production patterns for implementing the requirements discovered through structured dialogue.