How I Built SpecJam: a Multiplayer AI Spec Room with Kiro and Amazon Nova on Bedrock
SpecJam is a real-time room where humans and three AI teammates turn a messy brainstorm into a ready-to-build spec. Here is how I designed it, and how I used Kiro spec-driven development with Amazon Nova on Bedrock to build it for the Kiro Birthday Challenge, Day 2.
Introduction
Most brainstorms die in a document nobody wants to write up.
You spend an hour throwing ideas at a whiteboard, everyone leaves energized, and then the hard part just sits there: turning that mess into a clear plan someone can actually build. That gap between "great session" and "written spec" is where momentum goes to die.
For Day 2 of the Kiro Birthday Challenge , the brief was to build a multiplayer workspace where humans and AI agents feel like one team, not another chatbot. So I built a room that closes that gap. It is called SpecJam.
TL;DR* What: a live, multiplayer sticky-note room where humans and three AI teammates turn a brainstorm into a ready-to-build spec.
- Stack: React 19 and Vite on the front, Convex for the realtime backend, and Amazon Nova on AWS Bedrock powering the AI teammates.
- Built with: Kiro spec-driven development. Steering files taught Kiro my stack, and Kiro Specs turned the concept into requirements, design, and tasks.
- Repo: https://github.com/yogeshselvarajan/specjam
- Demo: https://youtu.be/7hrr_-E8R0g
What SpecJam actually does
SpecJam is a shared board. You and your teammates join from a link and drop ideas as sticky notes, exactly like a physical war room. The difference is who else is at the table: three AI teammates, each running on a different Amazon Nova model, each with one clear job.
You brainstorm together, the AI reacts in real time, it pushes back on weak ideas, and at the end it writes the spec for you. You walk out with a
requirements.md, design.md, and tasks.md, the exact format the Kiro IDE consumes.Meet the three AI teammates
| Teammate | Role | Model | What it does |
|---|---|---|---|
| Nova | Facilitator | Amazon Nova Lite | Reacts to every idea as it lands and clusters the board into themes |
| Sage | Skeptic | Amazon Nova Lite | Stays quiet until it spots a shaky assumption, then raises a hand and asks you to defend it |
| Scribe | Spec writer | Amazon Nova Pro | Synthesizes the surviving board into a spec: requirements, design, and tasks |
Sage is the one that makes it feel like a team. It does not spam the room. It flags the specific sticky notes worth a second look, waits for a human to acknowledge, and only then explains the concern. The AI earns its seat by disagreeing, not by agreeing with everything.
The collaboration flow
A room moves through a simple set of phases, and the owner drives the pace:
1
lobby -> braindump -> cluster -> vote -> skeptic -> spec -> done- Braindump: everyone adds ideas fast. Nova acknowledges each one.
- Cluster: Nova groups related notes into labelled themes.
- Vote: each person spends three dot-votes on what matters most.
- Skeptic: Sage raises hands on weak ideas. You read the concern and keep or cut.
- Spec: Scribe writes the final document from the high-signal board.
Under the hood: Convex plus Bedrock
The realtime piece is Convex. Every client subscribes to live queries, so the board, presence, votes, and AI messages update on every screen at once with no websocket code to write. When an idea lands or a phase turns, a Convex action calls Bedrock and writes the response straight back into the reactive database, which pushes it to everyone.
The AI calls use the Bedrock Converse API, which gives one consistent interface across Nova Lite and Nova Pro. Credentials live as backend environment variables, never in the browser:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import { BedrockRuntimeClient, ConverseCommand } from "@aws-sdk/client-bedrock-runtime";
export async function callBedrock(opts: {
model: "amazon.nova-lite-v1:0" | "amazon.nova-pro-v1:0";
systemPrompt: string;
userMessage: string;
}): Promise<string> {
const client = new BedrockRuntimeClient({ region: process.env.AWS_REGION ?? "us-east-1" });
const command = new ConverseCommand({
modelId: opts.model,
system: [{ text: opts.systemPrompt }],
messages: [{ role: "user", content: [{ text: opts.userMessage }] }],
inferenceConfig: { maxTokens: 1024, temperature: 0.4 },
});
const response = await client.send(command);
return response.output?.message?.content?.[0]?.text ?? "";
}Nova Lite handles the fast, frequent reactions and the clustering. Nova Pro does the heavier lifting for the final spec, where long-form synthesis matters. Splitting the work by model keeps the room responsive without paying for the big model on every keystroke.
How Kiro actually built this
This is the part I care about most, because Kiro was the build engine, not an autocomplete.
I started with Steering files to give Kiro persistent context.
tech.md locked the stack to Convex and Amazon Nova on Bedrock. structure.md set the file layout. convex-patterns.md captured backend conventions. agent-personas.md defined how Nova, Sage, and Scribe should behave. With that context always on, every generation matched my architecture instead of drifting.Then I used Kiro Specs to turn the concept into a plan. Kiro produced a
requirements.md in EARS notation, a design.md, and a tasks.md. I reviewed and refined those before a single line of app code existed, so the contract was clear up front.Finally, I ran spec-driven development: Kiro executed the tasks to generate the Convex backend, the schema and phase state machine, the three Bedrock agent actions, and the React frontend. The persona steering doc was even compiled into the system prompts the live agents use.
The result closes a loop I still find satisfying: an app built with Kiro Specs that itself generates Kiro specs. Its entire output is a spec folder another team can drop into their own
.kiro directory and start building. The full .kiro folder is committed in the repo, so you can read exactly how it was specified.What I learned
- Give the AI a role, not a personality. "You are a skeptic who flags assumptions" produced far more useful behavior than a generic helpful assistant.
- Signal beats noise. The single best UX decision was making Sage raise a hand and wait, instead of commenting on everything. Restraint is what made it feel like a teammate.
- Match the model to the job. Nova Lite for fast reactions, Nova Pro for synthesis. You do not need the biggest model for every call.
- Specs are not overhead. Writing the Kiro spec first made the build faster, because the AI and I were working from the same contract.
Build it yourself
The repo is public and MIT licensed:
- Code and full setup: https://github.com/yogeshselvarajan/specjam
- Demo video: https://youtu.be/7hrr_-E8R0g
- The challenge: https://kiro.dev/birthday/
- Kiro: https://kiro.dev/
You will need Node, a free Convex account, and Amazon Bedrock model access for Amazon Nova. The README walks through Convex setup and the three Bedrock environment variables, with no real secrets committed.
Wrapping up
SpecJam started as a simple question: what if the AI in the room did the part everyone dreads, the writing? Building it with Kiro turned that idea into a working MVP fast, and building it on Amazon Nova kept it responsive and cheap enough to run a live room.
If you try it, I would love to hear whether you let the AI skeptic cut your favorite idea.
Built by Yogesh Selvarajan. Find me on LinkedIn .
#BuildWithKiro #TeamKiro
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article