Complete Codex Hands-On Tutorial: From Installation to Deployment

Why You Need to Master Codex

In the competitive landscape of AI coding tools, OpenAI's Codex has become an indispensable core tool for many developers. This article is based on a comprehensive tutorial by David Andre — a practitioner with over a thousand hours of AI coding experience who used Codex to build a startup that was acquired for a seven-figure sum. It charts a clear learning path from absolute beginner to full-cycle deployment.

The author's core message is straightforward: if you're not using Codex right now, you're leaving opportunities on the table. Compared to Anthropic's Claude Code, Codex performs better along several key dimensions: building complex applications, resolving deep-seated bugs, and sustaining long uninterrupted runs without errors. It doesn't just boost coding efficiency — it extends to marketing, market research, personal productivity, and virtually anything you can do on a computer.

Here's what makes this workflow stand out: you don't need any coding background. The entire process — from building a real application to deploying it — can be done through natural language conversation with Codex.

Four Ways to Use Codex and Setting Up Your Environment

Codex offers four ways to get started, presented here in order of increasing complexity. The lowest hardware barrier — accessible to anyone — is Codex CLI (Command Line Interface).

One-Command Install and Login

Installation is extremely simple. The official docs provide a single command; just paste it into your terminal (use Spotlight to search for "terminal" on macOS, or press Win+R and type cmd on Windows). Once installed, type codex to launch. The tool will automatically prompt you for updates, typically taking just 2–3 seconds.

There are three login options, and using your ChatGPT subscription account is the best choice. The author emphasizes that the $20/month Plus subscription might be "the most valuable $20 subscription in all of AI." OpenAI also offers $100 and $200 Pro tiers for heavy users who need more capacity — and now is a great time to start.

Two Terminal Commands Every Non-Developer Should Know

The author stresses that even non-developers should learn these two commands:

• ls: lists all files and folders in the current directory
• cd: changes directory (cd .. goes up one level)

The core advice: every project should run in its own dedicated folder. Don't pile everything onto your desktop — that's a classic amateur mistake.

AGENTS.md: The System Prompt for All Your Agents

No matter what you're building, the very first thing to do after starting a project is create an AGENTS.md file. This is a universal convention adopted by over 60,000 open-source projects — essentially a "README for AI Agents" that functions as the system prompt followed by all agents.

Worth noting: aside from Claude Code, which uses its own claude.md, the vast majority of agent tools — including Cursor, Gemini CLI, Windsurf, and Aider — follow the AGENTS.md standard.

The author provides a reusable template you can copy directly. When pasting large blocks of text, there's a practical context engineering tip: wrap the pasted content in XML tags so the agent can clearly identify where the text begins and ends, which noticeably improves performance.

AGENTS.md is essentially a "convention over configuration" protocol. When an AI Agent starts up inside a project directory, it automatically scans for and reads this file, loading its contents as a global system prompt into the context. This means you can pre-declare your technology preferences (e.g., "always use TypeScript, never use the any type"), code style guidelines, directory structure conventions, common commands, and project-specific business context — none of which needs to be re-explained in every conversation. As a project grows, the value of AGENTS.md compounds: it ensures behavioral consistency across different sessions and agent instances, and reduces poor decisions caused by missing context. Think of it as the onboarding handbook for a new employee — it lets every "AI team member" understand the project rules from day one, without you having to explain everything from scratch each time.

Hands-On: Building and Deploying a Web App with Natural Language

The tutorial uses the construction of a web app called "Beauty Mirror" as its example — a selfie-upload tool that generates previews of different facial adjustments. It demonstrates the complete journey from idea to launch.

Image Input and Web Search

