Penguin Smack: one swing, one penguin, and a browser game built with AI

Penguin Smack is a browser game made with AI. kvickan released it on itch.io, and the launch devlog says which tools did which jobs. It's a free HTML5 game for desktop and phone. You get one swing at a penguin, and the rest of the run is physics. The maker credits Claude Code with the code and Codex with the art. The audio is royalty-free stock music from Pixabay, not AI-generated.

This Specimen covers how the project kept its scope small, which tools the maker names, how the leaderboard works and what the sources leave out. For the full story in the maker's own words, read kvickan's devlog and play the game on its itch.io page.

What is Penguin Smack?

The itch.io game page lists Penguin Smack as Released, HTML5, in the Sports genre, with an average session of "a few minutes". The launch devlog is dated 13 October 2026. The game is free and runs in the browser on desktop and phone, according to the devlog.

The premise takes one sentence. You're a yeti with a baseball bat, a penguin slides down an ice chute, and you get one swing. After that you watch the penguin bounce down an endless frozen lake.

The itch.io tags include 3D, one-button, arcade, physics and score attack. Under accessibility, the page lists an interactive tutorial and one-button play. The page's AI disclosure field marks the game as AI Assisted, covering code, graphics and text.

The game page lists these controls:

• Tap, click or Space to swing (gamepad A also works)
• R to skip a run
• M to mute
• N to turn music off
• L to open the leaderboard

Why does the small scope work?

One input, then the physics takes over

The player makes one decision: when to swing. The devlog says hitting the penguin as it reaches the ring earns a rating of PERFECT, GREAT, GOOD or SHANKED. That rating sets how hard the penguin launches.

After the swing, the player only watches. Per the devlog and game page, boost pads, trampolines, wind tunnels and ice ramps add speed, while ice walls and snow drifts take it away. The game page says ice walls halve the penguin's speed. Hitting several objects in a row builds a chain that adds more speed.

A short list of objects on top of one loop

The variety comes from a handful of objects along the lake, not from new systems. The devlog lists:

• exploding barrels
• gummy bumpers
• rockets the penguin can ride
• a rare cannon
• arcs of golden fish that set off a Fish Frenzy
• jackpot alleys
• danger zones walled in by ice

The devlog says most runs end after a few hundred metres, and the lucky ones pass five kilometres.

Why this suits a first finished project

At launch, the design left a lot out. The launch devlog describes one input, no level structure, no inventory and no story. A skip key ends a bad launch at once, so a weak swing costs a second or two, not a long wait. Every new object follows the same rule: it changes the penguin's speed. Each addition is small, and none of them changes how the game is played. Even so, the project shipped with a tutorial, a leaderboard and sharing.

The scope has grown since launch. The game page lists later devlog posts, including one titled "Big update: endless levels, 86 cosmetics and new smack sounds" and a visual update that adds eight areas. This Specimen sticks to the launch account. The sources don't say how well the core loop holds up over many sessions.

How was it made, according to the maker?

The devlog splits the work between two AI tools and royalty-free assets.

The game page names two music tracks from Pixabay: "Happy Winter Day" by alexrockbeat and "Energetic Action Sport" by AlexGrohl. It also says the game is built on three.js.

The split is worth noting. A coding agent wrote the systems, an image model made the visuals, and the audio came from licensed stock tracks by named musicians. The maker credits all three openly, and that credit list is a good model to copy. For more projects that use agents this way, see the coding agents tag. For AI-made art and textures, see sprite generators.

What the account doesn't tell you

This is the maker's own account, and it covers results more than process. The devlog and game page don't include:

• the prompts used
• how long the build took
• what the AI tools cost
• how much code or art was edited by hand
• how the project was set up for the agent (instructions, files, iteration loop)

Don't fill those gaps with assumptions. "Made with Claude Code" could mean one long session or weeks of careful review. If you want to see how agent instructions shape a project like this, the Lab Note on Claude Code's /doctor prompt audit explains how the tool reviews a CLAUDE.md file.

How does the leaderboard stop cheating?

One board, two front doors

The devlog describes one worldwide leaderboard shared by the itch.io build and a standalone site, penguinsmack.pages.dev. A live counter shows how many penguins have been smacked in total. The game page says players can enter a name from the leaderboard screen or keep a random one the game assigns. Per the devlog, results can be shared to X, Bluesky, Threads, Facebook or WhatsApp.

The devlog gave the record at launch as 9,225 m.

Big records are replayed before they post

The devlog and game page both say big records are replayed with the game's own physics before they appear on the board. So the board doesn't just accept a claimed distance. The game reruns the run to confirm it.

For a solo developer, this is the idea most worth reusing, whatever the theme. If a score-attack game's physics always gives the same result from the same inputs, that same simulation can check scores. If the inputs are known, the run can be replayed and the result compared. A faked distance that the replay can't reproduce gets rejected. The check is cheap because the code already exists: it's the game.

The sources don't explain how Penguin Smack does this. They don't say:

• what data the client sends (inputs, a seed, or a full replay)
• where the replay runs (in a Cloudflare worker or somewhere else)
• how large a score has to be before it's checked
• how the physics is kept consistent across browsers and devices

That last point matters. Floating-point maths can give slightly different results on different hardware, so a replay check only works if the simulation stays consistent. The devlog doesn't say how Penguin Smack handles that.

Where is it published, and what inspired it?

Credit to the original idea

The devlog calls Penguin Smack a nod to the old browser game Yetisports Pingu Throw. Naming the inspiration up front is the right move. If you build on a familiar idea, credit the original and make your mechanics and art clearly your own. Going by the descriptions, Penguin Smack keeps the yeti-and-penguin setup but adds a passive run with boosts, chains and a shared leaderboard.

Listed as AI-made

The game also appears on GamesByAI, a site where players rate games made with AI. The listing describes it as an arcade game made with Claude, free in the browser. Between that listing, the devlog's tool list and the itch.io AI disclosure field, players can see how the game was made before they play.

Two front ends, one backend

The game lives in two places, itch.io and a Cloudflare Pages site, with one leaderboard behind both. itch.io brings in players who browse the platform. The standalone URL is easier to share on social media. Scores from both count on the same board. For more projects shipped this way, see the browser games tag.

What are the limits, and who is this Specimen for?

Limits

• It has one mechanic. Penguin Smack is an arcade toy built around a single timing input. That's the design, but it caps how much depth the game can offer.
• No data on how long it holds players. The sources don't say how long people keep playing or how often they come back.
• No phone performance data. The devlog says the game runs on phones, but no source gives frame rates or names the devices it was checked on.
• No implementation details. The sources don't document the code structure, the replay check or the agent workflow.
• No summary of player reactions. The devlog invites players to post their best distances in the itch.io comments, but none of the sources describe how players have responded.

Verdict

Based on the sources, Penguin Smack is most useful to solo developers who want an example of a small browser game that actually shipped. It shows a short feature list, an honest credits section, and a leaderboard that checks big scores by replaying them.

It's less useful if you want a prompt-by-prompt tutorial. The devlog describes the finished game and the tools, not the steps. For step-by-step guides, see Experiments. For another project where an AI writes most of the code, see 3D-Agent, a Blender addon where the AI writes Blender Python, or the Claude-built 3D Terraria rebuild.

Play Penguin Smack on itch.io and read kvickan's devlog for the maker's own account. More community projects are in Specimens.