MCP: Castles in the Sky

The Problem

I kept copy-pasting the same AI prompts and context across different projects. Terraform configs, coding standards, deployment patterns. Every new project meant rebuilding the same organizational knowledge from scratch.

So I built MCP-MGR to centrally manage all this context and route it to different projects. Seemed logical.

What I Actually Built

I set up a FastAPI router on Lightsail ($7/month) that routed requests to Lambda functions ($2/month). Added some project configs and a basic registry of coding patterns.

It worked fine. I used it for a few projects and it saved some copy-pasting. The infrastructure was cheap and didn’t break.

1
2
3
4

# Example: Terraform workspace standard established
terraform workspace select dev
terraform plan -var-file=dev.tfvars
terraform apply -var-file=dev.tfvars

The Realization

After two weeks of working on this, I discovered Daniel Miessler’s personal AI infrastructure approach using simple ~/.claude/ file organization.

The breakthrough insight: I was solving “how to connect AI services” when the real problem was “how to organize AI knowledge.”

Text files, it turns out, are better than services for context management.

The Evolution: Jinx

I rebuilt the entire system as Jinx - a file-based AI infrastructure that eliminated service complexity while preserving all valuable patterns.

Performance Transformation

Architecture Simplification

Before (MCP-MGR):

Client → Router (Lightsail) → Profile MCP (Lambda) → Project MCP

After (Jinx):

Client → ~/.claude/ directory → Local files

Technical Implementation

Standards Preservation

All 7 organizational patterns were preserved and enhanced:

• Terraform workspace strategies for multi-environment management
• Lambda deployment patterns with consistent packaging
• GitFlow CI/CD workflows with OIDC authentication
• Cost optimization strategies targeting <$25/month per environment

Tool Migration

1
2
3
4

# Original MCP tools became simple shell scripts
./tools/validate-project     # Project validation
./tools/introspect-project   # Structure analysis  
./tools/standards-catalog    # Browse available patterns

Infrastructure Elimination

• Destroyed: Lightsail containers, Lambda functions, API Gateway
• Preserved: All validation tools, standards, and organizational patterns
• Improved: Response time, cost, maintenance overhead

Business Impact

Quantified Results

• $252 annual savings per environment
• 40x performance improvement for AI interactions
• Zero infrastructure maintenance overhead
• 100% offline capability for development workflows

Strategic Value

• Proven cost optimization strategies for future projects
• 7 reusable standards applicable across organizations
• Template system enabling 5-minute project bootstrap
• GitFlow automation patterns for CI/CD pipelines

Key Lessons

What Worked Brilliantly

1. Standards-first development - Capturing patterns accelerated all subsequent work
2. Cost-conscious architecture - Nano-sized infrastructure proved sustainable
3. Pattern documentation - Machine-readable formats enabled automation
4. Infrastructure as Code - Terraform enabled rapid iteration

What Was Over-Engineered

1. Service orchestration - Network latency for simple file operations
2. Complex routing - Namespace resolution added unnecessary overhead
3. Lambda cold starts - 1-3 second delays for instant operations
4. Infrastructure maintenance - Managing services that could be files

The Meta-Lesson

“The most elegant solution is often the one that eliminates the need for the solution.”

Complex problems don’t always require complex solutions. Sometimes the best engineering decision is knowing when to unbuild the complexity.

Technical Stack

Original (MCP-MGR):

• Python 3.11, FastAPI, Uvicorn
• AWS Lightsail, Lambda, API Gateway
• Terraform, Docker, GitHub Actions

Evolved (Jinx):

• Local files, shell scripts
• Python tools (preserved)
• Zero cloud dependencies

Repository & Documentation

The complete journey is documented in the MCP-MGR repository, including:

• Complete architecture documentation
• 7 organizational standards (reusable patterns)
• Migration strategy and implementation details
• Template system for project scaffolding

Result: A case study demonstrating that infrastructure overhead often exceeds business value.

Conclusion

MCP-MGR wasn’t a failure - it was the experiment that revealed a fundamental truth: the best infrastructure is no infrastructure.

This project demonstrates the iterative nature of engineering. Every line of code, every service, every deployment taught valuable lessons. The infrastructure may be gone, but the knowledge lives on in a simpler, more effective form.

Impact: $252/year savings, 40x performance improvement, and the wisdom to choose simplicity over complexity.

Technologies: AWS, Python, FastAPI, Terraform, Lambda, Lightsail, Infrastructure as Code, Cost Optimization