Deployment Advisor

File Storage

Background Jobs

Decision Flowchart

digraph deployment_advisor {
    rankdir=TB;
    node [shape=box, style=filled];

    start [label="Infrastructure Decision\nNeeded", fillcolor=lightyellow, shape=doublecircle];
    inventory [label="Step 1: Assess Project Needs\nClassify as REQUIRED NOW\nREQUIRED SOON / NICE TO HAVE", fillcolor="#e3f2fd"];
    env_check [label="Step 2: System Inventory\nInvoke environment-awareness\nCheck installed tools + services", fillcolor="#e3f2fd"];
    already_have [label="Does the user already\nhave a suitable tool?", fillcolor="#fff3e0", shape=diamond];
    use_existing [label="Recommend existing tool\nExplain how it fits", fillcolor="#e8f5e9"];
    evaluate [label="Step 3: Evaluate Options\nCompare cost, complexity,\nfit for project size", fillcolor="#e3f2fd"];
    simple_check [label="Is the simplest option\nsufficient?", fillcolor="#fff3e0", shape=diamond];
    recommend_simple [label="Recommend simplest option\nNote when to upgrade", fillcolor="#e8f5e9"];
    recommend_scaled [label="Recommend scaled option\nExplain why simple\nis not enough", fillcolor="#e8f5e9"];
    present [label="Step 4: Present Recommendation\n+ Alternative\nwith honest trade-offs", fillcolor="#e8f5e9", shape=doublecircle];

    start -> inventory;
    inventory -> env_check;
    env_check -> already_have;
    already_have -> use_existing [label="yes"];
    already_have -> evaluate [label="no"];
    use_existing -> present;
    evaluate -> simple_check;
    simple_check -> recommend_simple [label="yes"];
    simple_check -> recommend_scaled [label="no"];
    recommend_simple -> present;
    recommend_scaled -> present;
}

MCP Integration Assessment

When evaluating a project's stack, also consider whether AI integration would add genuine value. This is not about adding AI for its own sake — it is about identifying cases where an MCP server or Claude integration solves a real problem.

Consider MCP integration when:

• The project has an API that users or internal teams query frequently (an MCP server lets Claude interact with it directly)
• The project involves content management, knowledge bases, or documentation (Claude can help users find and synthesize information)
• The project has complex admin operations that benefit from natural language interfaces
• Customer support workflows could benefit from an AI agent with access to project data

Do NOT suggest MCP integration when:

• The project is a simple CRUD app with no complex query patterns
• Adding AI does not solve a problem the user actually has
• The user has not expressed interest in AI features
• It would be a gimmick rather than a genuine productivity improvement

If MCP integration is warranted:

MCP Integration Opportunity:
- Use case: [specific problem it solves]
- Implementation: MCP server exposing [which endpoints/data]
- Effort: [estimate]
- Value: [what the user or their users gain]

Presenting the Recommendation

Format your output as:

## Deployment Recommendation: [Project Name or Type]

### Project Requirements
- [Requirement 1]: REQUIRED NOW
- [Requirement 2]: REQUIRED SOON
- [Requirement 3]: NICE TO HAVE (defer)

### System Inventory
- Already installed: [tools, databases, CLIs detected]
- Running services: [ports, processes found]
- Project ecosystem: [framework, package manager, existing dependencies]

### Recommended Stack

| Layer | Choice | Reason |
|-------|--------|--------|
| Database | [choice] | [why — reference what user already has] |
| Hosting | [choice] | [why] |
| Auth | [choice] | [why] |
| [other] | [choice] | [why] |

Estimated monthly cost: $[X] (at current scale)

### Alternative Stack
[For when requirements change or scale increases]

| Layer | Choice | When to Switch |
|-------|--------|---------------|
| Database | [alt] | [trigger — e.g., "if concurrent users exceed 1000"] |
| Hosting | [alt] | [trigger] |

### What I Deliberately Did Not Recommend
- [Service X]: [why not — e.g., "overkill for this project size"]
- [Service Y]: [why not — e.g., "you do not have Docker installed and do not need it"]

Keep the recommendation proportional to the project. A weekend project gets a short recommendation. An enterprise SaaS gets thorough treatment.

Guardrails

Never:

• Recommend a service without checking if the user already has an alternative installed
• Suggest a paid service when a free alternative covers the requirements
• Recommend Docker to someone who does not have it and does not need it
• Default to AWS/GCP/Azure for projects that do not need enterprise cloud
• Stack multiple managed services when one would suffice (do not use Supabase + Auth0 + separate hosting when Supabase covers all three)
• Recommend based on what is trendy instead of what fits
• Ignore cost — always include a monthly estimate
• Suggest microservices for a project that should be a monolith

Always:

• Run environment-awareness inventory before making recommendations
• Present at least one recommended stack and one alternative
• Include cost estimates (even rough ones)
• Explain when to upgrade from the simple recommendation to the alternative
• Mention what you deliberately did not recommend and why
• Bias toward fewer services, lower cost, and less complexity
• Respect the user's existing choices when they have already committed to a stack

Connections

This skill integrates with the GodMode workflow at infrastructure decision points:

• godmode:environment-awareness -- Provides the system inventory this skill depends on. Always invoke before making recommendations.
• godmode:rationale -- Rationale surfaces alternatives at the feature level; deployment-advisor deepens the analysis for infrastructure-specific decisions.
• godmode:system-design -- Works together for architecture decisions. System-design handles application architecture; deployment-advisor handles infrastructure and services.
• godmode:project-bootstrap -- Deployment-advisor runs during project setup to establish the initial stack before any code is written.
• godmode:security-protocol -- Auth and hosting recommendations must align with security requirements.