AI Coding in Practice: Generating a Minecraft Clone in 90 Minutes as LLMs Enter Project-Level Development

Another Leap in AI Coding Capabilities

Recently, a hands-on test video of a new OpenAI model sparked widespread discussion on Bilibili. The video showcased the astonishing performance of a new-generation model across complex coding scenarios such as game development, 3D modeling, and front-end design, prompting many developers to call it "mind-bending."

It should be noted that some of the model names in the video (such as "GPT 5.6 SOAR" and "Sol, Terra, Luna") and benchmark test names contain obvious speech-transcription errors, and readers should approach them with a critical eye. But setting aside the naming disputes, the series of one-shot code generation cases demonstrated in the video are genuinely worth analyzing in depth — they represent an important breakthrough direction in the current capability of large models to understand and generate complex projects.

So-called "one-shot generation" refers to the ability of a model to produce structurally complete, logically self-consistent, and runnable code from a single prompt, without requiring multiple rounds of dialogue-based debugging. This stands in stark contrast to the traditional "Prompt → Error → Fix" iterative loop. The technical pathways for achieving this capability typically include: large-scale code corpus pretraining (billions of lines of code on GitHub), reinforcement learning from human feedback (RLHF) to align on code quality, and tool use capabilities that allow the model to self-verify syntax during the generation process.

Worth understanding in depth is that these three techniques form a synergistic closed loop: large-scale pretraining enables the model to master the syntax rules and design paradigms of dozens of programming languages; RLHF, through human annotators' scoring of code quality, guides the model to prefer runnable, stylistically consistent output; and tool use allows the model to invoke code execution environments in real time during generation to verify logical correctness, forming an internal loop of "generate-verify-correct" that approaches the correct answer within a single interaction — this is precisely the underlying mechanism that makes one-shot generation viable.

This article focuses on these hands-on test cases to explore the core trend of AI evolving from an "assistive coding tool" toward an "independent project developer."

The Real Breakthrough in AI Coding: From Generating Code to Understanding Projects

The video's central argument is: the new model's breakthrough lies not in "being able to write code," but in "being able to understand complete projects."

In the past, it was not difficult for large models to generate code snippets. The truly hard part is simultaneously grasping the collaborative relationships among 3D scenes, animation, collision detection, and game rules. This generation of models reportedly achieves significant improvements in coding workflows, particularly excelling at long-chain, multi-system collaborative tasks.

The realization of this "end-to-end project understanding" capability has deep technical roots. The core support lies in the substantial expansion of the context window and the integration of multimodal capabilities. The context window is a core metric measuring how much information a large model can process in a single pass, measured in tokens (roughly 1-2 Chinese characters per token, or about 0.75 English words per token) — the early GPT-3 had a context window of only about 4K tokens, whereas current mainstream frontier models generally support 128K to 200K tokens, and some experimental versions even reach the million-token scale. This expansion allows the model to "see" an entire codebase within a single inference pass: for complex game projects, this means the model can simultaneously understand the game engine architecture, the interface definitions of various subsystems, and business logic rules, avoiding the interface inconsistency problems caused by earlier models "forgetting" earlier content.

It's worth noting that expanding the context window does not come without cost. Since Google's 2017 paper "Attention Is All You Need" introduced it, the Transformer architecture has become the dominant foundational architecture for large models. Its core self-attention mechanism allows the model, when processing each token in a sequence, to simultaneously compute its relevance weights with all other tokens in the sequence — this grants the model the ability to capture dependencies of arbitrary distance, but also introduces a serious computational cost: the time and space complexity of self-attention are both O(n²), meaning doubling the sequence length quadruples the computation. As input length grows from 10K to 100K tokens, the theoretical computation increases by up to 100x, which constitutes a significant engineering bottleneck. To address this, the industry has developed various long-context optimization techniques: including Sliding Window Attention, Sparse Attention, and the RoPE (Rotary Position Embedding) extension scheme based on improved positional encoding — RoPE encodes positional information as rotation matrices rather than fixed vectors, enabling the model to generalize more naturally to longer sequences not seen during training, controlling computational overhead while preserving long-range dependency capability. In addition, the combination of Chain-of-Thought Reasoning and code execution sandboxes (Code Interpreter) means the model is no longer merely "predicting the next token," but can iteratively verify the correctness of its generated results.

