Food waste is a real-life monster. Every year, around 1.3 billion tons of food are thrown away—while millions go hungry and the planet heats up. Half-used onions. Forgotten spinach. That single sad tomato at the back of the fridge. They’re not just ingredients… they’re ghosts.
At some point, staring into my own fridge, I had a very Halloween-flavored thought:
What if no ingredient ever truly had to die?
That question became Recipe Reanimator: a Halloween-themed web app that turns leftover ingredients into AI-generated recipes and shows you how much food, money, and CO₂ you’re saving along the way.
But building Recipe Reanimator wasn’t just about food. It was also an experiment in AI-assisted development. I didn’t just build an app; I built a chimera of technologies—SQL + NoSQL, Python + React, AI models + cloud infra—using Kiro as my AI lab assistant.
This is the story of how Kiro helped me stitch that monster together.
Meet Recipe Reanimator: The App in the Cauldron
At a high level, Recipe Reanimator is a web app where you play kitchen alchemist:
- You can snap a photo of your pantry, and AI (via Gemini Vision) extracts the ingredients.
- You can drag and drop ingredients into a digital cauldron, with quantities.
- You tap “brew,” and it generates 5 personalized recipes, ranked by how well they rescue your existing ingredients.
- It shows real-time impact: approximate food saved, money saved, and CO₂ avoided.
- You can save favorite recipes, generate shopping lists for missing items, and share recipes with public links.
Under the hood, it’s a bit of a Frankenstein:
- Frontend: React + Vite for the Gothic, animated cauldron UI.
- Backend: Python FastAPI for APIs and AI orchestration.
-
Databases:
- TiDB (SQL) for users, auth, favorites, shopping lists.
- MongoDB (NoSQL) for recipes, ingredients, and history.
- AI: Google Gemini for recipe generation and pantry image understanding.
- Infra: GitHub Actions for CI/CD and Google Cloud Run for deployment.
On paper, this is cool. In practice, it’s the kind of stack where one wrong stitch and the whole creature collapses.
That’s where Kiro came in.
Why I Needed Kiro in the Lab
Traditional AI coding tools are great when you’re “vibe coding” a small prototype—prompt in, code out. But trying to glue together multiple databases, a typed API surface, an AI engine that sometimes returns weird JSON, and a production-ready deployment pipeline is another beast entirely.
Kiro is designed for that problem: it combines AI chat, spec-driven development, steering rules, and MCP integration so the AI can talk to tools like databases or APIs directly from your workspace.
For Recipe Reanimator, Kiro didn’t just generate code. It helped design the architecture, keep conventions consistent, talk directly to TiDB and MongoDB, and catch issues before they reached users.
Talking Features Into Existence
Kiro’s chat interface became my control panel for development. Instead of copy-pasting huge chunks of code into a generic LLM, I could reference the actual project structure and ask for changes in natural language.
A real example: I wanted pantry image uploads to automatically detect what ingredients were visible in the photo. So I told Kiro something like:
“Add OCR-based pantry image analysis using Gemini Vision, wired into the existing FastAPI backend and cauldron UI.”
Because Kiro had context of both the backend and frontend, it:
- Added a FastAPI endpoint for image upload.
- Integrated Gemini Vision calls to extract ingredients.
- Updated the React cauldron UI to support drag-and-drop image upload and display the detected ingredients.
It felt less like coding and more like a conversation with a very focused pair programmer.
Spec-Driven Development: From Vibes to Blueprint
For bigger chunks of work—like designing the backend or setting up CI/CD—I leaned on one of Kiro’s core ideas: spec-driven development.
The workflow:
- requirements.md – What this feature must do.
- design.md – How it should work technically.
- AI-assisted task breakdown – Concrete implementation steps linked back to the spec.
For Recipe Reanimator’s waste score and sustainability metrics, this helped me:
- Clearly define how to compute food, money, and CO₂ savings.
- Decide which database stores which fields.
- Plan how the frontend surfaces these numbers without becoming cluttered.
Kiro kept the spec and code in sync, so the final implementation still matched the original intent.
Giving Kiro Direct Access to My Databases (MCP)
The spookiest (and most powerful) part was using Model Context Protocol (MCP) with Kiro. MCP lets Kiro talk to external services like databases via a config file in the repo.
I set up MCP servers for both TiDB and MongoDB, pointing Kiro at my actual databases with environment variables in .kiro/settings/mcp.json. Once that was done, Kiro could:
- Query TiDB to inspect real table schemas.
- Look at MongoDB documents to understand recipe structures.
- Help debug data issues without leaving the IDE.
Example: When building “favorites,” I asked Kiro to check the TiDB schema for the favorites table. It queried TiDB, confirmed the structure, and then generated the correct SQL for FastAPI endpoints that joined favorites with users and recipes.
Steering Rules: My Project’s Spellbook
Kiro also supports “steering” files—project-wide rules that describe how the codebase should look and feel. For Recipe Reanimator, I wrote rules in .kiro/steering/ for:
- The tech stack and libraries to use.
- How to structure files and name things.
- The Halloween tone, “reanimation” metaphors, and UX guidelines.
Once written, Kiro followed these automatically whenever it generated new code or copy, keeping the spooky aesthetic and architecture consistent.
Smart Diagnostics: Catching Bugs Before They Escape
Because Kiro lives in an IDE environment, it can continuously scan the project for issues like TypeScript errors, Python type problems, and build-time failures before they hit production.
In Recipe Reanimator, that meant:
- TypeScript issues in the cauldron UI were surfaced early.
- FastAPI type mismatches and response issues were flagged before API calls ran.
- Misconfigurations across frontend/backend were caught faster than manual trial-and-error.
A Light Look at the Technical Stitching
Underneath the memes and lightning bolts, Recipe Reanimator is a fairly serious stack:
- Backend (FastAPI): JWT auth, bcrypt hashing, Gemini calls, structured prompts, and centralized logging.
- Frontend (React + Vite): Themed UI, cauldron animations, authenticated routes, drag-and-drop pantry uploads, mobile-first design.
- Data: TiDB for relational data; MongoDB for flexible recipe/ingredient documents.
- AI: Gemini for recipes and pantry vision, plus a custom waste score and sustainability narratives.
- CI/CD & Cloud: GitHub Actions workflows, multi-stage Docker builds, and Cloud Run for autoscaling and easy deploys.
Kiro’s role was to keep all these pieces aligned, from schema-aware queries to spec-driven features.
What This Journey Taught Me About Kiro
By the end, a few things stood out:
- Specs made big features manageable, turning vague ideas into concrete, testable work.
- MCP turned databases into first-class citizens in the development loop, not distant black boxes.
- Steering rules were quiet force multipliers, baking conventions, tone, and structure directly into Kiro’s behavior.
- Diagnostics and context-aware chat beat copy-paste LLM usage, especially in a multi-service architecture.
Without Kiro, this would likely have remained a half-finished prototype. With Kiro, it became a production-style chimera of databases, AI, and cloud that actually works.
Built for Kiroween
Recipe Reanimator embodies everything Kiroween is about:
- A spooky, coherent Halloween aesthetic.
- Reanimating “dead” ingredients to fight food waste.
- Stitching together incompatible technologies into one living system.
- Using Kiro not just as a helper, but as a true AI co-creator.
Like any good Frankenstein story, there’s a mix of terror and joy when you finally flip the switch and see your creation run. And in this case, the monster doesn’t just live—it helps people waste less food, save more money, and have a little fun along the way.
Top comments (1)
Some comments may only be visible to logged-in visitors. Sign in to view all comments.