Kironomics: I Turned Kiro Into a Leaderboard for Its First Birthday
A gamified usage-tracking platform that ranks developers by how they actually use Kiro built with three silent hooks, a tamper-resistant credit reader, and a live leaderboard. Shipped for Kiro's 1-year anniversary
TL;DR
One year ago, on July 14, 2025, AWS launched Kiro the agentic IDE that pushed developers from "vibe coding to viable code." To celebrate its first birthday, I built Kironomics: a leaderboard that turns everyday Kiro usage into a friendly competition
It tracks your prompts, tool calls, session time, and the part I'm most proud of your real Kiro credit consumption, read straight from the IDE's own local database so the numbers can't be casually faked. Every developer gets a score, a title (from 🌱 Kiro Novice to 🏆 Session Immortal), badges, and a rank against everyone else in the community.
The whole thing runs on three lightweight Kiro hooks, an Express backend, and a React dashboard. Zero overhead while you work. One network call per session. And it's live for the whole AWS User Group Madurai community to compete on.
Here's how I built it and the design decisions that kept it honest
Live now: awsugmdu.in/kironomics
The Spark: Meta's "Claudeonomics"
Earlier this year, a story made the rounds in engineering circles. A Meta employee built an internal leaderboard nicknamed "Claudeonomics" that ranked 85,000 employees by how many AI tokens they consumed. It handed out titles like "Token Legend" and "Session Immortal," and it went viral internally before leadership pulled it.
The idea stuck with me. Not the corporate-surveillance part that's what got it shut down — but the playful, community-driven version of it. What if developers could opt in to a leaderboard, on their own accounts, purely for fun and bragging rights? What if using your favorite IDE more felt like leveling up in a game?
Kiro's first birthday felt like the perfect excuse to build exactly that.
The Problem
If you want to gamify IDE usage, you run into four hard questions immediately:
- What do you measure? Lines of code is a dead metric. Raw prompts are easy to spam. You need signals that reflect real engagement
- How do you collect it without slowing people down? Nobody wants their IDE lagging because a tracker is phoning home on every keystroke.
- How do you keep it honest? The moment there's a leaderboard, someone will try to game it. If the numbers are trivially fakeable, the whole thing is meaningless.
- How do you make it fun, not creepy? This is the line Meta crossed. It has to be opt-in, transparent, and personal — a scoreboard, not a surveillance tool.
Kironomics is my answer to all four.
Why These Signals
I settled on four things worth tracking, each capturing a different dimension of "using Kiro well":
- Prompts — how often you're actually directing the agent.
- Tool calls — how much real work the agent does on your behalf (file reads, edits, searches, commands).
- Session time — how long you stay in flow.
- Credits consumed — the single most honest signal, because it maps to real metered Kiro usage that the IDE reports from AWS billing.
That last one is the anchor. Prompts and tool counts live in temporary files that a determined user could edit. But credit usage comes from Kiro's own internal state — synced from the billing backend — so it's the tamper-resistant ground truth the rest of the system leans on.
Architecture
The whole system is three layers: hooks on your machine, a backend that scores, and a dashboard that shows off.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
┌──────────────────────────────────────────────────────────────────┐
│ YOUR MACHINE │
│ │
│ ┌──────────────┐ auto-writes ┌──────────────────────────┐ │
│ │ Kiro IDE │ ────────────────► │ Local IDE State │ │
│ │ (you work │ │ • current usage │ │
│ │ normally) │ │ • plan limit │ │
│ └──────────────┘ │ • reset date │ │
│ │ └──────────────────────────┘ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ 3 Silent Kiro Hooks (zero overhead during work) │ │
│ │ │ │
│ │ 1️⃣ Tool Counter → counts every tool the agent runs │ │
│ │ 2️⃣ Prompt Counter → counts every message + start time │ │
│ │ 3️⃣ Session Reporter (fires when the agent stops): │ │
│ │ • reads the local counters │ │
│ │ • reads the IDE's real credit usage │ │
│ │ • sends ONE request to the backend │ │
│ │ • cleans up after itself │ │
│ └──────────────────────────────────────────────────────────────┘ │
└───────────────────────────────────┬────────────────────────────────┘
│ 1 HTTPS request per session
▼
┌──────────────────────────────────────────────────────────────────┐
│ KIRONOMICS BACKEND │
│ • Validates who you are │
│ • Detects your plan (Free / Pro / Pro+ / Power) │
│ • Works out how many credits this session used │
│ • Calculates your score + updates your streak │
│ • Runs honesty checks │
└───────────────────────────────────┬────────────────────────────────┘
│ leaderboard + metrics APIs
▼
┌──────────────────────────────────────────────────────────────────┐
│ REACT DASHBOARD │
│ 🏆 Leaderboard — rank, score, title, plan badge │
│ 📈 Personal Metrics — credits used, burn rate, days left │
│ 🔥 Heatmap — a year of activity, GitHub-style │
└──────────────────────────────────────────────────────────────────┘The elegant part: nothing happens over the network while you code. The counters just tick up in the background. Only when the agent finishes a task does the reporter fire once, bundle everything up, and send a single request. Your IDE never waits on Kironomics.
How a Session Flows (Start to Finish)
Let me walk through one real session, end to end:
- You type a prompt. The prompt hook quietly bumps a counter and records the start time. You see nothing.
- Kiro does its thing — reads files, edits code, runs commands. Each tool call bumps a second counter. Still invisible.
- The agent finishes. This is the moment everything happens. The session reporter:
- reads the two counters,
- opens Kiro's own local state to read your real credit usage and plan,
- calculates how long the session lasted,
- sends one bundled request to the backend,
- deletes its temporary files so the next session starts clean.
- The backend receives it, figures out your plan, calculates how many credits this session actually consumed, updates your total score, refreshes your streak, and runs its honesty checks.
- You open the dashboard and see your new rank, updated credits bar, and — if you crossed a threshold — a shiny new badge.
That's the entire loop. Passive collection, one batched send, instant leaderboard
Five Design Decisions That Mattered
1. Read credits from the IDE, not from the user
The temptation was to just count prompts and tools and call it a day. But those are easy to inflate. Kiro already knows and stores locally exactly how many credits you've burned this billing cycle, synced from AWS. By reading that directly, the scoring anchors to a number the user didn't write. It's the difference between "trust me, I worked hard" and "here's the receipt."
2. One request per session, never during work
Early on I considered streaming events live. Bad idea — it adds latency and network chatter to every action. Batching everything into a single request at
agentStop means the tracker is effectively free while you code. The IDE experience is untouched.3. A Knowledge-Base Power, not a background server
The first version shipped as a Power with its own MCP server. It worked on my machine and broke everywhere else, because a server launched from an unpredictable working directory couldn't find its own files. The fix was to flip the whole model: make the Power pure documentation that Kiro reads and acts on. Kiro itself sets up the hooks by following instructions. No server to crash, no paths to resolve, works in any workspace. Simpler and more robust.
4. Fair from the moment you join
A subtle trap: when someone installs Kironomics, their Kiro account might already have thousands of credits used this month. If I counted all of that on their first session, they'd instantly rocket to the top — and the honesty checks would (correctly) flag them as suspicious. The fix is a baseline-on-install rule: the first session records a starting point and counts as zero. From then on, only new usage counts. Everyone starts fair, like installing a fitness tracker — it counts steps from today, not your whole life.
5. Detection over prevention
You can't stop someone from editing a local file. That's just reality on the user's own machine. So instead of trying to build an unbreakable cage, the backend watches for patterns that can't happen in real usage — activity with no corresponding credit consumption, impossible ratios, and other tells. Flagged accounts quietly drop off the leaderboard. It's the same philosophy GitHub uses for its contribution graph: make cheating detectable and pointless, rather than impossible.
Keeping It Honest
Because there's a leaderboard, someone will try to game it. My approach has layers:
- The credit anchor. Real credit data comes from Kiro's own state, not user input.
- Baseline on install. No retroactive credit for usage before you joined.
- Pattern checks. The backend flags sessions where the activity and the credit consumption don't add up.
- Optional verification. Power users can cross-reference their usage against real AWS billing data to earn a ✅ Verified badge — proof their numbers are legit.
I'm deliberately not publishing the exact thresholds — that would just be a cheat sheet. The point is that the system rewards actually using Kiro, which, conveniently, is the whole goal.
The Progression System
Half the fun is watching yourself climb. As your score grows, your title evolves:
| Title | Icon |
|---|---|
| Kiro Novice | 🌱 |
| Prompt Apprentice | 📝 |
| Hook Wrangler | 🪝 |
| Tool Wielder | 🔧 |
| Session Warrior | ⚔️ |
| Token Legend | 👑 |
| Session Immortal | 🏆 |
And along the way you unlock badges for milestones your first session, your hundredth tool call, a seven-day streak, a marathon coding session, and more. Streaks are the secret sauce: nothing pulls you back into the IDE like not wanting to break a run
Plan-Aware Metrics
Kironomics doesn't just rank you it gives you a genuinely useful personal dashboard. Because it reads your plan and credit usage, it can show:
- Plan detection — Free, Pro, Pro+, or Power, recognized automatically
- Credits used vs. your monthly limit, with a progress bar
- Burn rate — your average daily credit consumption
- Days remaining — a projection of when you'll hit your limit at the current pace.
- Reset countdown — how long until your monthly credits refresh.
It turns out a leaderboard is a great excuse to also build the credit-tracking dashboard Kiro users actually want.
The Hard Parts (War Stories)
No build is clean. Here are the ones worth sharing:
The Power that only worked on my machine. As mentioned, the MCP-server approach couldn't resolve its own file paths when launched from a different workspace. Tools showed up as "unavailable" everywhere except my dev folder. Rebuilding it as a documentation-driven Power fixed it for good.
The hooks that wouldn't fire. After setup, the tool counter stubbornly refused to trigger — the prompt counter worked, but tools weren't being counted. The culprit: Kiro registers hooks at startup, so a freshly created hook needs a full IDE restart to activate. Once restarted, everything clicked.
The first-session inflation bug. A test user who'd been using Kiro for weeks installed Kironomics and instantly got flagged as a cheater because their entire month's credit history got attributed to one session. That's what led directly to the baseline-on-install design decision. A bug became a feature.
Finding the credit data at all. The most interesting detective work was locating where Kiro stores its real usage numbers. It's tucked inside the IDE's local state — updated periodically from the billing backend. Once I found it, the whole "tamper-resistant" story became possible.
What's Live
| # | Capability | Status |
|---|---|---|
| 1 | Silent activity tracking (3 hooks) | ✅ Live |
| 2 | Real credit reading from IDE state | ✅ Live |
| 3 | Plan detection (Free/Pro/Pro+/Power) | ✅ Live |
| 4 | Score, titles, and badges | ✅ Live |
| 5 | Daily / weekly / all-time leaderboards | ✅ Live |
| 6 | Personal metrics + burn rate | ✅ Live |
| 7 | 365-day contribution heatmap | ✅ Live |
| 8 | Streak tracking | ✅ Live |
| 9 | Honesty / anti-cheat checks | ✅ Live |
| 10 | Optional AWS billing verification | ✅ Live |
| 11 | One-command Power setup | ✅ Live |
The leaderboard is running right now for the AWS User Group Madurai community at awsugmdu.in/kironomics
The Stack
- Backend — Express.js, with a lightweight scoring and fraud-detection core.
- Frontend — React + Vite + Tailwind, authenticated with Amazon Cognito.
- Collection — three Kiro hooks plus a small Python reporter, all created automatically by the Power.
- The Power — pure documentation (a Knowledge-Base Power), so it works in any workspace with no server to run.
Everything is designed to be self-hostable. Point the frontend at your backend, wire up a Cognito pool, and you've got your own community leaderboard.
What I Learned
- Anchor your metrics to something the user can't write. The credit data is what makes Kironomics honest. Everything else is supporting cast.
- Batch, don't stream. One request per session keeps the IDE fast and the architecture simple.
- Documentation-driven Powers beat servers for anything that just needs to set up files. Fewer moving parts, works everywhere.
- Bugs become features. The first-session inflation bug directly produced the fairest part of the design.
- Gamification works when it's opt-in and personal. Meta's version got shut down for being surveillance. The same mechanics, offered as a voluntary scoreboard, are just fun.
Happy Birthday, Kiro 🎂
A year ago Kiro set out to take developers "from vibe coding to viable code." Kironomics is my small thank-you — a way for the community to celebrate how much we've all built with it, and maybe compete a little while we're at it.
Go climb the board: awsugmdu.in/kironomics
Install the Power, run "Set up Kironomics," and start earning your first badge. See you on the leaderboard. 🏆
Built by Logesh AWS Community Builder [AI] · AWS User Group Leader, Madurai
Vivek Raja AWS Hero [AI] · AWS User Group Leader, Madurai
Poobalan AWS Community Builder [serverless] · AWS User Group Leader, Madurai
Vivek Raja AWS Hero [AI] · AWS User Group Leader, Madurai
Poobalan AWS Community Builder [serverless] · AWS User Group Leader, Madurai
Any opinions in this article are those of the author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article