Whether it's a 3D game, an SVG interface, or an architectural model, the model no longer stitches together ready-made assets, but instead generates character models, animation, maps, and game logic from scratch, maintaining stylistic consistency throughout. This "end-to-end" project understanding capability is precisely what distinguishes it from the previous generation of AI coding tools.

Case One: A 3D Animal Racing Game

The first case involves having the model design a brand-new 3D animal racing game — different animals race while riding bicycles, and players must collect as many coins as possible before they disappear.

Before all the coins disappear

The biggest highlight of this case is: the model did not call on any ready-made assets, but directly generated the character models, riding animations, maps, and complete game logic. Different animals have their own movement forms, the map has built-in coin-collection mechanics and AI opponents, and the entire game already has basic playability.

For developers, this means AI can handle all four dimensions of 3D scenes, animation, collision detection, and game rules in a single pass — dimensions that traditionally required division of labor and collaboration — demonstrating an ability to grasp a complete game project as a whole. At the technical implementation level, generating 3D games typically relies on WebGL frameworks such as Three.js or Babylon.js — the model must simultaneously master these libraries' API conventions, 3D coordinate transformation logic (including matrix transformations between model space, world space, and clip space), and the architectural design of the game loop.

The game loop is the core engine mechanism of all real-time games. In essence, it is a main loop that continuously executes at a fixed frame rate, responsible for coordinating the sequential execution of "input handling → logic update → collision detection → render output." In a browser environment, this is typically implemented via the requestAnimationFrame API, triggering a callback on each screen refresh, with the goal of completing all computations for a single frame within about 16.67 milliseconds (60 frames/second). Taking the racing game as an example, in each frame the physics engine must compute the AABB (Axis-Aligned Bounding Box, the most lightweight collision detection scheme) collision between the animal characters and the track boundaries, the spherical collision detection of coins, and the path planning of AI opponents — all of which must be completed within about 16 milliseconds, or else the frame rate will drop and the display will stutter. The model's ability to simultaneously account for these time constraints and priority ordering during cross-library composite reasoning demands an extremely high level of capability.

Case Two: Cloning Teenage Mutant Ninja Turtles in 30 Minutes

The second case is more challenging. The developer provided only a single reference screenshot of a Teenage Mutant Ninja Turtles game — with neither original code nor any assets — and the model generated a runnable game demo in just 30 minutes.

But now AI can, in a short time

One detail worth mentioning: it did not simply copy the original screen, but rather redesigned a set of gameplay based on the reference image: character movement, attacks, enemy spawning, and level flow were all implemented. This shows the model not only recognized the visual layout but also inferred the character interaction relationships and the core features the game should have.

In other words, it has crossed from "image recognition" to "understanding game design logic." Behind this leap lies the key capability of Multimodal LLMs — such models use a vision encoder (architectures like CLIP, ViT, etc.) to transform images into vector representations that are isomorphic to text tokens, then feed them into the language model backbone for joint reasoning.

Understanding this capability requires knowing how vision encoders work: taking ViT (Vision Transformer) as an example, it slices an image into fixed-size patches (typically 16×16 pixels), then linearly projects each patch into a vector, and finally feeds them into the Transformer for processing in exactly the same way as text tokens. CLIP (Contrastive Language-Image Pre-training) further uses contrastive learning on massive image-text pairs to align the output spaces of the image encoder and text encoder — meaning that the image of "a Fire-type Pokémon next to a volcano" and the text "Fire-type Pokémon are suited to be placed in volcanic areas" are trained to be close enough in vector space, thereby achieving cross-modal semantic understanding.