Codex supports pasting screenshots directly as input (use Ctrl+V — note that it's not Cmd+V). The author calls this a severely underrated feature. Whether you're referencing a site's design, copying a layout, or showing an error screen, attaching an image dramatically improves communication. "When I'm coding with AI, I attach at least one image to almost every other prompt."

Codex's built-in Web Search tool is another often-overlooked capability. It can browse the web for up-to-date information — like finding the latest framework documentation, or conducting customer research and competitive analysis. The author stresses you shouldn't rely solely on the model's training data; for anything time-sensitive, actively prompt it to search online.

Session Management Tips

• /resume: restores a previously saved conversation
• /new or /clear: starts a fresh session (no need to restart the terminal)
• /model: selects the AI model (always use the latest GPT 5.4 — avoid mini or older versions)
• /fast: enables fast mode, doubling inference speed (burns through credits faster, but recommended for Pro users to keep on)

Choosing Reasoning Effort

Codex offers four levels — low, medium, high, and extra high:

• Low: Never use this. Too little reasoning, poor performance.
• Medium: The default. Fine for everyday tasks and conserves credits.
• High: The author's go-to. Simple tasks finish in seconds; complex ones can run 2–4 minutes.
• Extra High: Reserved for the nastiest deep bugs or high-stakes large-scale refactors.

Integrating with an IDE: Using Cursor with Codex

For complex projects, the author strongly recommends using an IDE (Integrated Development Environment). The world's most popular is Microsoft's VS Code (184,000 stars on GitHub), and AI coding tools like Cursor, Windsurf, and AntiGravity are all forks of it.

The author personally recommends Cursor, calling it "the OpenRouter of IDEs" — vendor-agnostic, letting you freely use models from OpenAI, Gemini, xAI, Anthropic, and others.

Core Advantages of Using an IDE

1. Integrated terminal (Cmd/Ctrl+J): Launches directly in the correct folder — no repeated cd navigation
2. Visual code structure: Directly view files and edit system prompts
3. Git change visualization: Icons next to files clearly show what's been modified
4. Multi-agent parallelism: Run multiple Codex instances simultaneously

The author shares an efficient workflow: on the left, use the Codex extension as a "consultant" (medium setting, for Q&A and explanations); on the right, run CLI Codex on high or extra high for actual building and long-running tasks. Since Anthropic models excel at conversational explanation, you can also enable Opus 4.6 as a "consulting advisor" in Cursor's built-in agent, complementing GPT 5.4.

Git, GitHub, and One-Click Deployment

The author clears up a common misconception: Git and GitHub are not the same thing. Git is an open-source version control tool created by Linus Torvalds — you should use it in every project even if you never plan to upload anything. GitHub is the code hosting platform.

Key advice: commit every 10–15 minutes. This is the habit beginners most often overlook. And now you can simply tell Codex to run git status, analyze the changes, and auto-generate a commit message.

For deployment, the tutorial demonstrates Vercel. Since the example is a Next.js project and Vercel is the team behind Next.js, it's the most natural choice. The entire deployment flow: push to GitHub → Vercel imports the repo via GitHub auth → configure environment variables → click Deploy. You'll have a publicly accessible URL in about 20 seconds. The author notes that deployment has become truly effortless — every platform (Netlify, Railway, Render, Vercel) integrates deeply with GitHub.

Security reminder: Always set spending limits on API keys. Never share them. Treat them like passwords.

Git's core mechanism is "snapshot-based version management": every time you run git commit, Git creates a recoverable checkpoint of your project's current state (like saving your game). This is especially critical in AI-assisted coding — an agent might modify dozens of files in one go, and if a change introduces a hard-to-trace bug, git revert or git checkout lets you instantly return to any previous state without manually undoing each change.

The basic workflow requires just three commands: git init (initialize Git in the project folder), git add . (stage all changes), and git commit -m "description" (create a snapshot). The advice to commit every 10–15 minutes is essentially about providing a fine-grained safety net for the AI's "try → break → roll back" cycle. Modern tools like Cursor use color-coded icons to visually show which files the agent has modified, making the scope of changes immediately clear.

Permission Sandboxing: Why Power Users All Run YOLO Mode

Codex's security model operates on two layers.

Sandbox Mode (Technical Capability Layer)

• Workspace Write (default): Can only write within the project folder
• Read Only: Read-only, used in Plan mode
• Danger Full Access: Full access — can write anywhere and access the network

"Sandbox" is a security isolation mechanism borrowed from operating systems — it restricts a process's file system access, network permissions, and system calls to prevent code from causing damage outside a controlled boundary. Codex's Workspace Write mode implements the principle of least privilege: the agent can only read and write within the project directory, and cannot touch system files, other users' data, or make network requests. This is especially important for beginners — even if the agent generates an unexpected deletion command, the damage is strictly contained within the current project folder.

Full Access mode lifts these restrictions, allowing the agent to install global dependencies, access API endpoints, and read/write to any path — this is the underlying mechanism behind YOLO mode. Understanding the distinction between these two layers (sandbox capability layer + approval policy layer) helps you make rational decisions based on task risk, rather than blindly chasing "fastest" or "safest."

Approval Policy Layer

• Untrusted: Every action requires approval (safest, but least practical)
• On Request (default): Operates freely within the sandbox, asks only when crossing boundaries
• Never: Never asks
• Granular: Fine-grained control by category

The author reveals an "industry secret": everyone who's actually shipping results with AI agents is running YOLO mode. Launch it with codex --yolo — both permission layers are fully unlocked, the agent never asks for approval, and it runs autonomously. It's like putting a car into Sport+ mode. He acknowledges the real risk (files could be accidentally deleted), but that's exactly why you use Git — even if the agent makes a mess, you can roll back to a previous version. "Otherwise you're constantly waiting for approvals and can't possibly manage multiple agents."

There's also Plan mode (/plan), where Codex interviews you about your requirements and maps out the project — ideal for beginners or large-scale changes. In this mode, the sandbox is locked to read-only.

Codex App: The Future of Multi-Agent Orchestration

The most advanced — and most user-friendly — approach is the Codex App (available on macOS and Windows; Linux not yet supported). This is OpenAI's answer to Google's AntiGravity, and its core strength is managing multiple agents in parallel.

Core Features

• Parallel threads: Each agent gets its own Git worktree (essentially a cloned folder), so you can simultaneously work on the frontend and backend without conflicts
• Skills: Capabilities like ImageGen (generate image assets), Playwright (browser testing — highly recommended), PDF, and more, invoked with the $ symbol
• Automations: Like an enhanced cron job — the author says it's more reliable than OpenClaw, useful for daily doc updates, scraping new leads, etc.
• Sub-agents: Dispatch background workers running faster models (like GPT 5.4 mini) for simple tasks without blocking the main conversation

The author predicts that multi-agent orchestration will be the inevitable future of development — everyone will soon be directing dozens of agents simultaneously, and companies are racing to find the optimal interface and architecture.

Git Worktree is an advanced Git feature that allows the same repository to check out different branches into multiple directories simultaneously, each with a fully independent working area. Codex App leverages this to create isolated "parallel universes" for each concurrent agent: Agent A modifies frontend components in worktree-1, Agent B refactors the API in worktree-2 — both working from the same codebase, but with completely separate physical files that can't conflict. When finished, each worktree's changes are merged back into the main branch via standard Git merge/rebase.

Playwright is Microsoft's open-source browser automation testing framework, supporting Chromium, Firefox, and WebKit. In an AI coding workflow, having an agent call Playwright means it can actually open a browser, fill in forms, click buttons, and take screenshots — letting it self-verify that the code it generates actually works in practice. This creates an automated "generate → test → fix" loop that dramatically reduces the need for manual verification.

Conclusion: A Leap from Idea to Product

The value of this tutorial isn't just the tooling — it's the shift in mindset. The author repeatedly emphasizes: don't treat Codex as just a coding tool. It can help you do market research, write copy, analyze competitors, assist with deployment — covering nearly every aspect of building a startup or boosting personal productivity.

For anyone who wants to build products, mastering Codex means two things: first, you no longer have to pay for mediocre software that doesn't quite fit your needs; second, you can turn any idea into a real, publicly accessible application within hours. That is the core competitive advantage the AI coding era gives to everyone.