I tested GPT-5.5 and GPT-5.6 SOL using 5 real front-end scenarios: SOL won 4 games but was 13% slower

On July 10, 2026, I put GPT-5.5 and GPT-5.6 SOL into the same Codex execution chain and performed five sets of front-end tasks in succession. Five scenes, ten pages, and a total running time of 84.6 minutes. Operations Dashboard, Kyoto city discovery, 16-step drum machine, modular table lamp configurator, theater seat selection. Each set of prompts has been verified by SHA-256, and the text obtained by the two models is the same word-for-word. The reasoning effort is all high, the service tier is all standard, and execution is sequential, not concurrent. Let’s talk about the results first. The overall quality score of GPT-5.6 SOL is 94.4 and GPT-5.5 is

• 4. SOL won four of the five games. It is more stable in terms of visual hierarchy, product language and mobile space. The cost is also clear: SOL takes
• 9 minutes in total, compared to 39.7 minutes for GPT-5.5, which is
• 0% slower. Engineering inspections were barely pulled apart. GPT-5.5 passes 113/115, SOL passes 114/115. SOL spent more time in exchange for better product expression, but not in exchange for stable functional differences. Real generation times for five scenarios.
• 6 SOL Only Dashboard is faster, the remaining four games are equal or slower. How to test: First remove the framework and network noise. This comparison only looks at the model's ability to turn requirements into front-end products. I didn't let them choose a framework, nor did I install a component library. Each task can only generate one index.html that can be run offline, and cannot call external fonts, network images, third-party scripts or APIs. This restriction is useful. Models cannot rely on familiar component libraries to quickly piece together a set of default interfaces, nor can they leave visual quality to ready-made assets. Page structure, CSS, interaction state, charts, graphics, and responsive processing all go into the same file. The acceptance is also completely consistent. Each page runs under two viewports of 1440×960 and 390×844 respectively, and checks horizontal overflow, console error, page error, keyboard operations, semantic structure and scene interaction through Chrome and Playwright. Five sets of tasks totaling 115 inspections. The rating scale includes seven items: implementation correctness, visual hierarchy and scene fit, responsiveness, interaction and state completeness, accessibility, engineering quality, and completion discipline. Machine failure will directly affect the functionality and accessibility scores. Beautiful screenshots cannot cover the failure. Each of these five scenarios pulls a set of front-end constraints: Dashboard tests high-density information architecture, city discovery page tests content editing and scene language, drum machine tests high-frequency status and tool interface, configurator tests derived status and purchase chain, seat selection tests two-dimensional space, selection feedback and order summary. Only doing landing pages can easily misjudge "being able to write beautiful CSS" as complete front-end capabilities. Scenario | Main Pressure | The Most Easily Exposed Problem This method also has boundaries. There are only five samples, the tasks are all started from scratch, and the results cannot be directly extrapolated to large React projects, design system migrations, or long-term maintenance. However, it is enough to answer a practical question: when given the same clear front-end goal, where will the two models spend their time and what will be the difference in the deliverables.
• 6 The improvement of SOL first appears in screen distribution. Operation Dashboard is responsible for testing high-density information architecture. The page needs KPIs, trend charts, queue status, filter tables, search and detail drawers. The desktop version must be secret and the mobile version must be operable. GPT-5.5 took 637.7 seconds and SOL took 533.9 seconds. This is the only faster scene in SOL. Both sets of pages can fit a lot of information into the first screen, and SOL's hierarchy is more restrained: there are fewer status colors, the priority of tables and charts is clearer, and the mobile navigation is more complete. The final score was 96 to
• SOL is faster and more complete in this one; The GPT-5.5 drawer can be opened, but cannot be closed using Escape. The GPT-5.5 point loss occurred on a small interactive contract. The conversation drawer can be opened, but Escape cannot be closed. The model's own verification record states that "Escape close" has passed, and later failed when reproduced by an external Chrome evaluator. This problem is not visible visually, and it may be missed by manual inspection by clicking the mouse to close it. The Kyoto City Discovery Page is responsible for testing content pacing and scene language. The requirements emphasize editorial rhythm, location cards, collections, filtering, itinerary status and mobile bottom sheet. Obvious domain differences begin to appear here. GPT-5.5 makes a functionally clear set of travel products, like a well-organized set of standard cards. SOL's pages are more like editorial choices: serif titles, paper colors, location density, image replacement graphics, routes and collection status are all organized around the Kyoto scene. It knows what content should be left blank and what the bottom panel on mobile should be responsible for. The speed of the two is close,
• 4 seconds vs.
• 7 seconds, but the score is 84 vs.
• GPT-5.5 is stuck in Escape again, the bottom sheet can be opened, but the keyboard cannot be closed. The speed difference is only
• 3 seconds, and the difference in picture judgment is larger than the time difference. GPT-5.5 mobile bottom panel does not complete Escape closing. The 16-step drum machine is responsible for testing the high-frequency status and tool interface. The page should not only have a beat grid, tracks, playback status, BPM and swing, but also allow users to understand the current pattern at a glance. GPT-5.5 completed in 475.2 seconds and scored
• It has all the functions, but there is an obvious empty area on the first screen, and the controls are more like web forms. SOL took
• 4 seconds, 155.2 seconds longer. It turns the space into a device panel, and track grouping, illuminated step points, transport controls and mobile storage are closer to real creation tools, with a score of
• Both sets of interaction checks passed. SOL takes two and a half minutes longer, with the main differences falling in tool atmosphere, space utilization, and status readability. Putting these three games together, SOL's advantages are already clear. It prefers to first determine which product the page belongs to, and then decide on density, fonts, colors, and above-the-fold focus. GPT-5.5 gets into component implementation faster, pages are generally correct, compact, and usable, and the visual language doesn't change as much between scenes. Time Account: More reasoning, more code, and slower. In total, SOL took
• 9 seconds longer than GPT-5.5 over the five games. The total wall time is
• 0% higher, and the median time per game is
• 2% higher. The output token is
• 54% more, the reasoning output token is
• 74% more, and the final total HTML size increases from 194,127 bytes to 226,321 bytes. These numbers illustrate the heavier workings of the SOL. It spends more inference budget organizing the page, and writing more CSS and state code. The results were indeed better across the four, but the speeds were inconsistent: Dashboard was
• 9 seconds faster, Kyoto was 14.3 seconds slower, drum machine was 155.2 seconds slower, configurator was 93.6 seconds slower, and seat selection was 150.7 seconds slower. Therefore, "the new model is faster" cannot hold up in this actual test. It may converge faster on complex information architecture, or it may continue to polish for product completion and lengthen the entire execution time. For one-time exploration, this time is easy to tolerate; throw in a lot of page generation or frequent iterations, and 13% becomes a real throughput cost. The speed also needs to be calculated together with the verifier loop. If the first build is prettier but still has to go through the same browser regressions, the team saves design discussions, not necessarily testing time. If the purchase chain needs to be repaired after generation, a high first-round score can even create a false sense of completion. Project Account: Beautiful pages will also be interrupted when closing. The modular desk lamp configurator is the only clear winner of GPT-5.5. This set of requirements includes material, lamp arm, base, light, quantity, real-time price, configuration code, CSS table lamp graphics and shopping cart confirmation. GPT-5.5 took 423.6 seconds and scored
• SOL took
• 2 seconds, the page is more refined, the lamp rendering, material selection and sticky purchase bar all look like mature products, but the score dropped to
• The reason is straightforward: SOL's Add to cart does not open the required confirmation panel. If the purchase chain is broken at the closing action, the e-commerce page will not be completed. SOL has a more mature picture, with purchase confirmation not happening. GPT-5.5 won this game with a complete interactive chain. What’s more interesting is SOL’s final message. It clearly says "Accessible cart confirmation with focus trapping, close button, and Escape support" and also says that the final interaction consistency pass has been completed. Real Chrome has no confirmation panel after clicking the button. What the model verifies is the code structure and the state inference constructed by itself. What the browser verifies is what state the page is in after the user clicks. The two are not equivalent. GPT-5.5 also shows the same trend on Dashboard and Kyoto pages. It claimed to have verified Escape close in the final message, but the browser overturned the conclusion. Both models can write validation narratives that look believable, and both models overestimate the coverage of static checks and simplified DOM harnesses. Theater seat selection gives another side. Seat selection, fare, quantity, order summary, keyboard operation and mobile layout of both sets of pages all passed. GPT-5.5 took
• 4 seconds and scored 95; SOL took 564.1 seconds and scored
• SOL, with clearer seating space, stage direction and information hierarchy, was only two points behind, but
• 7 seconds longer. When all functions passed, SOL continued to win in scene space and responsive details; it took an extra two and a half minutes to complete these two points. Ten pages captured no console error or page error on both desktop and mobile. This is good news, but also a reminder not to mistake "quiet console" for "functionally correct." The three failures were all state contract failures, JavaScript did not report an error, and the interface did not crash. Why is the model self-test distorted? The three failures have a common background: the execution environment in which the generated model is located may not be able to stably start a real browser. In the running log, the model tried headless Chrome, Playwright and temporary profiles multiple times. Some environments lacked browser engines, and some Chrome exited directly in the sandbox. They then fall back on JavaScript syntax checking, static hook scanning, simplified DOM harnessing, and source code review. These checks are not ineffective. They can catch syntax errors, missing selectors, unbound events, inconsistent explicit state functions, and can also confirm single-file and offline constraints. The problem is with the conclusion boundaries. The simplified harness proves that a certain handler changes variables in the simulated DOM, and cannot prove that the focus, hidden attributes, CSS priorities, event propagation and actual node relationships in the browser work together. Dashboard's Escape failure is this boundary. There is closing logic in the code, and the model also executes its own DOM harness, but the drawer in the real page does not disappear as expected. The configurator is more typical: SOL has written confirmation, focus trap and close handler. The static structure is complete, but the actual click does not make the confirmation panel enter the visible state. Therefore, I treat the model final message only as "developer readme". It can tell us what the model checked and cannot replace the acceptance results. The external evaluator reopens the final file and operates according to the user path in a clean Chrome session to be eligible to stamp the interaction status. This also explains why accessibility comes into the same set of regressions. The ARIA label on the button can only prove the existence of the semantic entrance; whether Escape can be closed, where the focus returns after closing, and whether the keyboard can still be accessed after the mobile menu is expanded are all runtime behaviors. Leaving accessibility to manual spot checks, it's easy to miss two GPT-5.5 failures that happen to be in the path of the keyboard. For the Agent workflow, there is a very practical division of labor: the model is responsible for generation and repair, and the verifier is responsible for producing facts that are not related to the model's cognition. The two share the same acceptance contract and do not share the "I think it's done" judgment. As long as the evaluator is independent, even if the model misjudges its own implementation, the pipeline can still stop at the correct position. How to choose? If the task is from 0 to 1 and the model needs to give visual direction, information level and mobile strategy at the same time, I will give priority to GPT-5.6 SOL. The three scenes of Kyoto, drum machine and seat selection show that it is better at writing domain into the screen, and the first version produced is more suitable for discussing products. If the interaction contract has been clearly written and the team cares more about speed and wants to quickly enter the testing and repair cycle, GPT-5.5 is still very strong. Its five-game average is
• 4, the main functions of the four scenes are solidly completed, and the configurator also handed over the most complete purchase chain this time. In actual projects, I will not let the selection stop at the model name. The generation task must also carry an acceptance contract: fixed viewport, screenshot, horizontal overflow, keyboard path, status assertion, console/page error. High-risk interactions add a layer of real browser actions, specifically payments, shopping carts, saves, deletes, permissions, and pop-up closings. There is also a simple way to judge. Divide the output into two categories: whether the visual direction is worth preserving, and whether the interaction state has been proven. The former can be determined jointly by the model and artificial aesthetics; the latter must be handed over to an independent evaluator. The two types of evidence are mixed together, and beautiful screenshots can easily endorse failed logic. This actual test makes me more willing to put SOL at the forefront of product exploration, and I am more determined to retain external verifiers. The model is already very good at generating trustworthy interfaces, and even very good at generating trustworthy descriptions of "I verified it." Whether the page can be delivered still depends on the evidence left by the real runtime. Models are responsible for pushing the first version further. Screenshots, Chrome, Playwright, and state assertions are responsible for telling us where it went.