Building Mirmer AI: How Kiro Transformed Solo Development into AI-Powered Collaboration

Solaimuthu A — Wed, 03 Dec 2025 15:52:18 +0000

Building a production-ready multi-LLM platform in weeks, not months

The Challenge: Resurrecting 400 Years of Peer Review

When I set out to build Mirmer AI, I had an ambitious vision: resurrect the 400-year-old peer review process that built modern science, and run it at machine speed with AI models. The concept was simple but the execution was complex:

Stage 1: Multiple AI models respond independently
Stage 2: Models anonymously peer-review each other's responses
Stage 3: A chairman model synthesizes consensus

But here's the reality check: I'm a solo developer. Building this meant:

FastAPI backend with async orchestration
React frontend with real-time streaming
PostgreSQL database with dual-mode storage
Python SDK with sync/async clients
CLI tool with browser-based authentication
Payment integration with Razorpay
Firebase authentication
Deployment on Railway and Vercel

That's easily 2-3 months of work. I had weeks, and * I wasn't just building a hackathon project - I was building a startup.*

Enter Kiro.

Caption: Mirmer AI's 3-stage council interface - where AI models debate and synthesize answers

The Kiro Advantage: Not Just Code Generation, But Architecture

Most AI coding assistants help you write functions. Kiro helped me architect an entire system.

1. Steering Rules: Teaching Kiro My Codebase

The first thing I did was create three steering documents in .kiro/steering/:

tech.md - My entire tech stack documented:

Backend: FastAPI, Python 3.10+, uv package manager
Frontend: React 18, Vite, Tailwind CSS
Database: PostgreSQL (production), JSON (dev)
Key Pattern: Dual-mode storage with factory pattern
Critical: Always use "uv run" not "python" directly

structure.md - Project architecture:

backend/
  main.py - API routes
  council.py - 3-stage orchestration
  storage.py - Factory pattern (auto-selects backend)
  storage_postgres.py - Production storage
  storage_json.py - Dev storage
frontend/
  src/components/ - React components
  src/pages/ - Route pages
sdk/
  mirmer/ - Python SDK package

product.md - The "why" behind decisions:

Core: 3-stage council process (parallel queries → peer review → synthesis)
Business: Free (10/day), Pro (100/day), Enterprise (unlimited)
Key Feature: Real-time streaming via SSE

Caption: Steering rules - the secret to persistent context across all Kiro conversations

The Impact: After setting up steering rules, I never had to explain the architecture again. Every conversation started with Kiro already knowing:

Use uv run for Python commands
Import from storage.py, not storage_postgres.py directly
Follow the 3-stage council pattern
Maintain dual-mode storage compatibility

This eliminated an entire class of errors and architectural inconsistencies.

2. Spec-Driven Development: From Idea to Implementation Plan

For complex features, I used Kiro's spec system. Here's how it worked for the Python SDK:

Phase 1: Requirements (requirements.md)
I'd say: "Create a spec for a Python SDK"

Kiro generated:

12 user stories with acceptance criteria
Glossary of technical terms
60+ testable requirements in EARS format

Example requirement:

User Story: As a developer, I want to stream council updates in real-time

Acceptance Criteria:
1. WHEN a developer calls the stream method THEN the system SHALL yield updates as each stage progresses
2. WHEN Stage 1 completes THEN the system SHALL yield an event containing all individual model responses
3. WHEN streaming encounters an error THEN the system SHALL yield an error event with details

Caption: Auto-generated requirements document with user stories and acceptance criteria

Phase 2: Design (design.md)
Kiro then generated:

Complete architecture with data flow diagrams
Component interfaces with method signatures
20 correctness properties for property-based testing
Error handling strategies
Testing approach (unit + property-based + integration)

The game-changer: Correctness Properties

Instead of just writing tests, Kiro helped me define universal properties:

"For any API request, x-user-id header should contain the API key"
"For any subscription payment, tier should update to pro"
"For any streaming request, events should arrive in order: stage1_start → stage1_complete → stage2_start..."

These became Hypothesis property-based tests running 100+ iterations each.

Phase 3: Tasks (tasks.md)
Finally, Kiro broke it into actionable tasks:

