Hands-On Test of GPT-5.6's Three Models Sol/Terra/Luna: How Good Are Their Coding Skills?

GPT-5.6 Release: A Full Breakdown of the Sol, Terra, and Luna Models

OpenAI has launched three new models all at once, with names carrying a distinctly cosmic imagery—Sol (Sun), Terra (Earth), and Luna (Moon). The tiered logic is clear and intuitive. The three are positioned as follows:

• GPT-5.6 Sol: The flagship high-performance model with the strongest overall capabilities
• GPT-5.6 Terra: Mid-tier positioning, balancing performance and cost
• GPT-5.6 Luna: A lightweight, entry-level version suited for light tasks

Behind this celestial naming convention lies the maturation of tiered product line strategies in the AI industry. From an industry background perspective, Anthropic established a three-tier architecture of "lightweight-balanced-flagship" as early as the Claude 3 series with Haiku, Sonnet, and Opus, while Google Gemini similarly formed tiers with Nano, Pro, and Ultra. The core driving force behind this tiered logic is the differentiated management of inference cost.

Inference Cost and Architecture Background: Inference cost refers to the computational resource overhead required each time a large language model generates a response. It is primarily determined by the number of model parameters, the number of activated experts, and the number of generated tokens combined. Current mainstream flagship models commonly adopt the Mixture of Experts (MoE) architecture—replacing the model's feedforward neural network layers with multiple parallel "expert" subnetworks. During each forward pass, a lightweight "router" dynamically selects and activates 2-4 of these experts rather than all parameters. This allows the total parameter count of the model to be enormous (GPT-4 reportedly exceeds 1 trillion parameters), while the actual number of parameters activated per inference is only a small fraction of the total, significantly reducing computational costs without sacrificing model capacity. The compute cost per API call for flagship models can still be 10-50 times that of lightweight models, so the industry also widely adopts Knowledge Distillation technology—formally proposed by Geoffrey Hinton's team in 2015. Its core idea is to have a small model (Student) learn the soft labels (probability distributions across categories) output by a large model (Teacher), rather than simple hard labels. In LLM scenarios, distillation typically includes three approaches: response distillation, feature distillation, and black-box distillation. Lightweight models such as GPT-4o mini and Claude Haiku extensively use this technology, retaining 60-70% of the flagship model's overall capabilities even with over 80% reduction in parameter count. For enterprise users, selecting the appropriate tier of model based on task complexity can substantially reduce API call costs; for consumer users, lightweight models mean faster response speeds.

This naming and product tiering approach has led many users to immediately associate it with Anthropic's Claude series. The reviewer bluntly stated: "There's a suspicion of clumsy imitation of Claude." Beyond the models themselves, this update also made an important integration: merging ChatGPT with Codex, and unifying the launch of "Work mode" across the web, mobile App, and desktop versions.

Work Mode: The Return of Cloud Codex

Users familiar with OpenAI's product line may recall that the web version once had a Codex feature supporting cloud-based task execution, which was later quietly discontinued. To understand the origins of Work mode, one needs to trace back the history of Codex: it was first released as a standalone API product in 2021, being the industry's first large language model optimized specifically for code generation. GitHub Copilot's underlying engine was based on the early Codex version.

Codex's Technical Path and Its Ties to GitHub Copilot: Codex's core technology involves fine-tuning on top of GPT-3 using approximately 154 billion tokens of public code repository data (primarily from GitHub, covering 54 programming languages). Compared to general-purpose language models, Codex achieved a pass@1 accuracy of 28.8% on function-level code completion tasks (the HumanEval benchmark), while contemporaneous GPT-3 scored only 0%. This generational gap validated the effectiveness of domain-specific fine-tuning. Notably, when GitHub Copilot entered public beta in June 2021, its underlying engine was precisely the early Codex version—this collaboration between GitHub (owned by Microsoft) and OpenAI pioneered the commercialization paradigm of "foundation model + vertical product + cloud computing infrastructure": OpenAI provided the model capabilities, GitHub provided the massive code training corpus and distribution channels, and Azure served as the compute backbone. After the Codex API was discontinued in March 2023, Copilot's foundation gradually migrated to the GPT-4 series, and this trajectory also reflects the overall trend of AI code assistants shifting from "specialized fine-tuned small models" to "general-purpose flagship models." Code Interpreter (now called Advanced Data Analysis) took things a step further based on Codex's capabilities by equipping the model with a Python sandbox execution environment, allowing the model not only to generate code but also to run code and use the execution results as new context for continued reasoning—this "closed-loop verification" mechanism significantly reduces hallucinatory code errors.