In the game-cloning case, the model needs to infer from a single screenshot the UI hierarchy (which elements are foreground characters, which are background), spatial relationships (the relative positions of characters and enemies imply collision ranges), and interaction logic (the presence of a health bar implies the need to implement a damage system). This inferential ability relies on the implicit associations that vision-language models establish over massive amounts of annotated game screenshots, design documents, and codebases — during pretraining, the model has already seen large amounts of "game screenshot → game description → implementation code" triplet data, thereby establishing a cross-modal mapping from visual features to programming patterns. This ability to infer dynamic system logic from static visual information is essentially the cross-modal alignment of visual information and programming knowledge, representing a deeper level of understanding by multimodal models that goes beyond simple "describe-the-image" tasks. Work that previously required the coordination of programmers, artists, and designers can now be independently produced by AI as a playable demo in half an hour.

Case Three: A Pokémon Opening and Large-Scale Content Generation

If the previous cases demonstrated a single scene, then the reconstruction of a Pokémon opening reflects AI's capability for large-scale content generation. According to the video demonstration, the model generated characters, Pokémon models, buildings, roads, and a complete map in a single pass, even reproducing the professor's initial three-way starter choice and Route 1.

Continuously adding new maps and new storylines

More importantly, this content was not cobbled together but maintained a unified art style within the same project, and could theoretically be continuously extended with new maps, new storylines, and new battle systems.

This capability may hold value for independent developers that exceeds pure code generation — one of the biggest challenges RPG games face is the "Content Curse": players consume content far faster than teams can create it. Taking the Pokémon series as an example, a complete generation of the game typically requires hundreds of developers over 3-4 years, with a considerable proportion of the workload devoted to repetitive content filling — map tiles, NPC dialogue, item descriptions, and so on.

AI has a structural advantage in such tasks, and its generation paradigm differs fundamentally from traditional solutions. Procedural Content Generation (PCG) is a technical paradigm the game industry has used for decades — No Man's Sky's 18 quintillion planets and The Binding of Isaac's random dungeons are both implemented this way — but traditional PCG relies on developers manually writing generation rules (such as L-systems for generating vegetation, Perlin noise for generating terrain). The rule boundaries are clear but lack semantic understanding, unable to grasp semantic constraints like "Fire-type Pokémon are suited to volcanic areas." Content generated by traditional PCG is essentially exhaustive sampling of a rule set, whose ceiling is determined by the granularity of the rules, and adjusting parameters requires modifying the underlying algorithm — extremely unfriendly to non-technical people.

AI-driven content generation, on the other hand, takes natural-language intent as input. The model internalizes vast amounts of human-created semantic associations, enabling it to follow high-level semantic rules while maintaining stylistic consistency. More importantly, AI-generated content is "steerable" — developers can correct the generated results with natural language ("make this area gloomier and more oppressive"), whereas adjusting traditional PCG requires modifying underlying algorithm parameters. The two approaches differ by orders of magnitude in creative efficiency. In essence, this upgrades design decisions from "rule encoding" to "intent understanding." In the future, perhaps a handful of people could accomplish large projects that previously required dozens.

In addition, the video demonstrated an SVG interface generation case: based on a prompt, the model directly generated a complete set of Windows-style vector icons and UI elements, which can be scaled infinitely without loss of quality — a significant practical value. SVG (Scalable Vector Graphics) describes graphics through mathematical paths rather than pixel grids — for example, a circle in SVG is represented by an XML tag like <circle cx="50" cy="50" r="40"/>, rather than storing the color values of tens of thousands of pixels. Complex graphics are described through Bézier curve paths (<path d="M10 80 C 40 10, 65 10, 95 80"/>), and their lossless scaling comes from always rendering based on real-time computation of mathematical formulas rather than interpolating pixels. AI generating SVG is essentially generating structured XML code, which for large models is a relatively mature text-generation task. Its practical value lies in directly outputting production assets usable by designers, without the loss from a secondary rasterization-vectorization conversion, significantly compressing the delivery cycle from concept to usable asset.

Case Four: Building a Complete Game World in 90 Minutes

The grand finale case is generating a Minecraft clone in about 90 minutes, including core gameplay such as day-night cycles, multiple creatures, and a crafting system.

The truly difficult part is making these systems work together

