DEV Community: Sukriti Singh

[Boost]

Sukriti Singh — Thu, 14 May 2026 11:43:24 +0000

Sukriti Singh

May 14

Why I Refused to Settle for a 97% Code Score

#ai #webdev #programming #javascript

Comments

4 min read

Why I Refused to Settle for a 97% Code Score

Sukriti Singh — Thu, 14 May 2026 11:40:10 +0000

“It Works” Is No Longer Enough. Perfection Is the New Leaderboard.

I recently participated in VibeCode Arena’s “Beat the Heat” challenge, and what I expected to be a casual frontend game project somehow turned into one of the most unexpectedly intense coding experiences I’ve had in a long time.

The prompt itself sounded simple enough: build a client-side camel racing game using HTML, CSS, and vanilla JavaScript. The camel needed to race through a desert while avoiding obstacles and reaching an oasis before time ran out. It felt like the kind of challenge you sit down with for an evening, finish in a few hours, and move on from.

At least, that’s what I thought in the beginning.

I built the first version fairly quickly. The camel movement worked, the obstacles spawned correctly, collision detection was smooth, and the desert background scrolled continuously across the screen. From a user perspective, the game felt complete. It was responsive, playable, and honestly quite fun. I submitted the project with a decent amount of confidence, expecting a strong evaluation score.

The system came back with a 97%.

Now, objectively speaking, 97% is an excellent score. In most environments, that would already be considered polished work. But the strange thing about competitive coding platforms is that they completely change your relationship with “good enough.” That missing 3% immediately started bothering me far more than it should have.

The more I looked into the evaluation breakdown, the more I realized something important: the platform wasn’t simply judging whether my game worked. It was judging how well the project had been engineered underneath the surface.

That distinction completely changed the experience for me.

The deductions weren’t coming from broken gameplay or missing functionality. Instead, they came from architectural and engineering decisions that most developers, including me, often ignore during smaller projects. For example, I had used synchronous script loading in my HTML file. The game still ran perfectly fine, but technically the browser was blocking rendering while loading JavaScript files. I also had a small inline script handling the startup logic. To me, it seemed harmless because it was only a few lines, but the evaluator flagged it as poor separation of concerns and a maintainability issue.

Then there was accessibility, which honestly became the biggest wake-up call during this challenge. I had built the game entirely from the perspective of a typical desktop user with a mouse and a screen. I hadn’t thought about keyboard navigation, screen readers, ARIA labels, or live status regions for score updates. The evaluator did. Seeing accessibility affect my score made me realize how often developers unconsciously treat it like an optional feature rather than a core part of frontend engineering.

Another issue was startup resilience. If something failed during initialization, the game would simply show a blank screen instead of failing gracefully. Again, the game worked under ideal conditions, but the evaluator wasn’t rewarding ideal-condition engineering. It was rewarding robustness.

That was the moment when the challenge stopped feeling like a game development exercise and started feeling like a genuine engineering competition.

I went back into the project, not to redesign the gameplay, but to rethink the structure of the code itself. I separated all initialization logic into a dedicated main.js file, removed inline JavaScript entirely, and switched every script to deferred loading. I added proper error handling around startup so the user wouldn’t be left staring at a blank page if something failed. I cleaned up unnecessary DOM operations, improved the accessibility layer, and made the overall architecture feel more modular and intentional.

What surprised me was how addictive the optimization process became. Once you start seeing scores move in real time, you begin obsessing over details you normally wouldn’t even think about. One small accessibility improvement changes the evaluation. One unnecessary render removed improves performance. One architectural cleanup removes a code quality warning. The feedback loop is incredibly effective because every improvement feels measurable.

At some point, I realized I was spending more time refining the engineering than actually building the game itself.

And honestly, that’s what makes VibeCode Arena interesting.

The platform quietly exposes the difference between code that merely functions and code that is thoughtfully engineered. In a time where AI tools can generate working applications within minutes, challenges like this highlight something that still matters enormously: refinement. AI can help generate a foundation quickly, but optimization, maintainability, accessibility, and architectural thinking still require human judgment.

That became especially obvious while competing on a live leaderboard alongside both developers and AI-generated solutions. The pressure of seeing rankings update in real time changes how you think. You stop treating frontend details casually because suddenly every tiny decision has visible consequences. Script loading strategies matter. Accessibility matters. Error handling matters. Performance matters.

The funny part is that all of this happened because of a browser game about a camel running through the desert.

But that’s exactly why the challenge works so well. The prompts themselves are playful and approachable, yet underneath them is a surprisingly deep engineering exercise. You enter expecting a fun coding challenge and end up getting an unexpected lesson in frontend architecture and optimization discipline.

By the time I finally pushed my score higher and saw the evaluation bars turn green, the satisfaction had very little to do with the camel game anymore. It came from knowing the project had evolved from “something that works” into something intentionally engineered.

