> This page is for version v8.3.0 (default). > For other versions, use one of these documentation indexes: > - v8.3.0 (default): https://docs.workflows.com/v-8-3-0/llms.txt > For clean Markdown of any page, append .md to the page URL. > For a complete documentation index, see https://docs.workflows.com/llms.txt. > For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.workflows.com/_mcp/server. # Validate Features & Designs ![Mind Reasoner](/_fern-img/466e07efd0202b28f29ec8dda3be88918c85104c2652efceb8ff717127f861ca.webp) > **Stop Building. Start Validating.** > > **The shift:** Create user minds. Ask them any question. Know how they'll respond before you build anything. > > **Result:** Ship features users actually want. Avoid costly mistakes. Accelerate product-market fit. --- ## What You Can Predict #### Feature Validation **Know before building:** * Will they actually use this? * Does it solve their real problem? * What concerns will they raise? * Which use cases matter most? Test features with user minds. #### Design Decisions **Validate design choices:** * Which design will they prefer? * What will confuse them? * Where will they get stuck? * What will delight vs. frustrate? Test designs before implementing. #### User Needs **Uncover hidden needs:** * What do they actually need (vs. request)? * What pain points aren't they mentioning? * Which problems are most urgent? * What would make them switch? Ask the right questions. #### Adoption Barriers **Identify blockers early:** * What will prevent them from adopting? * Which concerns will they raise? * What proof do they need? * What makes them hesitate? Address barriers before launch. --- ## How to Predict ### 1. Create User Minds Upload transcripts from user research: user interviews, customer support calls, feedback sessions, onboarding calls **Training:** 5-15 minutes per user or segment ### 2. Ask Any Question **Validate features:** ```bash > "SCENARIO: A product team is proposing to you (as Enterprise Customer) that they build a bulk export feature. They're asking for your feedback before prioritizing it in their roadmap. QUESTION: Would you actually use this feature? How important is it to you? What would make you adopt it vs. ignore it?" ``` **Test designs:** ```bash > "SCENARIO: The design team is presenting you with 3 navigation options for the new dashboard redesign. They want to understand which you prefer before implementing. QUESTION: Which design would you choose? What concerns would each option raise for you? What would make you frustrated vs. delighted?" ``` **Uncover needs:** ```bash > "SCENARIO: Your product team is planning next quarter's roadmap. They're asking you directly what's preventing you from getting more value from the product. QUESTION: What's your biggest frustration that you haven't mentioned yet? What would make you consider switching to a competitor?" ``` ### 3. Build with Confidence Get predictions. Validate decisions. Ship the right features. **You'll know:** What users will say, what they need (not just want), what will drive adoption --- ## Real Examples #### Validate Feature ### Before Building **You ask user mind:** ```bash > "SCENARIO: A product team is proposing to you (as Enterprise Customer) that they build a bulk export feature for CSV/Excel. They're asking for your feedback before prioritizing it in their Q2 roadmap. This would be a paid Enterprise-tier feature. QUESTION: Would you actually use this feature? How important is it to you? What would make you adopt it vs. ignore it?" ``` **User mind predicts:** ``` YES. This is my #1 requested feature. Why it's critical for me: - I manually export 20+ reports every week - It takes 3-4 hours of my time weekly - Current export is slow and limited to 100 rows - I need to export filtered views, not just all data This would save me 15+ hours per month. I'd use it daily. Requirements for me: - CSV and Excel formats (Excel preferred) - Export filtered views, not just raw data - Ability to schedule automated exports - No row limits (I need to export 10K+ rows) Without bulk export, I'm constantly frustrated with your product. This feature would make me a champion user. ``` ### Validate with More Users **You ask another user mind:** ```bash > "SCENARIO: A product team is proposing to you (as SMB Customer) that they build a bulk export feature for CSV/Excel. They're asking for your feedback before prioritizing it in their Q2 roadmap. This would be a paid Enterprise-tier feature. QUESTION: Would you actually use this feature? How important is it to you? What would make you adopt it vs. ignore it?" ``` **Second user mind reveals:** ``` I wouldn't use it. Why: - I only export 1-2 reports per month - Current manual export is fine for my use case - I prefer to work within the product, not in Excel This doesn't solve any pain point for me. I wouldn't pay extra for it. What I actually need instead: - Better filtering within the product - Saved views I can quickly access - Shareable dashboards with my team ``` ### Decision Made **Result:** * High-volume users (enterprise) desperately need bulk export * Low-volume users (SMB) don't care about bulk export * Build bulk export for Enterprise tier * Focus on in-app improvements for SMB tier **Outcome:** Right feature for the right segment. No wasted engineering time. #### Test Design ### Before Implementation **You ask user mind:** ```bash > "SCENARIO: The design team is presenting you with 3 navigation design options for the dashboard redesign. They need to finalize the design by end of week and want your input before implementation. Option A: Top horizontal nav Option B: Left sidebar with icons only Option C: Collapsible left sidebar with labels QUESTION: Which design would you choose? What concerns would each option raise for you? What would make you frustrated vs. delighted with each?" ``` **User mind predicts:** ``` Option C: Collapsible left sidebar with labels Why this works for me: - I have 20+ sections I need to access - Top nav (Option A) would be cluttered and hard to scan - Icon-only sidebar (Option B) = I'd have to memorize icons - Collapsible with labels = best of both worlds Concerns with each: Option A (Top nav): ✗ Can't fit all my sections ✗ Would require dropdowns = extra clicks ✗ Hard to scan quickly Option B (Icon sidebar): ✗ I don't want to memorize 20+ icons ✗ Would slow me down every time ✗ Tooltips on hover = friction Option C (Collapsible sidebar): ✓ Labels visible when expanded ✓ Can collapse when I need screen space ✓ Easy to scan all sections ✓ Supports 20+ items without clutter Option C is the clear winner for my usage pattern. ``` ### Test Edge Cases **You ask:** ```bash > "SCENARIO: The design team is asking you to imagine using Option C (collapsible sidebar) in your daily workflow. They want to understand your actual usage pattern. QUESTION: With the sidebar collapsed, would you remember where things are? Or would you keep it expanded most of the time? What would determine your preference?" ``` **User mind reveals:** ``` I'd keep it expanded 90% of the time. Why: - I jump between 8-10 sections constantly throughout the day - I need to see section names to navigate quickly - I'd only collapse when sharing my screen or focusing on one view Make expanded the default state. And remember my preference (expanded vs collapsed) so I don't have to reset it. ``` ### Design Decision **Result:** * Build Option C: Collapsible sidebar with labels * Default to expanded state * Remember user's collapse preference * Support 20+ navigation items **Outcome:** Design validated before implementation. No redesign needed post-launch. #### Uncover Needs ### Before Product Planning **You ask user mind:** ```bash > "SCENARIO: The product leadership team is asking you directly (as Enterprise Customer) for honest feedback to shape the next 6-month roadmap. They want to understand what's really preventing you from getting more value from the product, even if you haven't complained about it before. QUESTION: What's your biggest frustration with our product right now that you haven't explicitly mentioned? What would make you consider switching to a competitor?" ``` **User mind reveals (things they never told you):** ``` My hidden frustrations (that I haven't mentioned): 1. Report Generation is Painfully Slow What's happening: Reports take 30-45 seconds to load Real impact: I waste 15+ minutes daily waiting Why I haven't complained: Assumed you can't fix it Switching threshold: If competitor is significantly faster 2. Mobile App is Broken What's happening: Mobile app crashes when offline Real impact: Can't access data during client meetings Why I haven't complained: Figured you knew Switching threshold: If I have one more embarrassing moment 3. Onboarding New Team Members is a Nightmare What's happening: Takes 2-3 weeks to get someone productive Real impact: Team growth is bottlenecked Why I haven't complained: Thought it was just us Switching threshold: Next time we hire What I request vs. what I need: - I request: More chart types - I actually need: Faster reports + reliable mobile + easier onboarding If you fix the real problems, I'm a customer for life. If you add more chart types, I still might leave. ``` ### Validate with More Users **You discover:** * 8 out of 10 enterprise user minds mention report speed * 6 out of 10 mention mobile reliability issues * 5 out of 10 mention onboarding difficulty * Only 2 out of 10 care about more chart types ### Product Roadmap Decision **Result:** * Q1: Fix report performance (affects 80% of enterprise users) * Q2: Rebuild mobile offline support (affects 60% of users) * Q3: Create guided onboarding (affects 50% of teams) * Backlog: More chart types (low priority) **Outcome:** Build what users actually need, not what they request. Reduce churn. Increase satisfaction. #### Identify Adoption Barriers ### Before Launch **You ask user mind:** ```bash > "SCENARIO: The product team is preparing to launch a new collaboration feature next month. They're asking you (as Team Lead) for feedback on potential adoption barriers before they finalize the launch plan and training materials. QUESTION: What concerns would you have about adopting this new collaboration feature with your team? What would prevent you from using it? What would make you adopt it enthusiastically vs. ignore the launch?" ``` **User mind predicts:** ``` Concerns that would prevent me from adopting: 1. Data Access Control My worry: Who can see what? Why it matters: We have sensitive client data What I need: Granular permissions by project/client Without this: I won't enable collaboration 2. Notification Overload My worry: Will I get spammed with notifications? Why it matters: I already ignore 90% of app notifications What I need: Smart defaults + easy opt-out Without this: I'll turn off all notifications day 1 3. Learning Curve for My Team My worry: Another tool for my team to learn Why it matters: Team is change-fatigued What I need: Works like Slack/familiar patterns Without this: Team won't adopt it 4. Migration from Current Process My worry: We have 2 years of notes in our current system Why it matters: Can't start from scratch What I need: Import from Google Docs/Notion Without this: Can't migrate our workflow If you address #1 and #4, I'll try it. If you address all 4, I'll champion it to my team. ``` ### Test Solutions **You ask:** ```bash > "SCENARIO: The product team is proposing to you specific features to address your concerns before the collaboration feature launches. They want to know if these changes would make you adopt it. Proposed features: 1. Project-level permissions (control who sees what) 2. Default notifications to @mentions only 3. Slack-style keyboard shortcuts 4. Google Docs import tool QUESTION: Would these features address your concerns? What would make you adopt the collaboration feature with these in place vs. still ignore it?" ``` **User mind confirms:** ``` YES. This addresses all my concerns. What changes my decision: - Project permissions = I feel safe enabling it - @mentions only = I won't be overwhelmed - Slack-style = My team already knows these patterns - Google Docs import = We can migrate existing work With these in place, I'd: - Enable it for my team immediately - Migrate our current docs in first week - Recommend it to other teams in my company Without these, I'd probably ignore the feature launch. ``` ### Launch Strategy **Result:** * Build project-level permissions before launch * Default to @mentions only (not all activity) * Use Slack keyboard shortcuts (familiar patterns) * Include Google Docs import in v1 **Outcome:** Address adoption barriers before launch. Drive 3x higher adoption rate. --- ## Common Scenarios **Feature Prioritization**: Predict which features users will actually use, what's must-have vs. nice-to-have, which features drive upgrades. Build the right features in the right order, maximize engineering ROI. **Design Validation**: Predict which design users prefer, what will confuse them, where they'll get stuck. Avoid expensive redesigns and improve UX before launch. **Pricing Research**: Predict willingness to pay, which tier they'd choose, what features drive upgrades. Optimize pricing and packaging for maximum revenue. **User Segmentation**: Predict how different segments respond, what Enterprise needs vs. SMB, which features matter to each. Serve each segment better with targeted product development. **Competitive Analysis**: Predict what would make users switch to competitors, which competitive features they care about, where you're truly differentiated. Defend against churn with the right feature investments. **Onboarding Optimization**: Predict where new users will get stuck, what will confuse them, which features they should discover first. Increase activation rates with validated onboarding. --- ## Implementation #### MCP (No Code) **Use Mind Reasoner through Claude Code** No coding. Just natural conversation in Claude. **You:** ```bash > Create user minds for our enterprise segment using these interviews: > /Documents/research/enterprise-user-1.vtt > /Documents/research/enterprise-user-2.vtt > /Documents/research/enterprise-user-3.vtt ``` **Mind Reasoner:** ``` ✓ Training 3 enterprise user minds... (~10 min each) ``` **You:** ```bash > Ask each user mind: > "SCENARIO: The product team is proposing to you that they build a bulk > export feature for Q2 roadmap. They're asking for your feedback before > prioritizing it. > > QUESTION: Would you actually use this feature? How important is it to you? > What would make you adopt it vs. ignore it?" ``` **Mind Reasoner:** ``` User 1 (Sarah - Enterprise Admin): YES. Critical. Exports 20+ reports weekly, wastes 3-4 hours. Would upgrade to Enterprise tier for this feature. User 2 (Mike - Enterprise Analyst): YES. Very important. Needs automated scheduled exports. Current manual process is painful. User 3 (Lisa - Enterprise Manager): NO. Rarely exports. Prefers in-app analytics. This doesn't solve any problem for her. Summary: 2 out of 3 enterprise users need this badly. Build for Enterprise tier. High-value feature. ``` **You:** ```bash > Ask Sarah and Mike: > "SCENARIO: We're about to build bulk export based on your feedback. > Before we start development, we want to understand your specific > requirements to ensure we build something you'll actually use. > > QUESTION: What are your must-have requirements for this feature? > What would make you not use it even if we build it? What would make > you adopt it enthusiastically vs. be disappointed?" ``` **Mind Reasoner:** ``` Sarah's requirements: - CSV and Excel formats - Export filtered views (not just all data) - No row limits (needs 10K+ rows) - Fast export generation (<5 seconds) Adoption blockers: - If limited to 1000 rows: won't use it - If can't export filtered views: too limiting Mike's requirements: - Scheduled automated exports - Email delivery or cloud storage integration - Multiple export templates - API access for programmatic exports Adoption blockers: - If no scheduling: doesn't solve his problem - If manual only: defeats the purpose Both need: unlimited rows, filtered exports Mike needs: automation/scheduling Sarah needs: speed + format flexibility ``` [MCP Tools Reference →](/mcp-tools) #### Direct API **Build user prediction into your workflow** ```javascript const API_BASE = 'https://api.reasoner.com/api/mindsim'; // Create user minds for each segment // (See API Quick Start for full workflow) // Validate feature with multiple user minds const userMinds = [ { name: 'Sarah', mindId: 'mind_123' }, { name: 'Mike', mindId: 'mind_456' }, { name: 'Lisa', mindId: 'mind_789' } ]; const validations = await Promise.all( userMinds.map(async ({ name, mindId }) => { const response = await fetch(`${API_BASE}/simulate`, { method: 'POST', headers: { 'Authorization': `Bearer ${API_KEY}`, 'Content-Type': 'application/json' }, body: JSON.stringify({ mindId, scenario: { message: "SCENARIO: The product team is proposing to you that they build a bulk export feature for Q2 roadmap. They're asking for your feedback before prioritizing it.\n\nQUESTION: Would you actually use this feature? How important is it to you? What would make you adopt it vs. ignore it?" } }) }).then(r => r.json()); return { name, response: response.message }; }) ); console.log('Feature validation across users:', validations); // Analyze patterns across user segments const adoptionRate = validations.filter(v => v.response.includes('YES') || v.response.includes('would use') ).length / validations.length; console.log(`Predicted adoption rate: ${adoptionRate * 100}%`); ``` [API Documentation →](/api-quick-start) --- ## Next Steps #### [Align Stakeholders & Launch](/workflow-product-align-stakeholders) Navigate stakeholder approvals and optimize product decisions #### [MCP Quick Start](/mcp-quickstart) Set up in 5 minutes #### [API Quick Start](/api-quick-start) Build into your product workflow > **Info** > > Questions? Email [support@reasoner.com](mailto:support@reasoner.com)