The challenge here is: the model is no longer generating isolated functional modules, but building a complete, collaboratively operating game world. Understanding this challenge requires knowing the architectural complexity of sandbox games: sandbox games represented by Minecraft belong, in software architecture terms, to the typical Entity-Component-System (ECS) architecture, where every object in the game world is decomposed into pure-data components (position, velocity, health) and pure-logic systems (physics system, rendering system, AI system), with components and systems decoupled and communicating via a data bus. The core advantage of the ECS architecture lies in its cache-friendliness — component data of the same type are laid out contiguously in memory, so the CPU can greatly reduce the performance loss from cache misses during batch processing, which is crucial for sandbox games that need to process thousands of entities simultaneously.

From a technical perspective, a complete sandbox game requires at least the following subsystems to collaborate seamlessly: the rendering system (handling frustum culling and lighting calculations), the physics engine (collision detection, gravity simulation), the game logic layer (block placement rules, crafting recipes), the entity system (creature AI, pathfinding algorithms), and the time manager for the day-night cycle. These systems have complex data dependencies among each other — for example, the physics system needs to read terrain data from the rendering system, and creature AI needs to perceive block states from the game logic layer.

Behind the seemingly simple feature of the day-night cycle likewise hides the complexity of cross-system coordination: the time manager not only needs to drive the gradient transition of skybox colors and sun position (typically implemented by linear interpolation between preset dawn/dusk color tones), but also needs to trigger the lighting system to recompute ambient light intensity, notify the creature AI system to switch the spawn probabilities of diurnal/nocturnal monsters, and adjust the fog effect parameters of the player's field of view — these linkages require the model to have a clear global plan of the overall architecture and to pre-design the event notification interfaces between systems, rather than stitching modules together after each is completed. In traditional development, such architectural design typically requires an experienced technical director to coordinate. The fact that AI can plan out this system architecture in a single generation shows that the model has formed some internalized understanding of software architectural patterns.

