Building an AWS Architecture Card Game with Kiro: When the AI Deserves the Credit 😄

How It All Started

It all started when I played the AWS Builder Cards game for the first time at the AWS Singapore office. To my surprise, I won!

While I really enjoyed the experience, I felt the game had quite a few rules to remember. The host was fantastic and voluntarily gave players tips and hints throughout the game, which made it much easier to play.

Personally, I enjoy games with simple rules that are easy to pick up but still challenging and fun. That got me thinking:

Why not use Kiro to build a new variation of the Builder Cards game?

Instead of recreating the original game, I wanted to design a version with simpler gameplay, fewer rules, and a stronger emphasis on cloud architecture design and decision-making. The goal was to make it more accessible for beginners while still helping players learn AWS architecture concepts in an engaging way.

If you had told me a year ago that I’d spend more time reviewing AI-generated code than writing it myself, I probably wouldn’t have believed you.

Recently, I built an online game called AWS Builder: Architecture Race.

👉 https://aws-builder.trincoithub.org/

The interesting part isn’t the game itself.

It’s how it was built.

Kiro Wrote All of the Code (Seriously)

I don’t think I deserve much credit for this project.

The real developer was Kiro.

I simply:

• described features
• reviewed the code
• fixed a few issues
• clicked Accept

Meanwhile Kiro happily burned through 200 credits writing the application.

So if anyone deserves the “Developer of the Month” award…

it’s probably Kiro.

😂

The Idea

I’ve always liked the AWS Builder Cards game that AWS uses during events.

Instead of making a digital copy, I wanted something different.

The goal was to create a browser-based game where players:

• build cloud architectures
• choose the correct AWS services
• score points based on architecture decisions
• learn AWS services while playing

The game targets students, beginners, and community workshops.

Technology Stack

The entire application follows a serverless architecture.

Frontend

• VueJs3
• TypeScript
• Tailwind CSS

Hosted using:

• AWS Amplify Hosting

AI

The game includes an AI mode powered by:

• Amazon Bedrock

Instead of hardcoding every response, Bedrock helps generate intelligent gameplay interactions and explanations.

Backend

There are no traditional application servers.

Everything runs using managed AWS services.

Architecture includes:

• AWS Lambda
• Amazon API Gateway
• Amazon Bedrock
• Amazon DynamoDB
• Amazon S3
• AWS Amplify

No EC2.

No Kubernetes.

No containers.

No patching.

No “server is down because someone forgot to reboot it.”

Serverless Architecture

             Player
                │
                ▼
        AWS Amplify Hosting
                │
                ▼
         React Frontend
                │
                ▼
        Amazon API Gateway
                │
        ┌───────┴────────┐
        ▼                ▼
   AWS Lambda      Amazon Bedrock
        │
        ▼
 Amazon DynamoDB

Enter fullscreen mode Exit fullscreen mode

The result is:

• low operational overhead
• automatic scaling
• pay only for usage
• easy deployment

Developing with Kiro

This project became an experiment in Agentic Development.

Instead of writing every component manually, I worked with Kiro like another engineer on the team.

Typical workflow:

1. Describe the feature.
2. Kiro generates the implementation.
3. Review the code.
4. Request improvements.
5. Repeat.

Sometimes Kiro surprised me with elegant solutions.

Sometimes it confidently invented functions that didn’t exist.

Just like a real junior developer.

Hosting with AWS Amplify

Deployment was surprisingly straightforward.

Every Git push automatically:

• builds the application
• deploys the frontend
• updates production

No manual deployments.

No SSH.

No copying files around.

Lessons Learned

AI doesn’t replace software engineers.

It changes how we spend our time.

Instead of typing boilerplate, I spent more time:

• reviewing architecture
• validating business logic
• improving user experience
• refining prompts

The bottleneck shifted from writing code to making good engineering decisions.

Final Thoughts

This project showed me how quickly a production-ready application can come together when combining:

• Kiro
• Amazon Bedrock
• AWS Amplify
• Serverless AWS services

Would I build another project this way?

Absolutely.

Would I like my 200 Kiro credits back?

Also absolutely.

Until then, I’ll continue pretending I built it while Kiro quietly reminds me who really wrote most of the code.