Generating 10 Web Games with One-Line Prompts: A Hands-On Claude Code Experience

Where Are the Boundaries of AI Programming?

"Can AI actually write code at a professional developer's level?" It's a question many people have been asking. During a live stream on Bilibili, a senior developer used Claude Code — a command-line AI programming tool — to generate 10 web-based mini-games in under an hour using nothing but natural language prompts, then deployed them all to GitHub Pages for anyone to play online.

Claude Code is a command-line interactive AI programming tool released by Anthropic. It allows developers to converse with the Claude model directly in a terminal environment using natural language, enabling code generation, file operations, project management, and more. Unlike traditional IDE plugins (such as GitHub Copilot), Claude Code functions more like an "AI programmer assistant" — it can understand project context, autonomously create and modify multiple files, execute shell commands, and even handle Git operations and deployment workflows. The advantage of this command-line approach is that it can directly manipulate the file system without the constraints of a graphical interface, making it well-suited for batch and automated development scenarios.

The core of this experiment isn't the games themselves — 2048, Gomoku, and Tetris are hardly new — but rather what it clearly demonstrates: AI programming has evolved from "usable" to "genuinely useful," and the human role is shifting from "executor" to "director."

The Hands-On Process: One Sentence to Generate a Game

Game #1: 2048

The workflow was remarkably simple. A single Chinese-language prompt was entered in the command line:

Build a 2048 game in the 01-2048 directory, web version, dark theme, supporting keyboard arrows and mobile swipe controls, with a link back to the main hall index.html at the bottom

No technical jargon. No specification of whether to use a 2D array or 1D array for the data structure. No explanation of how the merge logic should be implemented. Within 1–3 minutes, Claude automatically generated a single HTML+CSS+JS file containing the complete core logic: a 4×4 board, number sliding, collision merging, and all essential mechanics.

Actual test results: the game was fully playable with correct logic and no obvious bugs. While it lacked fullscreen adaptation (after all, it was just a one-line prompt), the core functionality was complete.

2048 game development process

Game #2: Gomoku (Five in a Row) vs. AI

The Gomoku prompt was equally concise: draw the board with Canvas, player plays black, AI plays white, and the AI should have basic offensive and defensive strategies. What you might not have noticed is that the developer never specified which algorithm the AI should use — whether Minimax search, Alpha-Beta pruning, or a simple scoring function — it was entirely left to the model to decide.

Chess and board game AI typically has multiple implementation paths. Minimax is the classic game tree search algorithm that evaluates each move by simulating alternating plays between both sides. Alpha-Beta pruning is an optimization of Minimax that dramatically reduces computation by cutting branches that can't possibly affect the final decision. The scoring function approach is more lightweight — it assigns different point values to various board patterns (such as open threes, blocked fours, and five-in-a-row), and the AI places its stone at the highest-scoring position. For web-based Gomoku, the scoring function method is most commonly used due to its low computational cost and fast response time. But which approach Claude actually chose was not dictated by the developer — and that's precisely what demonstrates the model's ability to make autonomous technical decisions.

Test results showed that the AI opponent "wasn't stupid" — if the player made careless moves, they'd lose quickly. This proves Claude didn't just generate interface code; it independently implemented a reasonably competent game-playing algorithm.

Games #3 Through #10: Mass Production

The remaining games included Tetris, Pixel Bird (Flappy Bird), Minesweeper, and other classics — each generated from a single-line prompt.

Pixel Bird game

Take Pixel Bird as an example. The developer described the basic rules in the prompt: "click the screen to make the bird fly up, it falls automatically, dodge green pipes, score points by passing through pipes." Claude automatically handled the physics engine simulation — applying downward velocity each frame to simulate gravity, giving an instantaneous upward velocity on click, with the two combining to create a parabolic trajectory.

In games like Pixel Bird, the so-called "physics engine" is actually a simplified simulation of Newtonian mechanics. The specific implementation works like this: each frame (typically running at 60fps via requestAnimationFrame) applies a fixed acceleration increment to the bird's vertical velocity (simulating gravity), causing its speed to gradually increase and its position to move downward. When the player clicks the screen, the vertical velocity is instantly set to a negative value (upward), after which gravity takes over again, creating a natural parabolic motion trajectory. While this frame-by-frame physics simulation is simple, it's sufficient to produce smooth, intuitive movement — it's the most fundamental and commonly used technique in 2D game development. All of these implementation details were completed autonomously by the AI, with the developer specifying no technical implementation path whatsoever.

