Project Story — This Kiroween, Rhino and the Kiro CLI exorcise legacy nightmares and resurrect modern applications — in days, not months.

Inspiration

This project was inspired by a recurring pain we observed across enterprises: legacy modernization is slow, manual, and documentation-poor. Teams spend months reverse-engineering code before they can even start transforming it. We wanted to prove that modernization can be fully autonomous—from legacy understanding to a running modern application—using Rhino for intelligence and Kiro for transformation.

What We Built

We built an end-to-end, zero-touch modernization pipeline: Rhino extracts business logic and generates technical specifications. These specs are automatically consumed by Kiro CLI, which generates a fully functional Case Management application on .NET 8 with Clean Architecture—with no human in the loop.

How We Used Kiro

Vibe Coding

We used vibe coding during early experimentation to:

Generate initial Clean Architecture templates
Rapidly iterate on API design and service boundaries
The most impressive generation was when Kiro produced a complete multi-layered .NET 8 solution (Domain, Application, Infrastructure, API) in one pass with working build output.

Agent Hooks

We did not use Agent Hooks in this project. Instead, we relied on fully automated CLI-driven execution initiated through spec ingestion.

Spec-Driven Development

Our primary mode was spec-driven development.
Rhino generated:

Domain models
Business rules
Workflow definitions
Target architecture (.NET 8, Clean Architecture)

These were structured as steering + technical specification documents and fed directly into Kiro. Compared to vibe coding, this approach was:

Deterministic
Repeatable
Architecture-consistent
Enterprise safe

Spec-driven output was dramatically more production-ready than conversational prompts.

Steering Docs

We used steering documents to:

Lock target framework to .NET 8
Enforce Clean Architecture
Control naming, layering, and API boundaries
The biggest impact was eliminating architectural drift across repeated generations.

MCP (Model Context Protocol) — Key Innovation

We extended Kiro using MCP to fetch specification documents directly from the Rhino MCP Server.
This enabled:

Live, auto-synced spec ingestion
Elimination of manual file handling
True system-to-system automation between Rhino and Kiro
Without MCP, this level of real-time intelligence handoff would not have been possible.

Challenges We Faced

Normalizing legacy logic into machine-consumable specs
Ensuring Clean Architecture consistency across auto-generated layers
Designing a fully autonomous pipeline with no hidden human steps
MCP integration was the hardest but most rewarding technical challenge.

What We Learned

Spec-driven AI beats prompt-driven AI for enterprise software
MCP unlocks true AI-to-AI orchestration
Kiro is not just a generator—it is a modernization execution engine

Final Impact

Together, Rhino + Kiro demonstrate autonomous application modernization at machine speed—from legacy code to a fully running modern system with no human in the loop.