The return of Work mode is essentially the deep integration of code execution capabilities (Code Interpreter) with a cloud runtime environment (Sandbox)—the model can not only write code but also run, debug, and deploy it in real time on OpenAI-hosted servers. This "generate-and-deploy" closed loop significantly lowers the barrier for individual developers who lack operations capabilities. This Work mode is widely regarded as being "patched up" and re-launched. The official claim is that some capabilities have surpassed the previous generation "Fable 5" (i.e., GPT-5.5), but whether the actual performance lives up to this claim still requires data to speak.

Coding Hands-On Test: Highlights and Shortcomings Coexist

The reviewer used Codex as the core tool to conduct multi-scenario practical testing, ranging from mini-games to web development.

Highlight One: One-Click Deployment Makes Publishing Easier

The most noteworthy practical new feature in this update is: paid users can directly use OpenAI servers to host and deploy Web projects. After the AI finishes writing a web project, it can be directly deployed and return an access link. The default is private deployment (requiring account login to view), but it also supports public deployment or binding a custom subdomain.

In the classic Mario mini-game test, the new model not only successfully implemented the functionality, but its UI design also showed a marked improvement over the previous generation—the game ran normally, the character could grow larger, and the overall experience was smooth.

Highlight Two: Commendable Interactive Project Design

When creating an "interactive camera (clay effect)," the model's performance was quite impressive. The page design was refined, supporting marker recognition toggles, adjustable deformation intensity and influence range, and it could seamlessly switch between touch and mouse operations. The skeuomorphic dial design and lighting details received high praise from the reviewer, who felt it was "indeed far stronger than the previous generation."

Fatal Flaw: Pure Aesthetic Design Remains a Bottleneck

However, once purely aesthetic design was involved, problems emerged. When creating a "GPT-5.6 introduction video," the animations such as card hover jitter and seamless zooming were quite smooth, but the overall visual style was criticized as "like childhood winter break homework—finished, but questionable in terms of visual appeal."

When creating an introduction website relying solely on the model's own capabilities without the help of aesthetic enhancement plugins, although the finished product looked considerably better than GPT-5.5, it still had detail flaws that were hard to ignore.

Game Development Hands-On Test: A Huge Gap Between Cover Art and Actual Gameplay

The game development test was the most dramatic part of the entire evaluation, exposing an obvious "buyer's show vs. seller's show" gap.

3D Shooting Game: Stunning Cover, Failed Gameplay

The cover art the model generated for the 3D shooting game was "very good," but the actual gameplay experience was disappointing: although features like weapon switching, flying, and targeting were all present, the controls were extremely uncomfortable, "the bullets were completely invisible," and it was directly rated as "complete garbage." The side-scrolling racing game was the same—the cover art was exquisite, but the physics engine (backflip effects) performed poorly.

This phenomenon of "stunning cover, failed gameplay" reveals the core technical limitations of current LLM-generated games. AI-generated cover art relies on image generation models (such as the DALL-E series) and is already highly mature in static art assets; but actual gameplay needs to run on real-time rendering frameworks like browser WebGL or Three.js, involving complex temporal logic.

The Technical Challenges of WebGL and Game Engines: WebGL (Web Graphics Library) was standardized in 2011 by the Khronos Group and is a JavaScript-bound version of OpenGL ES 2.0, allowing web pages to directly call the device GPU to execute shader programs for 3D rendering without any plugins. Three.js wraps WebGL into a declarative Scene Graph API and is currently the most mainstream framework for browser-based 3D games and visualization, with over 2 million weekly downloads on npm. However, even with Three.js support, LLM-generated complete 3D game code still faces structural challenges: game engines need to maintain a precise "Game Loop" (typically implemented based on requestAnimationFrame), coordinating the timing of multiple subsystems such as physics calculation, collision detection, and render calls within approximately 16ms per frame. The rigid body dynamics simulation of physics engines (such as Cannon.js) is extremely sensitive to parameters—slight deviations in mass and friction coefficients can cause abnormal object behavior. Raycasting is used to determine whether a bullet hits a target and requires precise transformations between world coordinates, camera coordinates, and screen coordinates—LLMs are prone to systematic errors when handling such multi-coordinate-system conversion problems, manifesting as the visual phenomenon of bullets "missing" targets. These bugs are invisible during static preview and only surface when actually run.

CS-Style Game: Unexpectedly High Completion

In contrast, the performance of "creating a high-fidelity CS game" was actually more satisfying. Core gameplay mechanics such as switching between three weapons, bullet marks, and the bomb-defusal mission were all relatively complete, and the reviewer felt it was "actually written pretty well." This result was no accident: the core mechanics of CS-style games (shooting, collision, scoring) can be implemented with relatively simple two-dimensional logic, involving far fewer boundary conditions than 3D physics simulation, so the LLM's code generation success rate is higher. Additionally, a Blender live-action composite modeling test took over an hour to complete, with the AI matching its own sound effects, and the overall result even had "a touch of humor."

