Building a Tic-Tac-Toe Game with Kiro

Learn how I used Kiro's spec-driven workflow to build a Tic-Tac-Toe web application while introducing students to AI-assisted software engineering.

Series: Workshops (1 article)

1
Building a Tic-Tac-Toe Game with Kiro This article

Shakiran

Software Engineer

Published Jul 29, 2026

Last modified Jul 30, 2026

When people think about AI coding tools, they often imagine writing a prompt and watching an application appear in seconds. While that's exciting, building quality software involves much more than generating code. It requires planning, defining requirements, making design decisions, and maintaining consistency throughout a project.

That was exactly the message I wanted to share during a recent workshop I hosted with the AWS Builder Group – Makerere University.

Our session, "Ship Better Software with Kiro: Hands-on Workshop for Student Developers," introduced students to Kiro by building a complete Tic-Tac-Toe web application from scratch.

Rather than treating AI as a code generator, we explored how Kiro supports the entire software engineering process.

Why Tic-Tac-Toe?

It was in the template 😂, but anyway, jokes aside, choosing the right project was surprisingly important.

I wanted something that participants could complete in under two hours while still experiencing a realistic development workflow.

Tic-Tac-Toe checked all the boxes.

It includes:

User interaction
State management
Conditional logic
Game rules
UI updates

Small enough to finish.

Interesting enough to demonstrate good software engineering practices.

Starting with Specifications

One feature that immediately stood out in Kiro was Specs.

Instead of jumping straight into implementation, we first described what we wanted the application to do. Our initial specification looked something like this:

1
2
3
4
5
6
7
8
9
10
11
Build a browser-based Tic-Tac-Toe game.

Requirements:

- 3×3 board
- Two-player gameplay
- Alternate turns
- Detect wins
- Detect draws
- Restart game
- Responsive interface

This encouraged everyone in the workshop to think about the problem before thinking about the solution. As developers, that's a habit worth building regardless of the IDE we're using.

Building Feature by Feature

Instead of asking Kiro to generate an entire application in one prompt, we built the project incrementally.

Our workflow looked like this:

Create the project specification.
Generate the project structure.
Build the game board.
Implement player turns.
Detect winners.
Handle draws.
Add the restart button.
Test and refine.

Breaking the work into smaller pieces made it much easier for students to understand both the code and Kiro's reasoning.

Features That Impressed Me

Specs

Specs provide a structured starting point for development instead of relying entirely on prompts.

For students, this reinforces thinking about requirements before implementation.

Steering

Steering helps define project-wide guidance so generated code stays consistent.

It's a subtle feature, but one that encourages better engineering habits.

Hooks

Hooks automate repetitive parts of the development workflow.

Although we only introduced them briefly during the workshop, it's easy to imagine how useful they become on larger projects.

Workshop Highlights

The workshop brought together 28 student developers who followed along as we built the application.

Beyond writing code, participants discussed:

How AI fits into software engineering
The importance of project planning
Building maintainable applications
Responsible use of AI development tools

We also introduced the new AWS Builder Group – Makerere University Core Team and shared our plans for future AI and cloud workshops.

What I'd Love to See Improved

Overall, my experience with Kiro was positive, particularly the structured workflow it encourages.

One area I'd love to see refined is how the free tier handles long-running tasks.

While preparing for the workshop, I occasionally encountered situations where an agent appeared to repeat the same task without making progress. During those periods, credits continued to be consumed even though no useful output was being produced.

For students who are exploring Kiro on the free tier, this can become discouraging because monthly credits are limited.

Features like better stalled-task detection, clearer progress indicators, and easier recovery from looping tasks would make the experience even smoother, especially in learning environments where students are experimenting and iterating frequently.

Final Thoughts

Hosting this workshop reminded me that students don't just want AI to write code; they want to understand how AI can help them become better software engineers.

Kiro's approach encourages developers to think beyond prompts and focus on planning, structure, and maintainability.

As AI development tools continue to evolve, I believe these engineering habits will become increasingly important.

I'm looking forward to exploring more advanced Kiro workflows in future workshops and hope to see the Kiro Students program expanded to include universities beyond its current list of participating institutions. There is tremendous enthusiasm for AI-assisted software engineering across Africa, and broader access would enable even more students to learn, build, and contribute.