# Scope Containment Prover MCP for AI Agents AI Agent Connect > Scope Containment Prover stops your AI from over-engineering every request. This engine forces your agent to follow YAGNI principles, reject unnecessary features, and define the absolute minimum viable product. It prevents dependency bloat and premature optimization by making the LLM justify every decision before it writes a single line of code. ## Overview - **Category:** reasoning - **Price:** Free - **Endpoint:** https://edge.vinkius.com/vk_preview_xIyXFLpRAGOgmqLP0Tdt7rR41ka6TleZEKIb6bTG/ai-agent-connect - **Tags:** scope, yagni, over-engineering, mvp ## Description When you ask an AI to build a feature, it often over-promises. It might suggest a complex microservices architecture for a simple internal tool or try to bake in features for a million users when you only have ten. This Connector fixes that by acting as a reality check. It forces your agent to think about the actual problem before it starts coding. Instead of letting the AI wander into what if scenarios, it makes the agent prove that a feature is actually necessary. It demands that the agent identifies what it is not building, which is often more important than what it is. It looks at maintenance costs, dependency sprawl, and the actual time it takes to ship. By using this within the Vinkius marketplace, you're essentially giving your agent a project manager who hates waste. It ensures that the code you get is lean, maintainable, and ready to ship today, rather than a bloated prototype that takes months to finish. ## Tools ### validate_scope_containment Forces the agent to justify the core problem, YAGNI requirements, scale, dependencies, maintenance, and MVP status. It provides a structured reflection to catch bloat before any code is written. ## Prompt Examples **Prompt:** ``` I need to build a way for users to upload their profile pictures. ``` **Response:** ``` ### Scope Validation Verdict **Verdict:** PREMATURE_OPTIMIZATION **Reasoning:** You mentioned supporting 4K resolution and custom filters. However, your current user count is low. **Proposed Plan:** * **Core Problem:** User uploads a profile image. * **YAGNI:** Rejecting 4K processing and custom filters for now. * **Optimization:** Build for standard JPG/PNG. Monitor usage before adding heavy processing. * **MVP:** Simple upload button with basic validation. ``` **Prompt:** ``` We need to add a way to filter the list of items by date. ``` **Response:** ``` ### Scope Validation Verdict **Verdict:** SCOPE_CONTAINMENT_PROVEN **Reasoning:** This is a clear, isolated feature that doesn't introduce bloat. **Plan Details:** * **Core Problem:** Filter list by date. * **YAGNI:** No multi-select or date range filters. * **Dependencies:** None (using native JS). * **Maintenance:** Low (single function). * **MVP:** One date filter input. ``` **Prompt:** ``` Let's build a full dashboard for the admin. ``` **Response:** ``` ### Scope Validation Verdict **Verdict:** YAGNI_VIOLATION **Reasoning:** A full dashboard is a wish list, not a single feature. You must explicitly state what you are choosing NOT to build. **Action Required:** * **Identify Core Action:** What is the ONE thing the admin needs to do first? (e.g., View total sales). * **Cut the Rest:** Move 'User Management' and 'Report Generation' to separate sprints. ``` ## Capabilities ### Force YAGNI compliance Makes the agent explicitly list features it is rejecting to keep the project scope tight. ### Block premature optimization Prevents the agent from building for massive scale before the first user arrives. ### Audit dependencies Requires a justification for every library to ensure you don't add weight for problems you can solve in ten lines. ### Map maintenance costs Forces the agent to account for the long-term burden of testing and monitoring new code. ### Isolate the core problem Ensures the agent focuses on one specific user action instead of a vague wish list. ### Validate MVP timelines Checks if the proposed work can actually be finished in a reasonable timeframe. ## Use Cases ### Stopping microservices overkill When the AI tries to build a complex microservices architecture for a simple internal to-do app, this Connector forces it to stick to a single, maintainable service. ### Cutting down feature bloat When a file upload request starts turning into a media library with folders and search, the agent uses validate_scope_containment to cut back to the core CSV import. ### Justifying new libraries When you want to add a new package, this Connector forces the agent to prove it can't be solved in 20 lines of native code first. ### Defining a real MVP When a project scope looks like it will take months to finish, the agent uses the MVP validation to identify what can actually be shipped in two weeks. ## Benefits - Eliminate Scope Creep: Use validate_scope_containment to ensure your agent doesn't turn a simple CSV upload into a full-blown media management system. - Reduce Maintenance Debt: By forcing the agent to map maintenance costs, you avoid shipping code that requires constant patching and monitoring. - Minimize Dependency Bloat: Ensure your project stays lightweight by requiring the agent to justify every npm package or library addition. - Faster Time to Ship: Validating the MVP ensures that your agent focuses on the 2-week tasks instead of 8-week nice-to-haves. - Prevent Premature Optimization: Save weeks of development time by making the agent build for your current user count rather than hypothetical millions. - Clearer Requirements: The core problem isolation forces the agent to define one sentence, one user action, and one outcome. ## How It Works The bottom line is that your agent stops over-engineering and starts shipping functional code faster. 1. Provide a feature request or architecture plan to your agent. 2. The agent runs the validation to check against the 6 core pillars of scope containment. 3. You get a verdict that either approves the scope or demands specific cuts to bloat. ## Frequently Asked Questions **How does the Scope Containment Prover help with my project's scope?** It acts as a gatekeeper that forces your agent to focus on the core problem. It prevents the AI from adding nice-to-have features that bloat your code and delay your launch. **Can I use the Scope Containment Prover to stop my AI from over-engineering?** Yes, that's its primary job. It forces the agent to justify why it's choosing a specific architecture and ensures it's building for your current needs, not hypothetical future ones. **What is YAGNI and how does this Connector use it?** YAGNI stands for You Aren't Gonna Need It. The Connector forces your agent to explicitly list the features it is rejecting to keep the project lean and focused. **Will this help reduce the number of dependencies in my app?** Definitely. The Connector requires the agent to justify every library it wants to add. If it can solve the problem in a few lines of native code, it's forced to do that instead of adding a new package. **How does the Scope Containment Prover handle MVP definitions?** It checks if your proposed MVP can actually be finished in a reasonable timeframe. If the agent's plan looks like it will take months, the Connector flags it as bloated and asks for a smaller scope. **Is the Scope Containment Prover good for early-stage startups?** It's ideal for startups. It helps you stay lean by ensuring you don't spend weeks building features that your first ten users won't actually use. **Does this Connector help with long-term maintenance?** Yes, it forces the agent to calculate the Total Cost of Ownership for every feature, including the burden of testing, documentation, and monitoring. **What does YAGNI mean?** 'You Aren't Gonna Need It'. It's the principle of not building features until you actually need them. **Why force rejection of premature optimization?** Because optimizing for 1M users when you have 10 adds massive complexity that slows down development. **Why map maintenance cost?** Code is a liability, not an asset. Every line written must be read, tested, and updated forever.