ChatGPT Codex vs Traditional Coding – You Need to See This

Why the ChatGPT desktop app matters

A new wave of development tools is changing how software gets built, and the ChatGPT desktop application sits at the center of this transformation. Unlike the browser version, the desktop app gives you direct access to your local file system, terminal, and integrated development environment features that turn it into a genuine coding workspace. Leon van Zyl demonstrates exactly this shift by building a complete fitness application from scratch, without writing a single line of code himself. The approach combines the conversational power of large language models with the practical requirements of real-world development: running commands, managing files, and testing output visually.

The tutorial opens with a clear rationale for moving beyond the web interface. When you work in the browser, you are limited to copying code snippets and pasting them into your editor. The desktop app collapses that gap by understanding your project structure, reading files directly, and executing shell commands. This makes it possible to describe a feature and watch the application materialize, which is precisely the workflow Leon demonstrates over the course of nineteen minutes. The result is an AI-native fitness tracker that runs locally, powered by a free model served through Ollama.

Setting up the Codex workspace

Installation is the first practical step, and the video handles it methodically. Leon walks through downloading the ChatGPT application from the official OpenAI site, then immediately dives into the workspace layout that Codex provides. Workspaces are session-based containers that keep project context organized across multiple files and interactions. Instead of a single linear chat, you get a persistent environment where the model remembers your project structure, your coding preferences, and the tools you have enabled.

The settings tour reveals how much control the desktop app actually offers. You can select different models, adjust temperature and token limits, and enable specific agentic capabilities that turn the assistant into a far more autonomous developer. Leon emphasizes that this configuration step is not optional fluff but foundational. Choosing the right model for the task, whether it is GPT-4o for complex reasoning or a faster variant for quick iterations, directly affects the quality of the generated application.

Planning with Plan Mode and Grill Me

One of the most valuable techniques in the video is the structured planning phase. Leon activates Plan Mode, a specific thinking strategy that forces the model to outline the architecture, component tree, and data flow before writing any implementation code. This prevents the common problem of AI coding assistants that dive straight into code and produce a tangled mess that is hard to debug or extend later.

He introduces the Grill Me skill from skills.sh, which acts as a critical reviewer during the planning stage. When you invoke Grill Me, it interrogates your plan for logical flaws, missing edge cases, and architectural weaknesses. Leon uses it to stress-test the fitness app design, asking questions like how user data will persist, how the AI model integration will handle latency, and how the user interface will remain responsive. This process mirrors a senior developer reviewing a technical specification and is what separates a prototype from a production-ready application.

Feature files and agentic skills

Feature files become the central planning artifact in this workflow. Instead of a single monolithic prompt, Leon breaks the application into discrete features expressed as structured descriptions. Each feature file tells the model what to build, what inputs to expect, what outputs to produce, and what constraints to follow. This modularity means you can revisit individual features without destabilizing the entire application, and it aligns perfectly with how professional development teams work.

The plugins and agent skills layer adds another dimension of capability. Leon demonstrates how to equip the Codex workspace with tools that can read documentation, search the web for current best practices, and even scaffold boilerplate code from frameworks like Next.js. These skills transform the assistant from a code generator into a development orchestrator that can coordinate multiple sources of information. The Vercel AI SDK makes an appearance here, showing how you can bridge the generated frontend with serverless AI inference endpoints in just a few lines of configuration.

Parallel sessions for UI and logic

The workflow takes an interesting turn when Leon splits his work across parallel sessions. One session handles the user interface mockups and design system, generating the React components and styling rules. Another session simultaneously tackles the backend logic, setting up the Ollama integration and the API routes that will serve the fitness recommendations. This separation of concerns means you can iterate on the visual layer without waiting for the backend to be complete, and vice versa.

Within the UI session, Leon generates a design system that enforces consistency across buttons, cards, input fields, and typography. The model produces Tailwind CSS classes and reusable component patterns that give the fitness app a polished look without requiring manual tweaking in a design tool. Meanwhile, the logic session sets up the integration with Qwen 3.6 running on Ollama, ensuring that the AI-powered features like workout generation and nutrition suggestions are fully wired before the frontend expects them.

Saving, splitting, and implementing the plan

After the planning artifacts are ready, Leon demonstrates how to save the entire plan state and split it into implementable chunks. This step is critical for maintaining context when your session grows large. By persisting the plan and reloading only the relevant chunk, you avoid hitting token limits and keep the model focused on the specific feature you are currently building.

The goal command becomes the driver for implementation. Leon types a high-level objective, and the Codex agent autonomously works through the necessary steps: creating files, writing code, installing dependencies, and running build checks. He shows how to watch the terminal output directly inside the desktop app, catching errors as they occur and feeding them back to the model for correction. This tight feedback loop shortens the iteration cycle dramatically compared to switching between a chat window and a separate IDE.

Testing with Pet Command and final result

Testing is often the most neglected part of AI-generated code, but Leon addresses it with the Pet Command approach. This is a quick testing interaction where you feed the model specific scenarios and let it verify that the application behaves correctly. For the fitness app, he tests edge cases like empty inputs, rapid button clicks, and offline fallback behaviors when the Ollama server is unavailable.

The final result is a fully functional fitness application that tracks workouts, generates personalized suggestions using the local Qwen model, and maintains a clean, responsive interface. Leon recaps the entire workflow, from installation through planning, parallel development, implementation, and testing. The recap reinforces the core message: the ChatGPT Desktop App combined with free local models makes professional-grade AI application development accessible to anyone who can describe what they want to build.

Who this workflow is for

The tutorial speaks to a broad audience that includes professional developers looking to accelerate their output, no-code builders who understand logic but prefer not to write syntax, and AI enthusiasts who want to understand how agentic coding works in practice. Leon's style is pragmatic and fast-paced, assuming you are comfortable with terminal commands and basic web development concepts. If you have ever felt that AI coding assistants were too shallow for real projects, this video shows a structured workflow that changes that perception.

The use of Ollama and the free Qwen 3.6 model is a particularly strong point for builders who want to avoid API costs during experimentation. By running everything locally, you can iterate as much as you want without worrying about usage bills. This democratizes the development process and encourages experimentation that might otherwise feel prohibitively expensive with paid cloud APIs.