Game Hall and One-Click Deployment

After all 10 games were complete, the developer used a slightly longer prompt to have Claude generate a game hall page that integrated all the games together, featuring a dark tech-style theme with statistics displayed at the top. Then, with a single command, Claude automatically handled Git initialization, pushed to a GitHub repository, and enabled GitHub Pages deployment.

GitHub Pages is a free static website hosting service provided by GitHub. Developers simply push static files like HTML, CSS, and JavaScript to a specific branch of a GitHub repository (typically the main branch or gh-pages branch), and a publicly accessible website is automatically generated. It's particularly well-suited for hosting personal blogs, project documentation, and front-end applications. Since it requires no server-side runtime environment, purely front-end web games are an ideal use case for GitHub Pages — zero cost, zero maintenance, with global CDN-accelerated access.

Throughout the entire process, the developer never manually wrote a single line of code, nor manually executed any Git commands.

Deployed game hall

The Real Capabilities and Limitations of AI Programming

What AI Code Generation Can Do

Based on this experiment, today's top-tier large language models (like Claude) have demonstrated the following programming capabilities:

Understanding natural language requirements: No technical jargon needed — everyday language descriptions are sufficient
Autonomously selecting technical approaches: Data structures, algorithm strategies, and code architecture are all decided independently
Full-stack code generation: HTML structure, CSS styling, and JS logic completed in one pass
Rapid iteration: Each game completed in 1–3 minutes, far exceeding manual development speed

What AI Programming Can't Do

The developer also candidly pointed out the limitations:

A single sentence can't produce a perfect product: UI details, fullscreen adaptation, and playability optimization all require multiple rounds of iteration
Complex systems can't be built in one step: "Asking it to build a Bilibili or a QQ messaging app with one sentence — that's not realistic"
It doesn't understand your business: AI can write code, but it doesn't grasp your business requirements, user scenarios, or architectural trade-offs
Humans are still needed to judge quality: The code is written, but whether it meets user needs still requires human evaluation

New Demands on Developers

One thought-provoking insight: the AI programming era hasn't made things "extremely simple" — it has actually raised the bar for what's expected of people.

Before, knowing one language was enough — just front-end, or just back-end. But now you need to understand everything — databases, artificial intelligence, big data, Python… and you also need to understand the business.

The essence of this shift is that once AI takes over the code execution layer, human value migrates to higher-level decision-making. You need to know what should be built, what shouldn't, which approach is better, and which architecture is more scalable. This judgment comes from broad technical vision and deep business understanding, not from proficiency in a single language.

Developer role transformation in the AI era

Tool Selection: Premium or Free?

Regarding model selection, the developer shared pragmatic advice:

For everyday learning: Free domestic (Chinese) LLMs are perfectly adequate
For specific product needs or professional use: Consider top-tier overseas models like Claude
Claude's top-tier plan at $200/month: If you use it as an "employee," the output far exceeds the cost — "I think it's worth it"

The core takeaway: The model itself doesn't matter — what matters is the methodology. Regardless of which tool you use, the key is mastering the ability to harness AI — how to break down requirements, how to describe problems, how to evaluate results, and how to iterate and optimize.

The so-called "methodology for harnessing AI" centers on four key stages: requirement decomposition, prompt engineering, result evaluation, and iterative optimization. Requirement decomposition means breaking a complex goal into subtasks that AI can complete in a single pass. Prompt engineering means using precise and effective natural language descriptions to guide AI toward high-quality output. Result evaluation requires developers to have sufficient technical judgment to identify potential issues in the code. Iterative optimization involves refining the output through multiple rounds of conversation. The essence of this methodology is transforming traditional "coding ability" into "communication ability + judgment ability," placing higher demands on practitioners' overall competence.

From Executor to Architect

The most valuable takeaway from this live experiment isn't those 10 mini-games — it's the cognitive shift it conveys: in the AI programming era, everyone has the potential to become an architect. You don't need to memorize syntax details or manually debug every line of code, but you do need to understand how systems work, how to decompose requirements, and how to ensure quality.

AI isn't omnipotent, but it's already an "extremely powerful tool." Those who are skilled at leveraging this tool will achieve orders-of-magnitude improvements in efficiency. And those who understand both technology and business, who can harness AI while thinking independently — they are the truly scarce talent of this era.