# Steve Jobs Vision Prover MCP > Steve Jobs Vision Prover runs your product idea through a rigorous, five-point validation process based on historical design failures. It forces you to define the single core experience, quantify what you killed, and prove end-to-end ownership without using tech jargon. This server rejects pitches that suffer from feature bloat or committee design. ## Overview - **Category:** engineering - **Price:** Free - **Tags:** steve-jobs, product-design, decision-pivots, structured-reasoning, focus, zero-configuration, ux-design ## Description **Steve Jobs Vision Prover - Product Design Validation MCP Server** You run your product idea through a gauntlet when you call `validate_steve_jobs_vision`. This server doesn't just read your pitch; it forces five painful pivots—radical simplification, human experience focus, system autonomy, end-to-end ownership, and bold choice selection—and it rejects anything bloated or safe. You won't get through this thing unless you prove where the product starts and where the user ends. The process begins by forcing you to distill your entire concept down to a single core essence; if you can’t summarize it in one sentence, the server flags that you don't have focus. Next, you gotta quantify subtraction. It demands that you name specific features you cut and prove exactly how removing those things improved the product's function or accuracy. You're not allowed to just say 'we simplified'; you gotta show the math behind it. The server then makes sure your pitch is rooted in the human experience, so you draft a user moment using only plain language—no tech jargon like 'AI,' 'algorithm,' or 'API.' It forces you to describe what the person actually feels when they use it. You also gotta commit to a bold stance; this tool requires you to name the most polarizing design choice—the one that might piss off half your users but defines who the product is, period. When it comes to how the system works under the hood, you'll define its autonomy by explaining how the system makes key decisions for the user without needing them to touch a single setting or configuration menu. You also map out the ownership boundary, which means defining exactly what your product controls from start to finish. This proves there’s no reliance on third-party services or platforms—you own it end-to-end. If you fail any of those points, the server doesn't just warn you; it rejects the submission and coaches you on the exact fix required. It checks your ability to kill more features than you keep, demanding that the pitch starts with the human feeling rather than some ML pipeline. This whole process proves if your idea is actually structurally sound or if it’s just a mess of tech buzzwords. ## Tools ### validate_steve_jobs_vision Runs your product concept through five pivots: radical simplification, human experience focus, system autonomy, end-to-end ownership, and bold choice selection. It rejects designs that are bloated or safe. ## Prompt Examples **Prompt:** ``` We're building an AI travel agent. It has a dashboard where users set their budget, preferred airlines, diet, and seat preferences. We integrate with 15 booking APIs. ``` **Response:** ``` COWARDICE_DESIGN — A dashboard with budget, airlines, diet, and seat preferences is four decisions you pushed to the user. The system should infer the budget from past trips, know the diet from order history, and pick the seat based on sleep patterns. And 15 third-party APIs? You don't own the widget. Fix both before presenting this as a product. ``` **Prompt:** ``` A music app. One feature: play. It learns what you like and plays it. No browse, no search, no playlists. You open it, music starts. We built the entire audio pipeline. ``` **Response:** ``` VISION_PROVEN — Radical simplification: one feature, everything else killed. Experience backwards: 'you open it, music starts' — pure human moment, no tech words. Complexity absorbed: the system decides what to play, no user choices. Whole widget owned: entire audio pipeline built in-house. Bold choice: removing search and playlists — users will hate it until they love it. Ship it. ``` **Prompt:** ``` Our platform uses a proprietary transformer model to create personalized learning paths. We offer a clean and modern interface with customizable dashboards and integrate with all major LMS providers. ``` **Response:** ``` TECH_FIRST — You started with 'proprietary transformer model.' That is your plumbing, not your product. Then 'clean and modern interface' — that describes every app ever made. Then 'customizable dashboards' — cowardice. Then 'integrate with all major LMS' — fragmentation. Three failures in one pitch. Start over: what does the STUDENT feel the moment they open it? ``` ## Capabilities ### Determine Core Essence Forces you to summarize your entire product idea in a single sentence. If it takes more than one sentence, the concept lacks focus. ### Quantify Subtraction Requires naming specific features that were removed and quantifying exactly how that removal improved the product's function or accuracy. ### Focus on Human Experience Drafts a user moment using only plain language, describing what the human feels—avoiding all tech words like 'AI,' 'algorithm,' or 'API.' ### Define System Autonomy Explains how the system makes key decisions for the user without requiring any configuration changes from a settings menu. ### Map Ownership Boundary Defines exactly what the product controls end-to-end, ensuring there is no reliance on third-party platforms or services. ### Commit to a Bold Stance Requires naming the most polarizing design choice—the one that might annoy some users but defines the product's identity. ## Use Cases ### Revising an AI Travel Agent pitch A team pitches an 'AI travel agent' with 15 APIs and a massive dashboard. The agent runs the concept through `validate_steve_jobs_vision`. It immediately flags Configuration Cowardice (too many settings) and Fragmentation (relying on too many third-party booking systems). The fix: simplify to one core experience, like 'The perfect weekend getaway,' owned end-to-end. ### Designing smart luggage A company pitches 'smart luggage' with GPS, fingerprint locks, and power banks. `validate_steve_jobs_vision` forces them to strip away the tech list. The resulting pitch must focus only on the simple act: 'You arrive at the gate; your bag follows you.' Ownership becomes the single shell design. ### Revamping a hospital system A healthcare product relies on patients selecting from 47 room types, creating a complex user flow. The tool flags this as Configuration Cowardice. It forces the solution to be automated: 'The system assigns the optimal room based on medical history and recovery trajectory,' removing all manual choices. ### Concepting a new SaaS platform Instead of describing complex backend models, the user describes the human feeling after using the product—'You open it, music starts.' The tool then verifies this pure moment against the other pivots, confirming if the technical complexity actually supports that singular emotional outcome. ## Benefits - **Avoid Feature Bloat:** The tool forces you to name specific features that must be killed. It moves your thinking from 'what can we add?' to 'what must we cut?' - **Guaranteed Focus:** By requiring a single-sentence product essence, it immediately flags concepts that are too broad or attempt to solve multiple unrelated problems. - **Build Trust Through Ownership:** The Whole Widget Owned pivot forces you to map your core value chain end-to-end. You prove you aren't just renting functionality from platforms like Zapier. - **Write for Humans, Not Engineers:** The Experience Backwards pivot makes you describe the user moment without using a single buzzword—no 'AI,' no 'ML pipeline.' - **Eliminate Cowardice:** By mandating that the system makes decisions (Complexity Absorbed), it forces you to build into optimal defaults rather than leaving settings menus for the user. - **Define Your Point of View:** The Taste Exercised pivot ensures your product has a polarizing, confident stance. If everyone loves it, you failed. ## How It Works The bottom line is that the tool doesn't compute anything; it validates your thinking process. It forces you to prove design maturity, not just list features. 1. State the single, defining essence of your product in one sentence. If you can’t do this, stop. 2. List every feature you cut and explain how that specific removal improved the product (e.g., 'Killed X: system accuracy went from 72% to 94%'). 3. Complete the remaining five pivots by describing the user's emotional moment, defining system choices, mapping ownership, and committing to a bold choice. ## Frequently Asked Questions **What does the validate_steve_jobs_vision server actually check?** It validates five core principles of product design: simplification, human focus, system autonomy, ownership, and bold vision. It flags if your pitch is too complex or lacks a clear point of view. **Can I use validate_steve_jobs_vision for internal process improvements?** No. This tool focuses on external product-market fit and user experience. If you're just optimizing an internal workflow, you need a different type of system validator. **What happens if I fail the validate_steve_jobs_vision check?** The tool rejects your submission and names the exact pivot that failed (e.g., FEATURE_BLOAT, TECH_FIRST). It tells you precisely what contradiction needs to be fixed. **Is this better than using a general LLM for product design?** Yes. A general LLM adds everything; this tool forces subtraction. It requires quantified evidence of removal and proves ownership, which an LLM can't actually verify. **How do I integrate the `validate_steve_jobs_vision` tool into my existing AI client?** You connect it via the Vinkius Marketplace using your preferred AI client (Claude, Cursor, etc.). The MCP standard handles the handshake automatically. Simply authenticate your agent to our service endpoint, and it treats the `validate_steve_jobs_vision` tool like any other external function. **Are there rate limits or performance constraints when calling `validate_steve_jobs_vision`?** Vinkius manages standard API rate limiting based on your subscription tier. We recommend batching your product pitches to avoid hitting concurrent usage caps. The tool itself is computationally lightweight, focusing only on structured reasoning validation. **What format should my input be for the `validate_steve_jobs_vision` check?** You must provide a single block of text describing your product idea. We don't need separate fields; just dump your pitch—the more rambling, the better it tests the tool’s ability to catch bloat and cowardice. **Is my data secure when using the `validate_steve_jobs_vision` server?** Yes, all inputs are handled securely within Vinkius's encrypted environment. We use your pitch purely for validation runs and do not store or train models on your submitted product designs. **Does it generate product designs?** No. It computes nothing and generates nothing. The LLM designs the product — this tool validates that the reasoning behind the design is rigorous. It catches contradictions: if the LLM claims zero configuration but describes a settings panel, the tool rejects and explains why. **What does it catch that a prompt instruction doesn't?** A prompt says 'think like Steve Jobs.' The LLM nods and generates bloated designs anyway. This tool forces the LLM to fill in specific fields — name what it killed, describe the human moment without tech words, explain how the system decides. Tool calls are obligations. Instructions are suggestions. The LLM cannot skip the reflection. **Can I use it for developer tools and APIs, not just consumer products?** Yes. The principles apply universally. A CLI tool with 47 flags is the same failure as a consumer app with a settings menu — you pushed decisions to the user. The 'experience backwards' pivot works for developers too: start with the developer's workflow, not your architecture.