And I think that’s the bigger lesson these kinds of platforms reveal. Functional code is becoming easier and easier to generate. The real differentiator now is the ability to refine that code into something stable, performant, accessible, and maintainable.

That last 3% taught me far more than the first 97% ever did.

If you’re someone who enjoys frontend engineering, optimization challenges, browser game development, or simply testing how clean your coding habits really are under pressure, I genuinely recommend trying VibeCode Arena’s “Beat the Heat” challenge. Just don’t be surprised if you find yourself obsessing over tiny percentages and refreshing the leaderboard far more often than you planned.

👉 https://vibecodearena.ai/beattheheat?page=1&pageSize=10&sortBy=responses&sortOrder=desc&utm_source=external&utm_medium=vc5&utm_campaign=beattheheat

I Opened an AI Coding Challenge “Just to Look.” A Few Hours Later, I Was Completely Invested in the Leaderboard.

Sukriti Singh — Wed, 13 May 2026 09:03:34 +0000

What started as a simple AI-generated ice cream game somehow turned into one of the most weirdly competitive coding experiences I’ve had in a long time.

I joined this ongoing AI coding challenge with extremely low expectations.

Not fake low expectations either. Genuine ones.

At this point, the internet is flooded with AI-generated projects that all somehow look identical after five minutes. Somebody discovers a new model, generates a landing page with glowing buttons and a gradient background, adds glassmorphism cards floating around in space, and suddenly everyone in the comments starts talking like software development has permanently changed overnight.

Most of those projects look impressive right up until you actually interact with them.

Then you realize there’s usually not much underneath.

So when I first opened this challenge, I honestly expected more of the same. A few decent experiments. Some overdesigned dashboards. Maybe a couple of interesting ideas are buried somewhere in the middle.

Then I looked at the leaderboard.

And saw somebody sitting at 96.5.

That immediately changed the feeling of the entire thing.

Because scores like that make it obvious people are no longer treating the challenge casually. Once the leaderboard starts climbing into the 90s, the atmosphere shifts completely. Suddenly, everybody is trying to outdo each other. The projects stop feeling like random experiments and start feeling like actual competition.

And honestly, that’s where the challenge becomes dangerously addictive.

You tell yourself you’re only opening the leaderboard for a minute just to see the newest submissions. Then somebody uploads something absurdly polished, and now your brain immediately starts comparing it to every other project you saw earlier.

A few hours later, you somehow know the names of people climbing the rankings, you’re checking scores multiple times a day, and you’re emotionally invested in strangers competing through browser games and UI animations.

Which sounds ridiculous when typed out like that.

But it’s true.

What surprised me most wasn’t even the AI itself. At this point, everybody already knows AI can generate code, design interfaces, and build basic projects quickly. That part stopped feeling shocking a while ago.

The surprising part was how quickly people started figuring out how to make the projects actually feel good.

That’s a completely different skill.

Because generating something functional is easy now. Generating something memorable is much harder.

And after spending time scrolling through the challenge submissions, that difference becomes painfully obvious almost immediately.

Some projects technically work, but they still feel emotionally empty after a few seconds. You interact with them once, think “okay, cool,” and instantly forget they existed.

Other projects have this weird energy where you can tell somebody is obsessed over the details.

The animations feel smoother.

The interactions feel responsive.

The pacing feels intentional.

The UI reacts properly.

The transitions feel satisfying.

The project stops feeling like “AI-generated output” and starts feeling like an experience somebody cared about shaping.

That gap fascinated me way more than I expected.

Because I think people still underestimate how much personality matters even in AI-assisted development. The projects standing out on the leaderboard usually are not the ones trying hardest to sound technically impressive.

They’re the ones with momentum.

The ones with polish.

The ones with some kind of identity.

That becomes very obvious once you start comparing submissions side by side for long enough.

And honestly, the challenge itself unintentionally exposes something really interesting about the current state of AI creativity.

Everybody participating has access to similar tools.

Most people are using variations of the same models.

Most people have access to similar prompting capabilities.

Yet the results vary massively.

Some entries feel generic instantly.

Others feel crafted.

That difference is not coming from the AI alone.

It’s coming from that direction.

I think that’s why the leaderboard became so interesting to watch after a while. It almost feels less like a coding competition and more like a live demonstration of how differently people think creatively when given the same tools.

Some people focus entirely on visuals.

Download the Medium app
Some focus on interactions.

Some focus on gameplay loops.

Some focus on humor or presentation.

And the really strong submissions usually combine several of those things together in a way that makes the project feel alive instead of merely functional.

That’s probably the biggest shift I noticed while following the challenge.

Not that AI is replacing creativity.

If anything, the challenge made creativity feel more important.

Because once the technical barrier lowers slightly, people immediately start competing through ideas, taste, polish, pacing, responsiveness, and emotional impact instead.

