Three things I want to explore in this post
This isn’t a “how to code” tutorial. I’m using a tiny hack project as an excuse to share some hands-on practice and thoughts on building products with a new tool—Kiro—in the AI era.
The main character of this story is Soul Cocktail.
Try it here: [https://693227447c34a69c0a4bcf8c--willowy-florentine-e37d0c.netlify.app/]
Feel free to click around. If you have ideas or feedback, I’d genuinely love to hear them.
It started from a very real moment. At a re:Invent event, a bartender asked me:
“What would you like to drink?”
…and I froze. I couldn’t answer.
Later, we took that exact scenario and built a small “order cocktails by mood” app with Kiro in one night. The next day, I kept polishing it with Kiro and shipped it as a shareable webpage.
Around this small project, I want to talk about three things:
- Background & build process: How did Soul Cocktail get made under the constraints of “a little tipsy + time-limited + Kiro only”?
- Reflections afterward: Why did such a “not-that-complex” app win the on-site voting? And how did that change the way I think about building products and developing in the AI era?
- Kiro’s capabilities & how I used it: How exactly did I plug Kiro into a local project this time? Beyond vibe coding, what other capabilities do I think are worth digging into?
1. The background and build process of a small project
1) Background: the moment I got stumped by a bartender
At a re:Invent event, I was asked by a bartender:
“What would you like to drink?”
I blanked out. Every cocktail on the menu looked gorgeous, but my brain only had one sentence:
“I want something to drink today, but I don’t know what that drink is called.”
It’s such a common scenario:
you have emotions, you have preferences, but the menu isn’t organized by “mood.” You’re forced to choose from a long list—and in that moment, what you really need is someone who can quickly understand you.
That night’s event rules were also pretty special:
Everyone grabs a drink and relaxes first;
Within a limited time, use Kiro for vibe coding and build a demo from scratch;
At the end, everyone votes for their favorite project.
We were the only all-women team there.
We didn’t try to squeeze our brains for a “super advanced” technical topic. We kept it simple and close to the theme and the moment:
That “getting stuck” feeling when ordering a drink can’t be just my problem—so why not build a small thing that solves exactly that?
2) Ordering by mood: the core experience of Soul Cocktail
So the goal of Soul Cocktail became crystal clear:
When you need to order a cocktail but can’t put it into words, let a small app help you order based on your mood.
In Kiro, I described the experience roughly like this:
A dark UI with a “midnight bar” vibe;
Floating mood bubbles on the screen; the user can pick up to 3;
After tapping Generate, a brief “Mixing your soul cocktail…” moment;
Then a final Soul Cocktail card, including:
A slightly poetic cocktail name (e.g., Silver Pulse);
The selected moods mapped into “ingredient percentages”;
A short explanation of why this drink fits you today;
A tiny Daily Spark blessing.
During this process, I didn’t start with “create a new project and handwrite all the boilerplate.” Instead, I followed a path that fits Kiro’s strengths better:
Create an empty local folder: soul-cocktail/;
Open it in Kiro and let it initialize the frontend project for me;
From there, I went into vibe coding:
I was responsible for: overall experience, page structure, mood selection rules, what goes on the result card, the vibe and copy tone;
Kiro was responsible for: component structure, state management, styling, simple animations—and continuously refactoring based on my feedback.
On the first night, I held one rule tightly:
Make the core flow work first: Pick moods → Mix → Get result.
3) Live demo: not me presenting—everyone playing
For the demo, I didn’t stand on stage and walk through implementation details. I did something much simpler:
I invited people to walk up to the screen, pick their own mood bubbles, press Generate, and watch “today’s you” get mixed into a Soul Cocktail—then see their reactions to the Daily Spark line.
Since the final result depended on audience voting, many people had already personally experienced “ordering by mood” before they voted.
For them, it wasn’t an abstract demo anymore. It was a mini experience with their own inputs and their own outcomes.
And in the end—among a bunch of technically “heavier” projects—Soul Cocktail took first place that night.
2. Reflections afterward: what this small project made me rethink about building in the AI era
Back at the hotel, and even after I returned home, I kept circling one question:
Why did this “not-that-complex” little app win in that kind of setting?
1) People first, then technology
I think there were two key reasons.
First, it started from a real user moment.
We didn’t invent a scenario just to show off. It was something many people could genuinely run into right then and there. We weren’t “teaching you about cocktails”—we were solving one very specific problem:
“What mood am I in right now?”
“Then today, I’m that drink.”
Second, the experience was simple and low-friction.
You instantly understand how to play. You click a few times and get a result. And that result fit the environment perfectly—people were literally already drinking.
In other words, I wasn’t starting from tech. I started from how I felt in that moment as a customer, and then used Kiro to help me turn that into something real.
2) Build first, then polish
Another thing that really influenced me was the pace.
With limited time, nobody’s giving you a full day to design architecture properly. So my choice was:
Get an end-to-end experience first.
Make the “mood → cocktail” path work.
Leave details and optimizations for later.
On day two, I used Kiro to do two follow-up things:
Clean up the code and component structure, so it wasn’t just a demo but a maintainable project;
Fine-tune UI and interaction rhythm—background colors, transitions, button feedback;
And then have Kiro walk me through “the simplest shipping path,” turning a local demo into a shareable webpage.
It’s honestly a very simple method:
Build it first. Let real users try it. Then keep going.
3) In the AI era, what truly needs to change?
Zooming out a bit, the biggest takeaway Soul Cocktail gave me is this:
With an AI IDE like Kiro, we can completely redistribute the work between humans and tools.
In this project, I felt it very clearly:
Kiro can handle more of: code generation, refactoring, styling details, build config, deployment guidance;
Humans can spend more energy on:
spotting real-life moments;
responding with simple, direct product forms;
feeling user reactions, making decisions, and choosing trade-offs.
A lot of AI discussion stops at “efficiency”—one person can write more code and do more work.
But for me, what matters more is that tools like this let us:
turn ideas into runnable things faster;
keep “people with ideas” from getting blocked by low-level details;
and they force us to ask:
When so much detail work is automated, where should human value show up more strongly?
For me, the answer is probably:
understanding people, understanding situations, making decisions, and storytelling.
3. Kiro’s capabilities and how I used it this time
Lastly, a quick note on how I used Kiro this time—and what I think is worth exploring further.
※You can download Kiro from the official downloads page:
[https://kiro.dev/]
1) What I actually used this time
Local project awareness
Starting from an empty local folder, I let Kiro initialize the project, generate components, and manage state—rather than doing a “single-file cloud toy.” That made refactoring and deployment feel much more natural later.
Vibe coding: conversational coding + iterative edits
I barely did the traditional “hard-code from an empty editor” thing.
Instead, I kept telling Kiro:
“I want this structure, this flow, this feeling.”
It wrote and revised. I judged and chose.
To make this smoother, I included a local .kiro directory in the project and opened it in Kiro, so it always had the project context and rules handy.
Deployment guidance
When I asked, “It runs locally—what’s the simplest way to ship it?” Kiro gave a clear path:
push to a repo → pick a hosting platform → set build/output → deploy,
and helped with small annoying details like build commands and output directory names.
But after talking more with Kiro, I found an even faster way for this particular setup:
simply drag the project folder (the one containing
index.html) into the drop area at the bottom of the Netlify Projects page, and Netlify will automatically deploy it as a website.
2) What I want to explore more next
Kiro is an Agentic IDE released by AWS that supports spec-driven development.
Roughly speaking, spec-driven development means:
Write the Spec first—
what problem you’re solving, inputs/outputs, steps, edge cases—
then let the agent break down tasks and implement strictly following the spec,
instead of relying on ad-hoc prompts and human memory at every step.
To support that, Kiro provides two core capabilities: Spec and Hook.
Spec
You write, in a document-like format, the purpose, I/O, happy path, and key constraints for a class of tasks—and Kiro uses it as long-term reference.
Next time you build or modify related features, you don’t need to re-explain everything. You can just say: “Follow this Spec.”
Hook
You define rules like “when X happens, automatically do Y,” and attach them to IDE behaviors. For example:
run certain checks when saving files;
auto-generate corresponding tests when code changes in specific directories;
validate compliance with a spec before commit.
This upgrades part of your workflow from “people must remember to do this” to “the IDE just does it.”
For Soul Cocktail, I mainly used vibe coding plus a local project workflow. Spec and Hook were only lightly touched.
But for day-to-day work and personal projects, I want to deliberately turn repeated workflows, product rules, and team conventions into Specs—then combine them with Hooks—so these experiences become reusable, shareable “spec assets” inside Kiro, instead of living only in my head.
Epilogue: starting with one drink, and moving on to more “small problems, small projects”
After returning to everyday life, Soul Cocktail left me with a very direct change:
I started paying more attention to those little “stuck” moments in my life—
booking restaurants while traveling, jotting down notes I can’t find later, not knowing what to prioritize first—
and I used a similar approach to build a few small projects for myself, using Kiro and other AI tools to ship them quickly.
They’re all small. Some are tools only I might ever use. But they keep reminding me of something:
AI doesn’t just mean “faster code.” It’s also a chance to keep asking myself:
how many more of these “just-right” little things can I build for my life—and for other people’s lives?
Soul Cocktail is just one drink.
Next, I hope to keep using Kiro and other AI tools to turn more “small problems, small projects” into real, usable things—and share those practices with more people.
Top comments (0)