- [ ] 1. Set up project structure and packaging
- [ ] 2. Implement core data models
  - [ ] 2.1 Create Pydantic models for all data structures
  - [ ]* 2.2 Write property test for response structure validation
- [ ] 3. Implement synchronous Client class
  - [ ] 3.1 Create Client with initialization and configuration
  - [ ]* 3.2 Write property test for API key security

Notice the * on test tasks? Those are optional - I could focus on core features first.

Caption: Implementation tasks with progress tracking - each task references specific requirements

The Result: The SDK spec caught 3 bugs before production. Tasks broke a 3-day feature into 1-hour chunks. I could pause work and resume weeks later because context was preserved in the spec files.

3. Agent Hooks: The Self-Improving Codebase

Here's where it gets wild. I created 6 agent hooks that automated my workflow:

API Function Generator - Triggered on backend file edits

When I write a new API function, Kiro automatically generates:
- FastAPI route decorator
- Pydantic validation schema
- Error handling boilerplate
- Example request body

Auto-Document Code - Triggered on any code file edit

Kiro adds docstrings/JSDoc to every function automatically
No more "I'll document this later" - it happens in real-time

Auto-Generate Tests - Triggered on code changes

Creates unit tests with:
- Normal operation test cases
- Edge cases (empty inputs, null values)
- Error handling tests
- Mock objects for external dependencies

Code Quality Analyzer - Triggered on file save

Analyzes for:
- Functions longer than 50 lines (suggests refactoring)
- Duplicate logic (suggests extraction)
- Unused variables/imports
- Poor variable names

Caption: Agent hooks - automation that runs in the background as you code

The Impact:

API Generator saved 2-3 hours standardizing 15+ endpoints
Auto-Generate Tests ensured test coverage without breaking flow
Code Quality Analyzer caught issues before they became technical debt

Instead of context-switching to write docs and tests later, hooks handled it in real-time. The codebase improved itself as I coded.

4. Vibe Coding: When Speed Matters More Than Structure

Not everything needed a spec. For simple features, I used "vibe coding":

Example: Adding a search bar to the sidebar

Me: "#frontend/src/components/Sidebar.jsx - add a search bar 
     with 300ms debounce that calls the search API"

Kiro: [Generates SearchBar component with debouncing, 
       updates Sidebar to include it, adds proper state management]

One message, feature implemented.

The Strategy:

Vibe coding for 70% of features (UI components, simple endpoints)
Spec-driven for 30% (SDK, payment system, core logic)

Use specs when correctness matters. Use vibe coding when speed matters.

Caption: Vibe coding - from idea to implementation in one conversation

The Most Impressive Moment: CLI Authentication

The hardest problem I faced: CLI tools need Firebase authentication, but Firebase requires a browser. How do you bridge terminal and browser?

My prompt to Kiro:

"CLI tools need Firebase auth, but Firebase requires a browser. 
How do we bridge this?"

Kiro's solution (generated across 4 files, first try):

CLI local server (Python) - Listens on localhost:8765
Browser popup flow - Opens /auth/cli?callback=http://localhost:8765/callback
JavaScript token capture - Gets Firebase token, redirects to local server
Token persistence - Saves to ~/.mirmer/credentials.json

This involved coordinating:

Python (CLI)
JavaScript (browser)
Firebase SDK
HTTP callbacks
Error handling for when browser isn't available

It worked on the first try. That's when I realized Kiro wasn't just generating code - it was architecting solutions.

Caption: CLI authentication flow - bridging terminal and browser seamlessly

The Numbers: What Kiro Actually Delivered

Project Scope:

50+ backend endpoints
30+ React components
Complete Python SDK (published to PyPI)
CLI tool with browser auth
Real-time SSE streaming
Dual-mode storage system
Payment integration
Full authentication system

Development Time: ~3 weeks (would have been 2-3 months solo)

Specs Created:

python-sdk: 12 requirements, 20 correctness properties, 15 tasks
subscription-status-fix: 5 requirements, 9 properties, 7 tasks
sdk-documentation-page: Full requirements → design → tasks