The competition simply moves somewhere else.

And honestly, watching that happen in real time feels much more interesting than most of the usual conversations happening around AI online right now.

Outside spaces like this, AI discussions often become repetitive almost immediately. It’s always the same cycle of arguments about whether AI will replace developers, destroy industries, or eliminate the need for creative work.

Meanwhile, inside this challenge, people are too busy trying to build increasingly polished projects to care about those debates.

That contrast stood out to me constantly while scrolling through the leaderboard.

Nobody there looked passive.

Nobody looked replaced.

If anything, people looked hyper-motivated.

Every few hours, somebody uploads something smoother, cleaner, or more creative than before, and suddenly everyone else wants to improve their own work again.

The challenge accidentally creates this feedback loop where people keep pushing each other creatively without even realizing it.

That’s what makes it difficult to stop checking.

Because the leaderboard never really feels stable.

The quality keeps evolving in real time.

And the higher the scores climb, the more absurd the submissions start becoming.

Some of the projects genuinely do not feel like things built inside a short online challenge anymore. They feel like early versions of products that people could realistically continue developing afterward.

That’s honestly the part that stayed in my head the most after spending time with the challenge.

Not the individual tools.

Not the prompting tricks.

The speed.

The speed at which ideas become interactive experiences now feels completely different from even a year ago.

Not that long ago, most AI-generated projects still had that unmistakable “template” feeling attached to them. You could usually identify them immediately because they all shared the same polished-but-empty aesthetic.

Now the gap between “generated” and “crafted” is becoming much blurrier.

Some entries still feel obviously generic.

But others genuinely have personality.

That feels new.

You can almost watch people learning in real time that successful AI-assisted development has less to do with generating more code and more to do with shaping the experience properly.

That’s why the strongest submissions usually are not the most technically complicated ones.

They’re the ones people actually remember afterward.

And honestly, I think that might end up becoming one of the most important skills in this entire AI era.

Not pure technical execution.

Taste.

The ability to recognize what feels good, what feels memorable, and what makes people emotionally react to something instead of instantly forgetting it.

Because once everybody gains access to powerful generation tools, those softer creative decisions suddenly matter much more than expected.

The leaderboard in this challenge almost feels like a live scoreboard measuring that shift happening in public.

And maybe that’s why the whole thing became unexpectedly addictive to watch.

At first, I thought I was opening another AI coding event.

A few hours later, I realized I was watching people compete creatively in a completely different way than traditional coding competitions usually allow.

Not purely through algorithms or technical difficulty.

But through responsiveness, polish, personality, interaction design, visual feel, pacing, and experimentation.

That combination creates something much more interesting than I expected.

And honestly, I think this is still only the beginning.

If you’re curious, the challenge is still ongoing, and the leaderboard keeps changing. Some of the submissions are genuinely wild to scroll through now:

Challenge link: https://vibecodearena.ai/beattheheat?page=1&pageSize=10&sortBy=responses&sortOrder=desc&utm_source=external&utm_medium=vc5&utm_campaign=beattheheat

Because if people are already building projects scoring above 96 in public AI-assisted challenges right now, then the next few years of internet creativity are probably going to get very weird, very quickly.

This AI App Looked Ready to Ship. It Was Hiding a Critical Security Flaw.

Sukriti Singh — Tue, 12 May 2026 06:58:36 +0000

I ran a simple VibeCode Arena duel, voted confidently based on what I saw, and then watched the evaluation metrics expose how little of the important stuff I had actually checked.

I nearly trusted an AI-generated app this week, much faster than I should have, and what bothered me afterward was how normal that trust felt in the moment.

I opened the preview, clicked around, saw that everything responded the way it was supposed to, and within less than a minute, I had already mentally filed it under yeah, this seems usable. There was no hesitation there. No deeper inspection. Just a quick visual pass and a growing sense that the output was probably fine.

That confidence lasted until the evaluation metrics loaded and made it painfully obvious that I had reviewed the wallpaper while ignoring the foundation.

This came from a Duel I ran on VibeCode Arena. Same prompt, two models generating side by side, blind vote before the platform reveals what is actually going on under the hood.

The prompt itself was straightforward: build a Tech Debt Tracker using HTML, CSS, and vanilla JavaScript. Single-page app. Let the user add debt items, assign severity, and track overall technical risk through a Debt-O-Meter.

Nothing about that should have been especially dramatic. It is the kind of internal developer utility AI models are usually pretty comfortable producing, which is probably why both outputs looked surprisingly polished at first glance.

Both had dark interfaces, clean card layouts, working forms, severity labels, and a visible progress indicator. In other words, they both looked finished enough to make a fast reviewer feel safe.

I voted for Gemini 2.5 Flash.

Not because the other output looked terrible, but because this one felt slightly tighter in all the ways that create instant visual confidence. The spacing was cleaner, the Debt-O-Meter interaction felt smoother, and the whole thing gave off the impression that more care had gone into it.

