Skip to main content

How Kiro Helped Build FluentDynamoDB

· 4 min read
Dan Guisinger
Dan Guisinger
Founder, Oproto Inc.

Kiro is a Visual Studio Code fork from AWS that brings deep AI capabilities directly into the IDE. It isn’t “just another coding assistant.” It’s a different way of building software—one where planning, architecture, and implementation all flow through an AI-augmented workflow.

When we started FluentDynamoDB, we knew the scope would be massive: source generators, indexing logic, AOT-safe expression compilation, geospatial search, encryption, stream processing, and thousands of tests. Kiro became the only viable way to deliver something this ambitious with the quality level we required.

🚧 Project Status Update – Temporary Code Freeze FluentDynamoDB is currently in a temporary code freeze due to our Kiroween 2025 hackathon submission. During this period, the public repository will not receive updates, and new features will be released after judging concludes in early 2026. We're still actively engaged with the community, and we're preparing a February release that will include important fixes, improvements, and new capabilities.

The Kiro Spec Workflow​

One of Kiro’s most transformative features is the Spec system — a structured workflow for requirement-driven development. It brings discipline and repeatability to AI-generated code.

  1. requirements.md — What the system must do

Requirements in Kiro follow the EARS (Easy Approach to Requirements Syntax) pattern to ensure clarity, testability, and shared understanding. They define:

  • expected behaviors
  • constraints
  • edge case expectations
  • business rules and functional intent

This document becomes the contract every later phase relies on.

  1. design.md — How the system should be built

Once requirements are locked in, design specs map them into:

  • component boundaries
  • data structures
  • access patterns
  • correctness properties
  • error-handling rules
  • performance considerations

This is where we reasoned about source-generation behavior, expression translation, composite keys, the geospatial abstractions, and the ergonomics of the fluent API itself.

  1. tasks.md — What Kiro should implement

The task list breaks the design into small, actionable steps:

  • Each task references the requirement it satisfies
  • Each task references the design justification
  • Kiro executes tasks directly, writing code aligned to the spec

This traceability is what allowed us to maintain consistency across 10+ library packages and thousands of test cases.

Why This Matters​

Instead of asking an AI to “write some code,” you collaborate around a shared set of structured documents. The result is:

  • consistent architectural decisions
  • stable API design
  • tests that match requirements
  • code that reads as if it were authored by a single engineer

It's the closest thing to traditional spec-driven development I’ve ever used.

Project Scope​

FluentDynamoDB is not a demo or weekend hackathon project. It is large-scale engineering work powered by a structured AI workflow.

What Kiro helped produce​

  • 150,000+ lines of C# across source generators, builders, expression translators, encryption modules, and geospatial algorithms
  • 100,000+ lines of Markdown for documentation, steering notes, specs, and design artifacts
  • 10 core packages published as NuGet libraries (with more coming)
  • ~4,000 tests, including:
    • unit tests
    • integration tests
    • property-based tests
  • 5 example applications demonstrating CRUD, geospatial search, S3-backed fields, composite entities, and transactions

The scale is comparable to a multi-team enterprise project — delivered by one person with an AI-powered workflow.

45 Days​

This part still shocks me: From a near-empty repo to:

  • a fully generated table/entity system
  • lambda-expression translators
  • composite key builders
  • encryption + S3 blob support
  • a stream processing framework
  • geospatial lookup using GeoHash, S2, and H3
  • thousands of tests
  • full documentation

… in 45 days of development time.

This simply would not be possible using traditional development methods alone. Kiro didn't just accelerate development — it changed the scope of what was possible.

What's Next​

We’ll continue sharing deep dives into:

  • expression translation
  • source generation patterns
  • geospatial optimizations
  • lessons learned scaling AI-assisted development

FluentDynamoDB is on track for its public NuGet release this year. Thank you for following the journey — and if you're experimenting with Kiro yourself, I’d love to hear what you're building.