Hooks Created: 6 automated workflows running continuously

Lines of Code: ~15,000+ (backend + frontend + SDK)

Bugs Caught by Property-Based Tests: 3 critical bugs before production

Caption: 3 weeks of AI-assisted development - what would have taken months

Building a Startup, Not Just a Project

This wasn't just a hackathon entry - Mirmer AI is a real business with paying customers and production infrastructure.

Revenue Model:

Free tier (10 queries/day) for user acquisition
Pro tier (₹150 /month) with Razorpay payment integration
Enterprise tier (custom pricing) with automated inquiry system via SendGrid

Go-to-Market Strategy:

Published Python SDK on PyPI for developer adoption
CLI tool with seamless browser-based authentication
Complete documentation site with interactive examples
Landing page with pricing tiers and conversion funnel
Real-time usage tracking and subscription management

Production Infrastructure:

Backend deployed on Railway with PostgreSQL database
Frontend deployed on Vercel with global CDN
Payment webhooks processing real transactions
Firebase authentication handling user management
Dual-mode storage supporting both dev and production

Developer Experience:

SDK available immediately: pip install mirmer-ai
Comprehensive API documentation
Example code for common use cases
CLI tool for quick testing and integration

Kiro didn't just help me build faster - it helped me build a complete product with all the pieces a startup needs: payments, authentication, SDK, documentation, and deployment infrastructure. What would normally require a team of 3-4 developers, I shipped solo in 3 weeks.

Key Lessons: How to Maximize Kiro

1. Invest in Steering Rules Early

Spend 30 minutes documenting your tech stack, architecture, and product vision. You'll save hours of repetitive explanations.

2. Use Specs for Complex Features

If a feature will take more than a day, write a spec. The upfront investment pays off in:

Fewer bugs
Better architecture
Easier to pause/resume work

3. Create Hooks for Repetitive Tasks

Identify patterns in your workflow and automate them. My hooks saved 10+ hours over the project.

4. Mix Vibe Coding and Spec-Driven

Don't over-engineer simple features. Use specs when correctness matters, vibe coding when speed matters.

5. Leverage #File Context

Instead of explaining code, use #backend/main.py #frontend/App.jsx to pull files into context. Kiro sees the code and makes consistent changes.

The Resurrection Category: Why This Matters

I built Mirmer AI for the Kiroween Hackathon's "Resurrection" category. The concept: bring back dead technology with modern innovation.

What I resurrected: The 400-year-old peer review process that built modern science.

How I modernized it: AI models debate at machine speed, with real-time streaming and consensus synthesis.

Why it matters: As AI proliferates, we need systems to validate AI outputs against each other. Single-model responses are becoming obsolete. Mirmer addresses the "which AI should I trust?" problem by consulting all of them.

The irony? I used an AI-powered IDE (Kiro) to build an AI peer review system. Meta-resurrection.

Caption: From centuries-old expert councils to AI-powered peer review in seconds

Try It Yourself

Mirmer AI: https://mirmerai.vercel.app
Python SDK: pip install mirmer-ai
GitHub: [https://github.com/redwing-381/mirmer.ai]

Kiro: https://kiro.dev/

Final Thoughts: The Future of Solo Founders

Three weeks ago, building a production-ready multi-LLM platform with SDK, CLI, payments, and real-time streaming seemed impossible for a solo founder.

Kiro didn't just help me write code faster. It helped me:

Architect better systems (steering rules)
Think about correctness (property-based testing)
Automate workflows (agent hooks)
Maintain context across weeks (specs)
Ship a complete startup in weeks, not months

The future of solo entrepreneurship isn't about replacing founders. It's about augmenting them. Kiro transformed me from a solo developer into a one-person startup with an AI architect, code reviewer, automation engineer, and product team.

If you're building something ambitious - whether it's a hackathon project or a startup - don't go it alone. Bring Kiro along for the ride.

Built for #Kiroween Hackathon | Category: Resurrection + startup | #kiro #ai #development

Comments Section Prompt

What's the most complex feature you've built with AI assistance? Drop your stories below - I'd love to hear how you're using AI in your development workflow!

Forem: Solaimuthu A