So I voted pretty comfortably.

What I did not realize at that point was that I had not actually voted on software quality. I had voted on presentation quality, and those are not the same thing at all.

The first evaluation panel I opened was for the output I did not vote for. Overall score: 92 percent. Still sounds respectable until you scroll into the issue breakdown.

Critical security issue: Potential Cross-Site Scripting vulnerability in script.js.

Major correctness issue: Unhandled Exception in JSON Parsing.

Major accessibility issue: text and background contrast failure.

Then eight smaller code quality flags underneath all of that.

I remember stopping at the XSS line because there was absolutely nothing in the rendered preview to suggest the app posed a browser-side injection risk. It looked like a normal, harmless utility tool. Functional. Stable. Completely unthreatening.
That was the disturbing part.

Cross-Site Scripting is not a cosmetic warning you casually wave away. If user input is handled lazily enough, that opens the door for injected scripts to run inside another user’s browser session. Session theft, forced redirects, malicious payload execution — all the usual things that become very real very quickly once unsafe rendering gets into the mix.

And none of that was visible from the outside.

I keep repeating that because it is the whole lesson here: the preview looked fine. Completely fine.

So naturally, I opened the metrics for the output I voted for, expecting at least a cleaner result there. It did score 93 percent overall, and Security came back at a reassuring 100, which looked good for exactly one second.

Then the rest of the breakdown loaded.

There was a blocker-level CSS Syntax Error in style.css, three separate major accessibility issues, and a much weaker Code Quality score than I had expected from the output I had just felt so sure about.

So the “better” app was not actually clean either. It was simply failing in a different set of places that the preview had done a very good job of hiding.

That somehow made the whole thing worse, because now this was no longer about one flawed output slipping through. This was about me feeling confident after checking the wrong layer entirely.

One AI Model Scored 99. I Still Voted for the One That Scored 95.

Sukriti Singh — Tue, 12 May 2026 06:43:01 +0000

Claude scored higher. Llama felt better in the browser. The harder part was figuring out which one actually mattered.

One AI model scored 99. I still voted for the one that scored 95.

That should have made no sense.

The higher-scoring build was technically cleaner, passed almost every automated evaluation check, and looked like the obvious winner on paper. The lower-scoring one came back with flagged quality issues, accessibility deductions, and enough small implementation compromises that it should have been easy to dismiss.

And yet after using both side by side, I trusted the lower-scoring app more.

That contradiction ended up being the most useful part of the exercise, because it exposed something developers are going to run into increasingly often as AI-generated software becomes easier and easier to produce: “looks good,” “scores good,” and “feels right” are three different judgments, and they do not always point to the same winner.

I found that out while running a blind Claude 3 Haiku vs Llama-4-Scout coding duel on VibeCode Arena by HackerEarth using a deceptively simple prompt — build a Regex Translator.

The brief was intentionally small: one input box where a user pastes any regex pattern, one “Explain This” button, and then a plain-English explanation simple enough that even someone non-technical could understand what the expression is checking for. Frontend only. No backend logic. No technical jargon. Just a clean little utility.

Exactly the kind of prompt that should produce one clearly stronger build and one weaker one.

Instead, both outputs came back annoyingly close.

Visually, there was no dramatic collapse on either side. Both were rendered into plausible apps. Both captured the broad task correctly. Both looked functional enough that if I had judged the duel from screenshots alone, I probably would have shrugged, picked one casually, and moved on.

That is usually where a lot of AI app evaluation stops.

Increasingly, that is becoming a problem.

What makes VibeCode Arena more interesting than a standard side-by-side AI comparison is that it does not stop at the browser preview. Both generated builds also get pushed through an automated evaluation layer that scores security, code quality, correctness, performance, and accessibility, then surfaces implementation issues that do not necessarily show themselves just because the UI appears to work.

That second layer changed the duel immediately.

Side-by-side VibeCode Arena comparison showing Claude 3 Haiku and Llama-4-Scout generating a Regex Translator app from the same prompt
At first glance, both generated apps looked close enough that picking a winner felt almost arbitrary
Claude came back with a 99 overall score — essentially clean across the board. Security was perfect. Correctness was perfect. Performance was perfect. Accessibility was untouched. Code quality had only a minor deduction.

Automated VibeCode Arena evaluation highlighting score differences, accessibility deductions, and implementation issues for Claude 3 Haiku.
The browser previews looked similar. The evaluation report for Claude 3 Haiku was where the hidden differences began to show up.
Llama landed at 95.

Automated VibeCode Arena evaluation highlighting score differences, accessibility deductions, and implementation issues for Llama-4-Scout.
The evaluation report for Llama-4-Scout
More importantly, the evaluator surfaced three major issues inside Llama’s implementation: unnecessary character escapes, missing labels on form fields, and insufficient text contrast that would affect accessibility compliance. None of those are catastrophic enough to break the visible preview, but they are exactly the kind of hidden compromises that slip past people when AI-generated code gets judged too quickly.

