TL;DR: OpenAI's Codex first learned to check its own UI work with GPT-5-Codex in September 2025: it could render a screen, look at screenshots of the result, and fix what it saw. A year on, that loop is built into the product. Codex reviews interfaces in its own browser, takes comments on specific elements, and runs on OpenAI's GPT-6 models. At The Gradient, working this way turns validation that used to take weeks into days, but it doesn't replace designers: AI catches friction, and people still decide which trade-offs serve the product and the business.
In September 2025, OpenAI released GPT-5-Codex, a version of GPT-5 tuned for agentic coding. For the first time, Codex could not only write front-end code but also open the result, see it, and visually check its own work.
To be clear, Codex isn’t a design tool. It is OpenAI’s coding agent, available as a desktop app, a CLI, and an IDE extension. But as more designers move closer to code, it opens new ways to build, test, and validate ideas directly, without waiting for full dev cycles.
This isn’t just faster coding. It’s a redefinition of how design and development collaborate.
How Codex learned to review UI: from GPT-5-Codex to GPT-6
This article was first published in November 2025, when visual self-checking was a launch demo. Over the following year, it became part of how Codex works.
September 2025: Codex starts looking at its own output. GPT-5-Codex could render a front end, take screenshots, and fix what it saw. Review happened at the level of a single screen, and the designer still had to describe problems in words.
November 2025 – February 2026: longer tasks, one workspace. GPT-5.1-Codex-Max was built for long-running, project-scale work, and GPT-5.3-Codex combined Codex with OpenAI’s general GPT-5 training. In February, Codex also got its own desktop app. For UI work, this meant checking a whole flow in one session rather than one screen at a time.
April 2026: designers can point instead of describe. The Codex app added an in-app browser where you comment directly on elements of a rendered page. Feedback that used to be “the card on the right feels cramped” became a note pinned to that card.
May 2026: annotations become design input. Advanced annotations let you adjust font size, colours, and spacing on the page itself and pass those values to Codex. The designer’s correction arrives as a specification rather than an opinion.
Autumn 2026: the GPT-6 generation. Codex now runs on OpenAI’s GPT-6 models. GPT-6.1 Sol, released in September, is the default in the Codex CLI. Combined with checks against reference screenshots at different screen sizes, the build–look–fix loop from the original demo is now a routine step.
From Prompt to Prototype in Minutes
In OpenAI’s launch demo for GPT-5-Codex, Codex received a rough wireframe — a 3D globe for a travel app. Within minutes, it built a responsive screen, animated the globe using Three.js, and verified both mobile and desktop layouts. No manual QA, no handoff, no waiting for developer capacity.
It even validated dark mode and suggested adjustments like tooltips or spacing tweaks. That’s not magic — it’s fast automation with “average but good-enough” output, ideal for testing before design teams step in to refine.
A year later, the same task looks different in practice. The globe would be built and checked inside the Codex app’s own browser, and instead of asking for “tooltips or spacing tweaks” in a prompt, a designer would mark the exact element and the spacing value they want.
For design teams, it means less time lost between idea and implementation. For businesses, it means faster MVPs, quicker validation, and shorter time-to-market. Let’s dive in a little deeper.
What This Means for the Design Industry
Until now, design agencies have worked across three main layers: research, UX/UI design, and implementation. Codex, among other AIs, blends these layers into one continuous loop.
- From static to interactive design — teams can test flows directly in the browser, not just on Figma boards.
- From handoff to co-creation — developers and designers now share one AI teammate instead of passing files back and forth. Since Codex added browser comments, they also share the same surface: the rendered product, annotated directly.
- From weeks to hours — interactive prototypes can be generated and tested the same day.
This shift makes AI-assisted UX/UI design a new standard rather than an experiment.
How Codex fits into our AI design workflow
At The Gradient, we’ve been exploring AI-powered workflows long before they became fashionable — from AI-accelerated product discovery to rapid prototyping. As early adopters of AI in design, we’ve built our own way of working — one that merges design, engineering, and AI experimentation into a single, fluid process.
Prompts > Pixels
Beautiful UIs matter, but in AI products, prompts do the heavy lifting. So we focus heavily on writing, testing, and evolving the right ones.
We Call It “First, We Build.”
Instead of spending months on screens and presentations, we start coding from day one. In the first week of collaboration, our team already produces a live, playable prototype — not for show, but to test value. Because ideas that sound great in theory often collapse in practice — and we’d rather learn that early.
Real Examples From Our Design Projects
Take our Norvana project as an example. Initially, we designed an “activity score” feature — a daily tracker that showed users how close they were to reaching a target score (say, 78 out of 85). On paper, it sounded motivating. But once we built and tested it with real data, it turned out no one cared. The metric felt abstract, disconnected from real behaviour — users didn’t feel progress or purpose.
That moment became a turning point: we realised you can’t design AI experiences in theory; you have to live them. The only way to know if something works is to make it real, interact with it, and see where it breaks. This philosophy now defines how we build. We don’t chase perfect flows — we chase validated value.
Our designers don’t stop at Figma; they work hands-on with AI tools like Cursor, Lovable, and Replit. That allows us to feel the product, not just visualise it — to experience how AI responds, what it asks, and whether the interaction feels natural. It’s design through experimentation, not assumption.
Here’s how this process changes outcomes for our clients:
1. Faster Design Validation
Codex and similar AI tools let us assemble interface components and test them across devices within hours. In our experience, validation that used to wait for a designed prototype and a developer’s time now happens in days, and clients get a working version to explore almost immediately.
2. Real-time Iteration and Value Testing
Our teams iterate in real time — testing hypotheses, user reactions, and flows in living prototypes instead of static mock-ups. It’s no longer about making things look perfect; it’s about finding what genuinely works and improves user experience.
3. From Chaos to Clarity
Every project starts with a messy mix of ideas and hypotheses. AI helps us turn that chaos into something tangible in days. By bringing prototypes to the first client meeting, we make collaboration faster, cheaper, and more engaging — clients can see, click, and react.
The result: fewer assumptions, more evidence, and a strong sense of momentum from day one.
4. Continuous Co-creation
Designers, PMs, and engineers now collaborate inside shared AI environments. Instead of lengthy handoffs, we exchange prompts, sketches, and lightweight code snippets. This makes enterprise design cycles leaner, clearer, and far more human-centred.
5. The Lower Cost of Error
Because everything moves faster, mistakes are cheaper. When testing takes days, not months, teams are more open to feedback and experimentation — and products evolve faster.
What can Codex check, and what still needs people?
AI usability testing with Codex covers the mechanical layer: whether a layout breaks at a given breakpoint, whether text overflows, whether every state renders, whether the console throws errors, and whether the build matches a reference screenshot. It does not tell you whether real users understand the flow, trust it, or want it. That still takes research with people.
Each model generation has widened the mechanical layer. Codex now handles longer tasks, whole flows, and precise visual corrections. The judgement layer hasn’t moved: a newer model is better at matching a reference, not at deciding whether the reference is right.
While AI tools redefine speed and automation, great design still requires empathy, judgement, and taste — things AI can’t replicate.
- 𐩒Understanding context and emotional nuance: AI can flag friction but cannot always understand cultural expectations, behavioural triggers, or emotional tone. This is where human judgment stays essential.
- 𐩒Aligning suggestions with product strategy: AI can say “this is confusing,” but only humans can decide whether confusion is a necessary trade-off — or whether a design choice supports long-term business goals.
We use AI to generate quick MVPs, then jump into Figma to polish, craft, and infuse visual identity. Design remains the key differentiator — the layer that turns “AI-made” into “human-loved.”
What This Means for Designers and Product Teams in 2026
AI is shifting from an experimental add-on to a stable layer in product operations. Instead of speeding up design for the sake of speed, Codex improves how teams evaluate options, reduce uncertainty, and make decisions that hold up in delivery. It changes not what teams do, but when they learn what matters — and how quickly they can correct course. The direction of travel over the past year is clear: less time explaining problems to the tool, more time deciding which problems matter.
AI-Assisted Workflows Reduce Discovery Noise
Codex helps teams cut through guesswork at the earliest stages. Instead of exploring ideas blindly, designers and PMs can see:
- 𐩒which flows create unnecessary effort,
- 𐩒where users are likely to stall,
- 𐩒which concepts introduce technical or cognitive complexity.
This gives product teams a cleaner starting point, improves prioritisation, and prevents unproductive cycles before engineering gets involved.
Faster Validation of Decisions That Shape the Roadmap
Codex doesn’t decide what gets built — it clarifies the impact of choices. For product managers, this means:
- 𐩒validating assumptions before they become epics,
- 𐩒identifying high-risk patterns early,
- 𐩒comparing variants in minutes instead of waiting for full usability tests.
The result — fewer late-stage surprises and a roadmap grounded in evidence rather than optimism.
Human Judgement Stays at the Centre — but With Better Visibility
AI highlights patterns and friction, but people weigh trade-offs. Teams still decide:
- 𐩒whether a flagged issue matters for the user segment,
- 𐩒whether complexity is acceptable for the business goal,
- 𐩒how the experience should feel in a specific cultural or product context.
Human judgment sets direction; AI removes blind spots that slow decision-making.
In a Nutshell
Vibecoding brings speed to design — not perfection. It helps teams test ideas earlier, validate faster, and bridge the gap between concept and code.
At The Gradient, this isn’t a shift we’re adapting to — it’s the space we’ve already been building in. We design AI-native products by combining intelligent automation, rapid prototyping, and human-level craft — using tools like Codex not to replace creativity, but to scale it.
What does this mean for you?
Discuss with your AI.
A Product Strategist with over 13 years of experience in marketing, product strategy, and branding. His love for analytics, funnels, and a structured approach ensures that the digital products we craft aren't just functional—they impress.
