Kiro Comparison Tool

This tool takes a few options you're considering, some constraints you might have, and spits out a comparison that actually helps you understand the trade-offs. Instead of just saying "pick this one", it shows you when each option makes sense and when it doesn't.

What it does

You can compare:

• APIs (like Stripe vs PayPal)
• Cloud services (AWS Lambda vs Google Cloud Functions)
• Tech stacks (React vs Vue)
• Different approaches (microservices vs monolith)

You give it the options, maybe some constraints like "budget under $100/month" or "must support TypeScript", and it gives you back:

• Trade-offs with scores for different aspects
• Recommendations with confidence levels
• Insights from Kiro AI that actually consider your situation

Setup

You'll need Python 3.10 or higher. Then:

pip install -r requirements.txt

I'd recommend using a virtual environment:

python3 -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate
pip install -r requirements.txt

Running it

Just run:

streamlit run app.py

It'll start on http://localhost:8501 by default. Open that in your browser and you should see the interface.

To use it:

1. Pick a comparison type from the sidebar
2. Enter at least 2 options
3. Add constraints if you have any (one per line)
4. Add context about your use case (optional)
5. Click "Compare Options"

The results show trade-offs, scores, recommendations, and Kiro AI insights.

API

There's also a FastAPI backend if you want to use this programmatically:

uvicorn api.main:app --reload

Then check out http://localhost:8000/docs for the interactive API docs. The main endpoint is /api/compare - just POST a JSON with type, options, constraints, and context.

Tech stack

• Streamlit for the UI (super easy to build web apps in Python)
• FastAPI for the API (fast and has great docs)
• Kiro AI for generating the insights (this is the cool part)
• Python 3.10+

The comparison engine looks at different things depending on what you're comparing. For APIs it checks performance, cost, docs, community, reliability. For tech stacks it looks at dev experience, ecosystem, learning curve, maintainability. You get the idea.

Project structure

.
├── app.py                      # Streamlit UI
├── api/
│   └── main.py                # FastAPI backend
├── lib/
│   ├── comparison_engine.py   # Does the actual comparison logic
│   └── kiro_client.py         # Talks to Kiro AI
├── .kiro/                      # Kiro config (needs to stay in repo)
└── requirements.txt            # Dependencies

Why this?

The Kiro AI integration is what makes it useful instead of just comparing features, it actually considers your context and gives you insights that make sense for your situation. Way better than just "this one has more GitHub stars."

Notes

• Keep the .kiro directory in the repo (required for submission)
• Python 3.10+ required
• If port 8501 is taken, use --server.port to change it
• The OpenAI integration is optional - if you don't have an API key, it falls back to template-based insights

That's pretty much it. The code is straightforward Python, so if something breaks you can probably figure it out by looking at it.