Become a Medium member
So the technical answer seemed straightforward.

Claude had produced the stronger implementation.

Then I clicked through both previews again.

And this is where the neatness of the score report started to break.

Llama’s result simply felt closer to the actual utility I had in mind. The regex explanation behavior was tighter, the visible response felt more aligned with the original ask, and the app gave me the immediate “yes, this is what I wanted this tool to do” reaction faster than Claude’s did. Claude was the cleaner report. Llama was the more convincing product experience.

So the final vote did not go where the higher number was.

That does not make the automated evaluator less valuable. If anything, it makes it more valuable because it exposes the fact that AI-generated software now has to be judged across several dimensions at once. There is technical cleanliness. There is hidden implementation quality. There is accessibility. And then there is the much messier but very real question of whether the thing actually feels correct when a human uses it.

Those layers overlap.

They do not overlap perfectly.

This duel forced that mismatch into the open.

Without the preview comparison, I would not have had a practical user preference. Without the automated report, I would not have seen the implementation compromises quietly sitting within the lower-scoring build. And without being made to cast a blind winner after seeing both, I probably would have lazily accepted the 99 as the answer and missed the fact that my actual product instinct was pointing elsewhere.

That is what made this more interesting than a simple “which AI model writes better code?” contest.

It became a reminder that AI coding is no longer suffering from a shortage of talent. Models can generate plausible software all day now. The more interesting bottleneck is evaluation, and most developers are still doing far less of that than they think they are.

Try VibeCode Arena here & signup: https://vibecodearena.ai/beattheheat?page=1&pageSize=10&sortBy=responses&sortOrder=desc&utm_source=external&utm_medium=vc5&utm_campaign=beattheheat

Because if an app can look functional, score imperfectly, still feel better in use, and leave you uncertain which dimension should dominate the decision, then the hard part is no longer getting AI to build something.

It is learning how to judge what AI has built.

Try the challenge here: https://vibecodearena.ai/share/6203f289-29cd-417f-b5ed-a0ecdfdaf017

I Tried VibeCode Arena and Got Weirdly Obsessed With Beating AI

Sukriti Singh — Tue, 05 May 2026 05:18:50 +0000

I thought this was a fun browser game challenge, then I saw people consistently dropping 95+ scores across multiple prompts and even AI models showing up on the board.

I initially clicked into VibeCode Arena because the challenge names looked too unserious to ignore.

Save Ice Cream. Camel Race. Thirsty Crow.

Sounded like the kind of browser-game coding prompts you try once for fun and leave.

But after opening the submissions and checking the rankings, the vibe changed pretty quickly.

Across all three challenges, developers were posting consistently high scores in the 90s, with some names appearing again and again near the top. Prajith Arjunan S was sitting at the top of every board I checked, and there were dozens of in-progress responses still climbing behind. This clearly wasn’t one of those dead “submit and forget” event pages.

People were actively trying to outdo each other.

And that instantly made it more interesting.

The current arena is called Beat the Heat

The event running right now is a summer-themed set of browser game builds where each prompt asks you to create a small client-side game using nothing except:

HTML
CSS
Vanilla JavaScript

No frameworks. No backend complexity. Just execution.

But the prompts themselves are creative enough that they don’t feel like repetitive frontend assignments.

For example:

Thirsty Crow → build a stacking game where stones raise the water level in a pot
Camel Race → create a desert obstacle racing game with sprint/jump mechanics
Save Ice Cream → design a quick-reaction mini game where tasks slow melting

So yes, they look playful.

But the scoring boards underneath are very much not playful.

The top scores currently sit in the mid-90 range across these prompts, and there are large clusters of active responses still in progress. Claude 3 Haiku even appears as one of the benchmarked entries on the Save Ice Cream board, which means you’re not just looking at human submissions in isolation.

That mix makes the whole thing feel much more alive.

This is where it gets addictive: the public ranking

A lot of coding contests fail because once you submit, there’s no emotional reason to care.

Here, there is a visible leaderboard attached to every prompt.

That changes behavior immediately.

You stop thinking:

“Can I complete this?”

and start thinking:

“Can I push this score higher?”

When you can literally see people sitting at 92, 94, 95, and new in-progress responses appearing below them, the prompt stops feeling like a one-time task and starts feeling like a public benchmark.

There is something psychologically annoying about seeing a score that looks close enough to chase.

Especially when the same few developers keep showing up near the top across multiple challenges.

Now it’s not just a coding exercise.

Now it’s pattern recognition:
how are they structuring cleaner builds,
what is the evaluator rewarding,
how polished does the gameplay need to be,
how optimized does the interaction feel?