Similarly, the video also demonstrated generating a 3D theme park containing 25 Pokémon in 60 minutes (each Pokémon's position reasonably arranged according to its characteristics), and a 3D house model rendered with WebGL that runs directly in the browser from a single HTML file. WebGL is a browser 3D graphics API based on the OpenGL ES standard. Its core working principle is: the developer submits vertex data (describing the 3D coordinates of triangle facets) to the GPU via JavaScript, and the GPU runs two types of shader programs in parallel — the Vertex Shader is responsible for transforming each vertex's 3D coordinates into screen 2D coordinates via the model-view-projection matrix, while the Fragment Shader determines the final color of each pixel on screen (through texture sampling, lighting calculations, etc.). Both types of shaders are written in GLSL (OpenGL Shading Language), whose syntax is entirely different from JavaScript, closer to C, and runs directly on the GPU, completely isolated from CPU-side JavaScript. Implementing an interactive 3D model with a single HTML file means the model must simultaneously write, within the same file: the HTML organizing the page structure, the JavaScript controlling interaction logic, and the GLSL shader code embedded in strings — three coexisting syntactic systems with an enormous technical span, which is precisely why this case is regarded as an important breakthrough.

An Objective Assessment: Significant Progress, Limitations Equally Real

Although these cases are impressive, it is still necessary to maintain rational judgment. The video itself admits: the generated Minecraft clone is "still quite far from real Minecraft," the 3D house has "minor issues with a few window positions," and the Pokémon models also have "shortcomings in detail."

These results are essentially still concept demos generated in one shot, with an obvious gap remaining from commercial-grade deliverable products. The boundaries of current AI coding capabilities manifest mainly in three dimensions: first is the "long-tail error" problem — the model performs excellently on common code patterns, but still easily produces logic errors that are hard to auto-detect in specific platform API version differences and rare edge-case handling. Second is "context forgetting" — although the context window has been greatly expanded, the phenomenon of "attention dilution" at the end of extremely long contexts remains a research challenge. Experiments by Stanford University researchers showed that when key information is buried in the middle of an extremely long context, the model's retrieval accuracy drops significantly — the industry calls this the "Lost in the Middle" problem, whose root cause lies in the positional bias of the Transformer's attention weights in long sequences, allocating higher attention weights to information at the beginning and end of the sequence while relatively diluting information in the middle. Third is "hallucinated code" — the model sometimes generates syntactically correct code that references nonexistent APIs. This type of error is called "API hallucination," hard to discover without an execution-verification step, and may cause the code to throw hard-to-trace errors at runtime. But given the iteration speed of current large models, these flaws are likely to be gradually resolved in the next few versions.

More worthy of attention is the overall trend: AI is step by step moving from an "assistive development tool" toward the stage of "being able to independently complete a full project." The evolution of AI coding tools has roughly gone through three stages: the first stage was code completion (represented by early versions of GitHub Copilot), mainly providing suggestions at the function level; the second stage was conversational debugging assistance, capable of explaining errors and providing fixes; the third stage, which we are now entering, is "Agent-style development" — where AI can autonomously decompose tasks, invoke tools, iteratively verify, and deliver complete modules.

Technically, Agent-style development relies on "Chain-of-Thought" reasoning to have the model break down complex tasks into executable steps, and on "Function Calling/Tool Use" to enable the model to actively invoke external tools such as code executors, file systems, and search engines. In actual engineering implementation, this closed loop is typically organized through the "ReAct" (Reasoning + Acting) framework: proposed by Google DeepMind researchers in 2022, its core idea is to alternate the model's reasoning process with action decisions — at each step the model first outputs its reasoning in natural language (Thought, e.g., "I need to first check which files are in the current directory"), then decides which tool to call and with what parameters (Action, e.g., calling the list_files tool), and after the tool returns a result (Observation), it enters the next round of reasoning, forming a traceable decision chain of "Thought → Action → Observation." This paradigm has been widely adopted by mainstream Agent frameworks such as LangChain and AutoGPT, but its effectiveness depends largely on the reliability of tool calls — when a tool returns an abnormal result, the model needs to possess error-recognition and re-planning capabilities (i.e., "if the file list is empty, I should instead check whether I'm in the wrong directory"). Yet when facing consecutive multi-step tool-call failures, current models still easily fall into loops or produce erroneous recovery strategies, which is one of the core reasons Agent systems still face challenges in production environments. Forming a closed loop of "perceive-plan-execute-verify" upgrades AI from passively responding to prompts into an autonomous Agent that actively drives projects forward. This shift will have a profound impact on independent developers, creative professionals, and even the entire software industry's mode of production.

Conclusion: Repositioning the Role of Human Developers

Regardless of whether the model names in the video are accurate, these hands-on test cases all point to a clear signal: the AI coding capabilities of large models are moving from "snippet generation" toward "project-level understanding and construction."

When AI can independently build a collaboratively operating game world, the role of human developers will change accordingly. According to Stack Overflow's 2024 Developer Survey, over 75% of developers already use AI tools in their workflows, but most position them as "accelerators" rather than "replacements." A more accurate prediction is: repetitive implementation work will be largely automated, while work that requires business judgment and accumulated experience — such as system architecture design, product requirement understanding, and code quality review — will become the core value of human developers. The role shifts from "implementer" to "designer and gatekeeper."

This shift actually continues a consistent pattern in the history of software engineering: every elevation of the level of abstraction (from machine code to assembly language, from assembly to high-level languages, from hand-written code to frameworks and libraries) has once triggered discussions of "will programmers disappear," but the ultimate result has been the expansion of the developer community and the upward shift of their value. When the FORTRAN compiler debuted in 1957, many worried that "machines can automatically translate to machine code, so assembly programmers will be out of work," but the reality was that lowering the barrier to programming brought an explosive growth in the programmer community, and demand for high-level-language programmers far exceeded the total of all assembly programmers back then. The rise of AI coding tools is likely to follow the same historical logic — bringing more people within the threshold of software creation, while liberating professional developers' attention from "how to write" to the higher-level questions of "what to write" and "why to write it." How to find one's core value amid this shift is a question every developer would do well to consider in advance.

Regarding the actual capability boundaries of such models, it is advisable to rely on official release information, view third-party accounts and test results rationally, and avoid being misled by exaggerated marketing rhetoric.