Making PPTs in Work Mode: A Disaster Zone for Efficiency

Work mode is designed for office scenarios. The reviewer used the creation of a popular-science PPT as an example for testing, and the result was nearly catastrophic:

• Staggering Time Consumption: Processing took as long as 24 minutes and still didn't finish, ultimately ending in "exhaustion"
• Quota Surge: A single task consumed about 30% of the weekly quota
• Extremely Slow Speed: Even at 1.5x playback speed, progress was still sluggish

The fundamental reason for this phenomenon is that Work mode adopts an Agent-style task execution architecture. Unlike ordinary conversation mode, Work mode operates based on ReAct (Reasoning + Acting) or similar frameworks: while completing a task, the model repeatedly cycles through the process of "thinking → calling tools → observing results → thinking again."

The Technical Bottleneck of Agent Architecture, Context Windows, and Attention Mechanisms: The ReAct framework was proposed by Yao et al. in a paper jointly published by Princeton and Google in 2022. Its core innovation is interleaving Chain-of-Thought reasoning with tool calling—the model generates explicit "thinking" steps before each tool call, then observes the tool's returned results before proceeding to the next round of reasoning, forming a "think → act → observe" loop. OpenAI's Work mode, Anthropic's Claude Computer Use, and Google's Project Mariner are all productized implementations of this type of architecture. The fundamental bottleneck of this architecture lies in context accumulation: to create a 20-page PPT, the model may need to search for materials (3-5 times), generate an outline (once), create content page by page (20 times), and debug code (5-10 times). Each call retains all prior content in the context window, and the final total length may exceed 100K tokens. At the underlying level, the computational complexity of the Transformer's standard self-attention mechanism is O(n²·d). When the context expands from 32K to 128K tokens, the attention computation theoretically increases by about 16 times. Although algorithms like FlashAttention reduce memory access complexity from O(n²) to O(n) through IO-aware block-wise computation, the engineering-level quality degradation problem still exists—research has found that LLMs pay far less attention to the middle portion of context than to the beginning and end (the "Lost in the Middle" phenomenon), causing formatting requirements set early on to be easily diluted by later tool outputs, with output quality continuously declining as the task progresses. Additionally, the accumulated latency of tool calls (each HTTP request takes 100-500ms) and the fact that early errors are continuously amplified by subsequent reasoning treating them as true premises also make the risk of error propagation in long tasks significantly higher than in single-round conversations. This phenomenon is called "Context Window Pollution" in the industry.

The model's "habitual divergence" and frequent calling of numerous tools led to extremely high token consumption, and the finished product still had obvious bugs, such as the blue dots of bullet points appearing below the text. The reviewer's clear advice is: using this mode to make PPTs is not recommended; if you must use it, just choose the lowest-tier Luna model—lightweight models have faster inference speeds and lower per-call costs, so in multi-tool-call scenarios, the total cost may actually be more controllable.

Quota Consumption and Real Usage Experience

During the testing process, the reviewer reset the quota twice, all of which was consumed by the aforementioned cases. He estimated that without resetting, only about 20%-30% of the weekly quota would remain. The good news is that in the early stage of the model's release, OpenAI has already reset the quota two or three times in a row, making it relatively "generous and filling."

Real Use Case: A Biology Study Webpage for High School Students

At the end of the video, a webpage for Chapter 2 of Biology Elective One created by a netizen using GPT was showcased, covering complete content such as neural regulation reflex arc animations, knowledge overview diagrams, true/false questions, and multiple-choice questions. Although the front-end had some breakdowns, it "genuinely met the learning needs"—this also confirms the practical value of AI programming in educational scenarios.

Conclusion: Progress Made, but Falling Short of Expectations

The reviewer's final conclusion is objective and fair:

"If you only look at the front-end, it hasn't surpassed GPT-5.5; but taking a comprehensive view of factors such as ample quota and a smarter model, it can indeed hold its own against the previous generation."

Facing the community's high-profile promotion that "the front-end has comprehensively surpassed GPT-5.5," as well as the elevated expectations raised by team members hyping it up on the X platform for over a month, the actual experience can only be described as "falling short of expectations." GPT-5.6 has indeed made progress in coding ability and interactive design, and one-click deployment is a commendable practical highlight; but its aesthetic shortcomings, poor game physics effects, and the high consumption and low efficiency in office scenarios remain real problems it needs to confront directly. Interested users may want to try it out hands-on before making a judgment.