That competitive loop is what makes this harder to leave than expected.

It also doesn’t look like a one-off gimmick page

This was something I specifically checked because many online challenge pages are interesting for exactly one day.

VibeCode Arena seems to be running these as rotating themed developer battles rather than a single static contest.

Same idea:
creative build prompts, public scoring, leaderboard progression, community votes.

Different themes.

That matters because signing up no longer feels like “join this one summer event.”

It feels more like joining an ongoing challenge platform that keeps dropping new browser-build arenas.

And that gives the current Beat the Heat event much more pull.

👉 You can check the live challenge here: [Insert Signup Link]

The scoring system gives people too many reasons to keep pushing

Each attempted challenge adds points.

Top-ranked responses get bonus points.

Shared duel links can collect votes for more points.

So even if one prompt goes well, there is still:

another challenge to attempt,
another rank to chase,
another vote to collect,
another top score to try overtaking.

Which explains why so many boards already have dozens of active in-progress responses.

There is no clean stopping point.

Also yes, there is cash for the top 3

Current leaderboard prizes are:

🥇 ₹5,000
🥈 ₹3,000
🥉 ₹2,000

Nice incentive, obviously.

But after looking through the boards, I honestly think the stronger hook is social competition, not the money.

Once visible high scores exist, developers start treating them like targets.

And visible targets are enough.

Why this feels more alive than routine coding practice

Most practice platforms are useful but isolated.

This feels public.

You can see:

active rankings,
repeated top performers,
AI benchmark entries,
multiple responses still in progress,
and a challenge format that is less sterile than standard DSA problems.

So instead of “solve and leave,” it feels like “build, polish, compare, climb.”

That is a much more engaging loop.

Final thought

I opened VibeCode Arena expecting a light browser-game coding distraction.

I stayed because the leaderboards looked far more competitive than I expected.

If you enjoy frontend builds, public score chasing, or just want to see how far you can push a vanilla JavaScript game against dozens of other developers, this current arena is worth checking out.

👉 *Try the Beat the Heat challenge here: https://vibecodearena.ai/beattheheat?page=1&pageSize=10&sortBy=responses&sortOrder=desc&utm_source=external&utm_medium=vc5&utm_campaign=beattheheat

Curious if anyone here has already submitted to one of these and how close you got to the 95+ club.

I Made Two AI Models Read My Git Commits. It Got Uncomfortably Personal.

Sukriti Singh — Sun, 26 Apr 2026 08:03:04 +0000

I ran a blind AI duel this week on VibeCode Arena by HackerEarth with a prompt that sounded a lot less revealing than it turned out to be.

The idea was simple: build a Developer Mood Analyzer.

User pastes recent git commit messages, the app scans them, assigns one mood — Chaotic, Caffeinated, In Denial, Silently Judging Everyone, Burnout Mode, or 10x Developer — and then throws back a result card with a big emoji and a one-line summary.

Mostly just a fun little AI build challenge.

At least that was the plan.

VibeCode Arena runs these prompts side by side, so two AI models generate against the same instruction, and you compare them blind before the model names are revealed. In this duel, one side was Gemini 2.5 Flash, and the other was my own challenge entry.

What both models produced looked nearly the same in the preview, which was mildly suspicious. Same dark UI, same textarea, same oversized Analyze button, same general result card concept. It was polished enough, but not the kind of duel where you immediately think one side has obviously crushed the other.

So I did the only useful thing at that point and started trying to break them.

More specifically, I pasted in my own recent commit messages. These were not curated. This was just actual recent history:

fix: hotfix for the hotfix changed stuff It works now misc updates temp temp remove later ok fine
Press enter or click to view image in full size
Screenshot showing the duel side by side.
One of the analyzers thought for a second and labeled me Burnout Mode.

Its explanation:

You are one bad deploy away from quitting tech and starting a farm.

That felt a little too targeted for something that was only supposed to be scanning commit text.

I sent it to a few developer friends, mostly because I wanted confirmation that this thing was being unfair to everyone, not just me. Same pattern every time: they opened it, laughed once, and immediately started digging through their own git logs.

Join The Writer's Circle event
Nobody asked what prompt I used. Nobody asked which model built the better version. Nobody even really cared about the duel part.

They just wanted to know what mood they got.

One friend landed on Chaotic after feeding it a string of temp, misc, and trying again commits. Another got In Denial, which was deserved. Someone else got 10x Developer and became much more confident than the situation called for.

That was the moment I realized the hook here is not really the app. It is the fact that commit messages are way more revealing than developers think they are.

If you run “git log --oneline” right now and actually read the last ten entries, there is a good chance it looks less like disciplined software engineering and more like a low-grade distress signal.

Something along the lines of:

temp why is this failing quick fix maybe final final final do not touch

