What is Advanced Elicitation?
A structured second pass over LLM-generated content. Instead of asking the AI to “try again” or “make it better,” you select a specific reasoning method and the AI re-examines its own output through that lens. The difference matters. Vague requests produce vague revisions. A named method forces a particular angle of attack, surfacing insights that a generic retry would miss.Advanced elicitation is about structured rethinking, not random iteration. Each method brings a specific analytical framework that reveals different weaknesses and opportunities.
When to Use It
Advanced elicitation works best in these scenarios:- After workflow content generation - A workflow produces output and you want alternatives
- When output seems okay but shallow - The result is acceptable but you suspect there’s more depth
- To stress-test assumptions - Find weaknesses or blind spots in reasoning
- For high-stakes content - Specs, architecture, critical features where rethinking helps
- When stuck on quality plateau - Normal iteration isn’t improving things further
How It Works
The advanced elicitation process follows this flow:1. Content Generation
The LLM produces initial output - a spec section, architecture decision, implementation approach, or other artifact.2. Method Selection
The LLM suggests 5 relevant reasoning methods based on your content type and context. You can:- Pick one - Select the most promising method
- Reshuffle - Get 5 different method options
- Skip - Accept current output and continue
3. Method Application
The selected method is applied systematically to the original output. The LLM works through the reasoning framework, generating insights and alternatives.4. Review Improvements
You see:- Original output
- Method-driven analysis
- Proposed improvements
- Rationale for changes
5. Decision
You choose:- Accept - Keep the improvements, continue workflow
- Discard - Revert to original, continue workflow
- Repeat - Try a different method on the same content
- Iterate - Apply another method to the improved version
Built-in Reasoning Methods
Advanced elicitation includes dozens of reasoning methods. Here are the most powerful:Pre-mortem Analysis
What it does: Assume the project already failed, work backward to find why. Best for: Specs, plans, architecture, any forward-looking artifact. Example:First Principles Thinking
What it does: Strip away assumptions, rebuild from ground truth. Best for: Architectural decisions, complex problem-solving, challenging conventional approaches. Example:Inversion
What it does: Ask how to guarantee failure, then avoid those things. Best for: Finding hidden risks, validating approaches, improving resilience. Example:Red Team vs Blue Team
What it does: Attack your own work (red team), then defend it (blue team). Best for: Security, architecture validation, finding edge cases. Example:Socratic Questioning
What it does: Challenge every claim with “why?” and “how do you know?” Best for: Testing assumptions, validating requirements, finding missing justification. Example:Constraint Removal
What it does: Drop all constraints, see what changes, add them back selectively. Best for: Creative problem-solving, finding innovative approaches, escaping mental ruts. Example:Stakeholder Mapping
What it does: Re-evaluate from each stakeholder’s perspective. Best for: Requirements validation, UX decisions, finding overlooked users. Example:Analogical Reasoning
What it does: Find parallels in other domains and apply their lessons. Best for: Solving novel problems, finding proven patterns, creative approaches. Example:Method Selection Strategy
Different methods excel in different situations:| Content Type | Recommended Methods |
|---|---|
| Requirements/Specs | Pre-mortem, Socratic Questioning, Stakeholder Mapping |
| Architecture | First Principles, Red Team vs Blue Team, Inversion |
| Implementation Plans | Pre-mortem, Constraint Removal, Analogical Reasoning |
| Problem Analysis | First Principles, Five Whys, Systems Thinking |
| Creative Work | Constraint Removal, Analogical Reasoning, SCAMPER |
| Risk Assessment | Pre-mortem, Inversion, Red Team vs Blue Team |
Best Practices
When to Use Advanced Elicitation
Do use it when:- Output seems acceptable but not excellent
- High-stakes content where quality matters
- You’re stuck and need a different perspective
- Initial generation missed obvious angles
- You want to validate assumptions
- Output is clearly wrong (fix the prompt/input instead)
- You’re just fishing for different wording
- Time pressure requires moving forward
- Diminishing returns (you’ve already run 3 methods)
Maximize Value
Pick methods intentionally - Don’t just click the first option. Read the descriptions and choose based on what you’re trying to improve. Apply sequentially, not all at once - One method, review results, decide next step. Multiple methods in sequence build on each other. Accept imperfect improvements - If a method surfaces 3 good insights and 2 weak ones, keep the good and ignore the weak. Know when to stop - First method often gives 70% of value. Second might give 20%. Third gives 10%. Stop when returns diminish.Common Patterns
The Validation Pattern- Generate initial output
- Pre-mortem Analysis (find what could go wrong)
- Address critical gaps
- Socratic Questioning (validate assumptions)
- Accept or iterate
- Generate initial output
- Constraint Removal (think freely)
- Analogical Reasoning (borrow from other domains)
- First Principles (validate novelty isn’t just complexity)
- Accept refined approach
- Generate initial output
- Red Team vs Blue Team (find vulnerabilities)
- Address security gaps
- Inversion (how would we guarantee breach?)
- Accept hardened version
Integration with Workflows
Advanced elicitation appears at key decision points:In prd-co-write
After generating each section:
In plan-build
After architecture decisions:
In implement
After generating implementation approach:
Measuring Success
How do you know advanced elicitation worked? Good outcomes:- Found gaps you genuinely didn’t notice
- Simplified overly complex approaches
- Added missing resilience or validation
- Challenged and validated assumptions
- Generated actionable improvements
- Changes are just rewording
- Adds complexity without clear benefit
- Insights you already knew
- Taking too long relative to value
- Going in circles with multiple methods
Real-World Example
Here’s advanced elicitation applied to a feature spec: Original Output:Users can export their data as CSV or JSON files. Click the export button, choose format, download begins.Pre-mortem Analysis Applied:
It’s 3 months later. Export feature is broken and users are angry. What went wrong?Improved Output:
- Large datasets timeout before export completes
- Export format doesn’t include relationships/nested data
- No way to export subset of data (all or nothing)
- Users don’t know export is processing (looks frozen)
- Failed exports leave no error message
- No way to re-download previous exports
Users can export their data with the following capabilities: Export Scope:One method application transformed a basic feature into a production-ready spec. Advanced elicitation isn’t about endless iteration. It’s about applying the right analytical lens at the right time to surface insights that normal thinking misses.Export Formats:
- Full data export
- Date range selection
- Filtered subset based on tags/categories
Export Process:
- CSV (flattened data)
- JSON (preserves nested structure)
- Excel (multiple sheets for relationships)
Export History:
- Async processing for large datasets (>1000 records)
- Progress indicator showing % complete
- Email notification when export ready
- Download link valid for 7 days
- Error messages with specific failure reason
- List of previous exports with re-download capability
- Retention: 30 days
- Shows: Date, format, scope, file size