A 1.4 MB HTML game demo has been spreading through Chinese gaming accounts and WeChat groups under the label of a homegrown AAA game. That is a fraction of the size of a conventional AAA title. Opening the file revealed three striking absences.
It does not even have a game engine.
There is not a single image file, audio file, or 3D model file inside it.
It also does not credit the original creator.

The original was made by an Anthropic engineer with one prompt, about eight hours of computation, and an estimated API-equivalent cost of $550. Someone then gave it a Chinese-language reskin, called it an independently developed Chinese AAA game, and sent it circulating through WeChat.
Those are the three things I could confirm after taking apart Ji Mao, the version making the rounds. It is a playable first-person shooter in a 1.4 MB file small enough to send in a chat. How does that work? You do not need a coding background to follow the explanation. Links to the original, the Chinese version, and the source are at the end.

First, establish what it actually is: a reskin
The game circulating as Ji Mao is originally Saltline, by Anthropic engineer Felix Rieseberg. That background comes from reporting by the Chinese gaming publication Game Research Society. Felix posted the original on X on the morning of November 10. The Chinese version appeared in WeChat groups that same day, advertised as a homegrown AAA game and spreading one shared file at a time.

I examined the file being shared. The interface had indeed been translated into Chinese, and its introduction repeatedly claimed independent development. But deep in the shader names, the original title survived 9 times: saltline-sky, SALTLINE_SHADOW, SALTLINE_POST. The original creator's name appeared 0 times.

Players rarely inspect those corners. Apparently, neither did the person who reskinned it. A search through the code tells the story without a speech about authenticity.
My first question: without an engine, where do the visuals come from?
My first reaction was probably the same as yours: what engine produces something that looks like this?
I asked AI to help inspect the file, questioning the results as we went. It does use three.js, but that is a rendering library, not a game engine. Drawing triangles on screen takes roughly half the file, 721 KB. The work an engine would normally handle, including physics, enemy AI, audio, and input, is written out in the remaining 672 KB of code.
Gravity, jumping, collision boxes, and line-of-sight checks come down to a few dozen lines of math. Enemies have patrol, investigation, combat, and search states, plus visual awareness. They call for help when they spot you. There is even a performance budget: only two or three enemies do a full round of thinking at once. Bloom, chromatic aberration, vignetting, and film grain are implemented in custom post-processing shaders too.
The part normally supplied by a game engine is precisely the part AI wrote from scratch.

How does 1.4 MB contain something that looks like a AAA game?
As we looked at the file size, I offered a guess: perhaps traditional studios avoid doing everything in code because generating it all by hand costs more than including finished assets, even if the package becomes much larger.
The AI agreed with that labor-economics explanation. Art pipelines are mature and can run in parallel; writing procedural content by hand is slow and expensive, while storage and bandwidth keep getting cheaper. Then it pointed out something more fundamental:
Most of a game's size comes from its assets, not its code.
A commercial game can easily occupy 100 GB, with only a few dozen megabytes of code. Textures, models, audio, and voice recordings take the rest. Ji Mao sits at the other extreme: 100% code, 0% asset files. Not a single image or audio file is bundled inside it.
So where do the sights and sounds come from? Asset files store data, but many of the patterns in that data can be described by short formulas.
Take a rain-soaked steel shipping container. A conventional 4K texture records a color for each of 4096 × 4096 pixels, taking 64 MB uncompressed. Here, less than 2 KB of compressed code describes a base color, noise for rust, lines for the panel seams, and wear at the edges. During startup, it draws the texture and sends it to the GPU.
It is the difference between storing the finished result and storing the recipe. About 30,000 times in this example.

The shipping-company logos on the containers, translated as Ji Mao Ocean Shipping and Ji Mao Northern Shipping, are drawn with canvas. So is the rifle's Ji Mao Arsenal 5.8×40 inscription. What looks like a collection of art assets is geometry and text-drawing instructions in the source.
The audio is stranger still. Roughly 30 sounds, including gunshots, gulls, mechanical-dog servos, rain, waves, and brass music, are mathematical functions rather than audio files. Here is what the gunshot synthesis function looks like, with my annotations:

One gunshot layers five mathematical components into a 0.32-second array: high-frequency noise for the crack, a sweep from 160 Hz to 45 Hz for the thump, and decaying sine waves at four frequencies for the metallic ring of the bolt spring. Four variants are chosen at random so repeated shots do not sound identical.
Those loading messages about arranging containers and checking the service rifle describe something literal: thousands of formulas are turning code into textures and audio in memory. It is like sending a cake recipe instead of a cake, then baking it in five seconds before serving.
The whole file is 436 KB after gzip compression. Smaller than a phone photo.
But there must be some smallest building block, surely?
This was where I got stuck with a beginner's question. Something still has to assemble the result. Where does the smallest unit come from? Does the music start with a sound already on the computer? Does the image start with individual pixels somewhere?
The answer is almost philosophical: code contains neither sound nor light. It contains numbers.
For sound, the speakers need a sequence of numbers. This game produces 44,100 per second, each specifying how hard the speaker cone should move at that instant. The game calculates the sequence and hands it to the browser. The operating system, sound card's digital-to-analog converter, amplifier, and speaker cone do the rest. A sound card is, in effect, a machine that turns numbers into changes in air pressure.
For graphics, the game does not directly switch a pixel on. It asks for a triangle and supplies a formula for its color. Thousands of GPU cores run that calculation in parallel, with a core working on a pixel. The graphics card turns numbers into light.

The original creator later summed it up: “Everything in this game is code.” After inspecting it, I can confirm that this is no exaggeration.
Where does the AAA appearance come from?
There is a limit worth stating plainly: the game contains little content. One location, one gun, two enemy types, and a mission lasting roughly ten minutes.
It feels remarkably complete because it gets three comparatively inexpensive things right. First, the full play loop works: title screen, mission, combat, extraction, results, and restart. Second, the art direction is well chosen. Dusk, rain, backlighting, and silhouettes hide the simple models, while wet surfaces and volumetric light create atmosphere. Finally, cinematic post-processing adds bloom, chromatic aberration, vignetting, and film grain.
Interfaces and systems make a game feel complete, and those are comparatively cheap to express in code. A large amount of content is expensive. This demo maximizes the former and conceals the shortage of the latter.
How the original was made, and why the arguments followed
Saltline's origin is more interesting than the reskin. Felix gave Fable 5.2 one prompt and let it generate the game from scratch, without human feedback, over about eight hours. His published figures were approximately 445 million input tokens, mostly cached, and 2.7 million output tokens. At listed API rates that works out to about $550. That is an equivalent price, not what he actually paid.

The arguments followed quickly. Some people tried the published prompt and got comically different results. Others on overseas forums praised the visuals but found the gameplay ordinary. Claims about one-prompt generation and the cleanliness of training data became points of dispute. Felix's statement that the era of prompt engineering was essentially over sounds more like advertising to me for now.
What I would take from this if I wanted to make a game
These are notes for myself as much as for anyone else.
The prompt can be simple; the judgment cannot. Felix's prompt is almost absurdly plain, yet the same prompt produced poor results for other people. A difference I see is knowing what counts as finished and choosing a precise target: a small scene, a harbor at dusk, and a complete FPS loop.
Choose the art direction before asking AI to build. A direction as short as dusk, rain, and backlighting was one of the most cost-effective decisions in the project. A constrained visual target gives AI much more to work with than “make me a good game.”
Finish a small procedural play loop. With no external assets, the finished product is one HTML file you can send in a chat. Get title screen, combat, and results working together before expanding the content.
Treat AI output as a draft and take responsibility for acceptance. This game even keeps running if its audio system fails, and offers four graphics settings. That sort of engineering completeness comes from specific requirements and checks rather than assuming a model will remember everything.
What this could mean for the games industry
The cost of producing something that looks expensive is changing. What once required an art team and substantial hours can now approach an impressive demo with a clear prompt and a few hours of computation. More small teams, independent developers, and students may be able to build a polished vertical slice to test gameplay or show investors.
The expensive part then shifts toward gameplay design, content volume, intellectual property, and taste. Those are precisely the areas this wave of AI handles less well. The comments about ordinary gameplay make the distinction clear: an AI-generated game can be complete without being especially fun.
There is another consequence already visible: the cost of copying and rebranding approaches zero too. Ji Mao retained the original title in 9 places, credited the creator in 0, and spread through WeChat in a day. We should expect more translated reskins presented as original work. Attribution, provenance, and verification will matter more.
The joke about Ji Mao may be old news tomorrow. The implications of a game made entirely from code are only beginning.
Try it yourself
You can examine the claims for yourself. The Chinese version runs in a browser, including on a phone: Play the Chinese demo.
The English original is also playable in a browser: Play Saltline.
The complete source is a single 1.4 MB HTML file in a third-party GitHub repository: View the source code.