We all write commit messages in whatever mental state we happen to be in when we are trying to ship, patch, undo, or quietly survive. Which means git history ends up recording two things at once: changes to the codebase, and a surprisingly honest trace of the person making those changes.

That second part is what this analyzer latches onto.

The AI duel itself got more interesting the longer I played with it. On first glance, both outputs looked interchangeable enough that I thought this would come down to tiny cosmetic preferences. But after enough weird inputs, edge cases, and absurd commit dumps, differences started showing up. One version was slightly better at reading intent from vague commit language. One handled sparse input without producing nonsense. One just felt cleaner in how it presented the result.

Nothing dramatic. Just enough to remind me that AI-generated apps can look almost identical in screenshots and still behave very differently once you stop admiring the preview and start using them like an impatient real person.

That is probably my favorite part of these blind duels now. They force a more honest kind of evaluation.

Since this turned out to be much more entertaining than expected, I posted it as an open challenge instead of leaving it as a disposable one-off. So now anyone can jump in, try the current analyzer, improve the prompt, redesign the interface, make the mood detection smarter, make it meaner, whatever — and submit a better version.

There is obvious room to push it further. Better roast lines. Terminal-looking visuals. Combo moods for truly cursed commit histories. Shareable result cards. Maybe some kind of developer stability score, which feels medically irresponsible but compelling.

Even in its current form, though, it does something very reliably:

People instantly want to paste in their own commits.

This is usually a good sign that you have accidentally built something with a real participation loop.

So if you feel like being judged by your own repository, paste in the last ten actual commits from a week where things were not going smoothly and see what it tells you.

Try the challenge here: [https://vibecodearena.ai/duel/d42f49c8-d609-4096-9dec-1a9416557fe6]

Also, I am genuinely curious what the worst recent commit message sitting in other people’s repos looks like, because I refuse to believe “ok fine” is even close to the bottom of this barrel.

I Spent a Week on VibeCode Arena. Here Is Everything I Did Not Expect.

Sukriti Singh — Tue, 31 Mar 2026 07:20:37 +0000

Seven days. Blind voting. And a realization I didn't want to admit.

I will be upfront about something.

I almost did not write this.

Not because the week was boring. The opposite, actually. I almost did not write it because some of what I found was uncomfortable to admit, and the comfortable thing would have been to just post a highlight reel and move on.

But highlight reels are useless. So here is the actual account.

How it started

I had been hearing about VibeCode Arena for a bit. A platform by HackerEarth where you watch AI models compete on the same prompt, vote blind before the reveal, and open your results as community challenges.

Sounded interesting. I kept putting it off the way you put off anything that might make you feel like you do not know what you are doing.

Eventually I just opened it.

The first thing you see is the Duels feed. People have submitted prompts, two models have gone head to head, and the community is voting on which output is better. Some of the stuff people are building on here is genuinely creative — retro terminals, interactive tools, little games. I spent longer than I meant to just scrolling through before I actually tried anything myself.

Day One — The blind vote

I ran my first Duel.

The way it works is simple. You write a prompt, two AI models generate simultaneously, you watch both outputs come in side by side, and you vote for the better one before the model names are revealed. The reveal only happens after you commit.

I typed something I genuinely wanted to see — not a test prompt, an actual idea I had been sitting on. Both outputs came in. I read through them. I voted.

Then the model names appeared.

I had voted for the model I never use. The one I had quietly written off months ago was based on nothing more specific than a vague impression I had picked up from other people's opinions.

I did not feel vindicated. I felt slightly embarrassed. Because the implication was obvious — I had been choosing my tools based on reputation and habit, not based on what they actually produced.

I ran three more duels that day. My assumptions were wrong twice.

Day Two — The stick figure brawl

Okay, this one was just fun.

I wanted to try creating my own challenge and I did not want to overthink it. So I typed "design a game with stick figures fighting" and watched what came back.

Two outputs. One was clean and structured but felt more like a diagram than a game. The other had actual chaos to it — Player 1 attack button, Player 2 attack button, health bars, the whole thing. It felt like something you would actually waste two minutes on.

I picked the second one. Codestral-2508.

Again, not a model I had seriously considered before. Again, the blind format forced the honest evaluation.

I opened it as a community challenge — which means anyone can now jump in, take that base, prompt AI to improve it, and submit their version. The leaderboard fills up with different people's takes on the same starting point.

I posted it and waited to see what would happen.

What I felt in that moment was something I did not expect. A kind of genuine curiosity. Not "I built a thing" but "I started something and I have no idea where it goes." That is a different feeling and, honestly, a more interesting one.

Day Three — Looking at other people's challenges

I spent most of day three not building anything. Just looking.

The challenge feed has a range of things people have posted. Some are serious — UI components, accessibility focused tools, form builders. Some are completely unhinged. The range is wide and the leaderboard on each one tells you something about what the community actually values versus what looks impressive at first glance.

What I noticed was how much you learn from watching other people's iterations of the same starting point.

Someone takes a base output and restructures it entirely. Someone else adds a feature you had not thought of. A third person goes in a direction that seems wrong and then you look at their score and have to reconsider your assumptions.

I kept thinking — this is the thing most people are missing when they use AI alone. You get your own blind spots plus the model's blind spots. Open it up and suddenly you have twenty different sets of eyes on the same problem.

Day Four — The guitar fretboard

This one I am still thinking about.

I ran a duel with the prompt "design a guitar with all the key notes represented on strings." Six words. I play a bit of guitar so I was curious what the models would do with something I could actually evaluate properly.

Both outputs produced what they called an Interactive Guitar Fretboard. All twelve notes across the top, six strings, click a note and see its positions highlighted in green.

At first glance, it looked great. Clean. Functional. More than I expected from six words.

Then I actually used it.

The note positions are not accurate. When you click a note, the highlighted positions across the strings do not match where that note actually sits in standard tuning. For a tool that is supposed to teach you the fretboard, that is the most important thing to get right, and it got it wrong.

There is no sound at all. You click, and nothing plays. Silence. For a guitar tool that is not a minor gap, it is half the point missing.

No fret numbers so you cannot tell which fret you are looking at. No fret markers at the positions every guitarist uses to navigate the neck. The neck itself looks slightly too short.

I voted for Codestral-2508 again. Better visual layout, marginally better structure. But both outputs had the same fundamental problems.

I opened it as a challenge with a clear brief — fix the note positions, add fret numbers, add fret markers, and add sound. Here is what is wrong, here is what good looks like, go.

That felt more honest than pretending the output was finished.

Day Five — Something changed about how I prompt

I did not read a guide about this. It just happened.

After four days of carefully evaluating other models' outputs, I noticed I was prompting differently. Less about how to structure things, more about what the thing needed to do and why it needed to do it.

The outputs got better. Not dramatically, but noticeably.

I think what happened is that spending time on the evaluation side — really sitting with outputs and asking what is working and what is not — had quietly changed what I was putting into the prompts. I had internalised something about the gap between what prompts produce and what they should produce, and it was coming out the other side.

That is not something I could have gotten from reading about prompting. It came from doing the evaluation work repeatedly.

Day Six — The uncomfortable one

I ran a duel on a prompt close to something I had actually built myself a few months ago.

I was quietly confident going in. I knew this territory. I had already solved this problem.

One of the outputs came back and handled a specific part of the interaction better than I had.

Not overall better. Not in every dimension. But in one specific way that mattered, it had made a decision I had not made, and the decision was right.

I sat with that for longer than I probably needed to.

The thing I landed on was this. It was not that AI is better. It was that I had been too close to my own previous solution to see its weaknesses clearly. I had built a thing, shipped it, moved on, and calcified around it. Fresh evaluation — even from a model — caught what I had stopped being able to see.

That is uncomfortable. It is also useful.

Day Seven — What I actually took from all of this

A week is not long. I am not going to pretend it transformed everything.

But a few things shifted.

I think about model choice differently now. Not which model is best in general — that question does not have a useful answer. But which model for what kind of task, under what conditions, evaluated by what criteria. That framing is more honest and more practical.

I evaluate AI output more carefully. I have a clearer sense of what I am actually looking at — what is genuinely solid, what just looks good, what will cause problems later. That clarity came from doing the blind evaluations repeatedly, not from reading about them.

I am more comfortable with incompleteness. Both of my challenges — the stick figure brawl and the guitar fretboard — were unfinished in clear ways. Opening them as challenges rather than polishing them to death felt right. The platform treats incompleteness as an invitation rather than a failure. That reframe is quietly useful.

The thing nobody says about vibe coding

Most of the conversation around vibe coding is about speed. Build faster, ship faster, stop writing every line by hand.

That is true and it is also incomplete.

What vibe coding actually demands from you, if you do it properly, is better judgment. You are no longer the one writing every line so you have to be the one who can evaluate every line. You have to know what good looks like. You have to catch what is wrong before it ships. You have to make the calls the AI cannot make because it does not have your context.

VibeCode Arena is the most direct way I have found to build that judgment. Not through tutorials. Through doing it, on real prompts, with real outputs, scored honestly, in a community that is working on the same thing.

One week in I am more calibrated than I was. I am also more aware of how much calibration I still need.

That feels like the right place to be.

Try it here: https://vibecodearena.ai/?page=1&pageSize=10

And if you want to jump into something live, the guitar fretboard challenge is open, the note positions need fixing, the sound needs adding, and the leaderboard is waiting.

Challenge link: https://vibecodearena.ai/share/afc85b04-2031-4b33-8a70-caf14197ac6d

The best thing a week on VibeCode Arena did was make me honest about what I did not know. That is more valuable than any output it produced.