Codex Beginner's Guide: Master the AI Programming Workbench Across 9 Core Modules

What Is Codex: From "Answering Questions" to "Completing Tasks"

In the age of AI-assisted programming, the tools that truly boost developer productivity are evolving from "Q&A assistants" into "intelligent agent workbenches." OpenAI's Codex is a prime example of this shift.

In one sentence: Codex is OpenAI's AI programming and agent workbench — and its greatest value lies in moving AI from "answering questions" to completing tasks.

Ordinary AI tools work like a Q&A assistant: you ask a question, it gives you an answer — write some copy, summarize some content. Codex, on the other hand, is more like an assistant that can step into your actual project directory, read files, edit them, run commands, and call plugins — ultimately producing results you can review and continue to refine. Think of it as an assistant that participates in your workflow, not just your conversations. The benefits extend beyond coding to everyday office work, studying, and writing.

This article is adapted from a 22-minute beginner tutorial by a Bilibili content creator. It systematically breaks down Codex's core capabilities and practical usage across 9 modules — suitable for complete beginners working their way up to advanced usage.

Installation & Interface: Three Zones Every Beginner Needs to Know

Installing Codex is just like any other app: visit the official website, click download, and choose the version for your operating system. When you first launch it, sign in with your ChatGPT account.

Once you're in, don't rush to click everything. As a beginner, just focus on three core areas:

• Left navigation panel: Access new chats, projects, the plugin marketplace, and automation entry points
• Center dialog area: Give Codex tasks, upload attachments, and select models and reasoning levels
• Right results panel (the "stage area"): View files, preview pages, and generated outputs

A great starter exercise: create a blank project, then type the prompt "Create a Markdown file with three sentences explaining the difference between Codex and a regular chat tool." You'll notice it doesn't just reply in the chat window — it actually creates a new file in your project directory. This is the foundation for everything else: Codex has a persistent workspace it can operate in.

Chat vs. Project Mode: Temporary Conversations vs. Persistent Work

Codex has two primary working modes. Understanding the difference is the first step to using this AI programming tool effectively.

Chat Mode: Quick, One-Off Questions

Chat works like a regular conversation — it's best for temporary, one-time questions. For example, type "Explain what MCP is" and it responds just like any other AI tool. If your task doesn't require persistent files or local output, Chat is all you need.

Project Mode: Formal Tasks That Produce Real Outputs

Project mode is designed for serious work — any task that involves creating files, reading materials, making iterative edits, running commands, writing code, or calling plugins. For example, "Move the current file to the current directory" — Codex will complete this operation in the real filesystem and show the result in the results panel.

Simple rule: Chat is for temporary conversations; Project is for work that produces persistent results. Building a webpage, editing a presentation, creating a spreadsheet, writing code — all of these should use Project mode. In either mode, you can right-click to rename sessions and view the actual working directory.

Why does the persistent workspace matter? This concept is key to understanding what sets Codex apart from ordinary AI chat tools. Regular AI conversations are stateless — once the session ends, nothing is retained. Codex's Project mode maintains a real file system sandbox: all generated files, installed dependencies, and executed scripts are saved in the project directory and fully preserved the next time you open it. It's like having a cloud-hosted development machine that's always on, rather than starting from scratch every time. This is why tasks that require multiple iterations — like "build a webpage" or "write code" — must use Project mode. Only a persistent workspace can support a full workflow like "files generated last session → edits this session → deploy and test next session."

Models, Reasoning Levels & Permissions: Stick with Defaults as a Beginner

These three settings are easy to overlook but critically important when using Codex.

Choosing the Right Model

The model is Codex's "brain." You'll find multiple versions in the bottom-right corner of the input area, each with different trade-offs in speed, reasoning power, cost, and suitability for different tasks. Beginners don't need to overthink this — the default model handles the vast majority of tasks just fine.

Adjusting Reasoning Level

Reasoning levels range from low to medium, high, and ultra-high. Higher levels take more time but are better suited for complex tasks like planning large projects or analyzing extensive files. There's also a speed option: Fast mode is 1.5× faster than default, but consumes twice the tokens.

Being Careful with Permissions

Permissions are the setting that deserves the most caution. When executing tasks, Codex may read files, write files, run commands, access the internet, install dependencies, or even control your browser and computer — all of which require authorization.

Important reminder: higher permissions aren't always better. More permissions give Codex more freedom, but you need to understand what it's actually doing. Beginners should stick with "default permissions" or "auto-review permissions" and never mindlessly click through permission prompts — always check what directory it's accessing and what command it's about to run.

In a real test, when instructed to create a TXT file in the Downloads directory (outside the current project directory), Codex prompts for authorization — demonstrating that by default it can only access the current directory, and out-of-scope operations require explicit confirmation. With "auto-review" enabled, Codex automatically evaluates the risk level of each operation: low-risk actions are confirmed automatically, while high-risk ones require your approval.

Plugin Marketplace: Equip Codex with Professional Tools

Codex's Plugins work like a toolbox — once installed, Codex can handle more specialized tasks.

Take the "Office Suite" as an example:

• Documents plugin: Create and edit Word documents
• Spreadsheets plugin: Work with Excel spreadsheets
• Presentations plugin: Generate and modify PowerPoint presentations

Hands-On Demo

Prepare an "AI Tools Study Guide" document and enter this prompt: "Help me organize this document into three outputs: a Word study notes file, an Excel tool comparison table, and a PowerPoint course outline." Codex will automatically invoke the appropriate plugins and generate all three file formats in one go.

Beyond letting Codex decide intelligently, you can also call plugins explicitly — click the plus button, select a plugin, then provide your content, and Codex will use the specified plugin to generate the output.

Plan Mode: Plan Before You Execute on Complex Tasks

For complex tasks, jumping straight to execution often produces disappointing results — the tech stack, code structure, and visual style may all diverge from your expectations. That's when Plan mode becomes essential.

Plan mode follows a four-step process: Understand → Break Down → Confirm → Execute. Its core value isn't "going slower" — it's having Codex decompose the task first, explain what it plans to do, and only proceed after you confirm.

How to Enable Plan Mode

Click the plus button and select "Plan Mode." Using "Build a personal blog" as an example: Codex will first pop up a dialog asking you to choose the blog's focus, implementation approach, and visual style, then present a complete plan. Once you're satisfied, click "Implement This Plan" and it will generate the static blog pages.

Plan mode is ideal when you have clear expectations for the outcome and don't want the AI freelancing. It plans before it acts — it won't dive into modifying code right away.

Skills & MCP: Teach It How to Work, Connect It to External Services

These are two advanced capabilities that are easy to confuse but serve complementary purposes.

Skills: Codex's Operating Manual

A Skill is like an instruction manual that tells Codex what steps to follow for a certain type of task, what rules to observe, and what resources to use. For example, there are image Skills for generating images, document Skills for handling files, and testing Skills for verifying webpages. GitHub hosts a large library of ready-made Skills covering development, product management, writing, data analysis, and more.

Installation options include:

• One-click install for officially recommended Skills
• Copy a third-party Skill command from the terminal and press Enter
• Click "Skill Create" to build your own, by describing your workflow

MCP: The Standard Interface for Connecting External Tools

MCP is the standard interface for connecting external tools and services, enabling Codex to interface with browser automation, databases, design tools, project management platforms, and more.

Configuration is straightforward: run codex mcp add followed by the MCP address to install it, or even simpler — just type "Help me install the Figma MCP" in the input box, and it handles the rest automatically.

In a live demo, after installing the Figma MCP, a prompt instructed Codex to read a Figma design file — and it successfully retrieved the design and identified the corresponding heading elements. That's the power of connecting Codex to external services.

One-line distinction: Skills teach Codex how to do something; MCP lets Codex connect to external systems.

A note on MCP MCP (Model Context Protocol) is an open standard proposed and championed by Anthropic in late 2024, aimed at establishing a unified communication specification between AI models and external tools. Before MCP, every AI application that wanted to connect to a database, design tool, or browser had to build a custom integration layer — expensive and hard to reuse. MCP defines a standardized format for "tool description + invocation + response," so any external service that follows the protocol can be called directly by a compatible AI — similar to how USB unified peripheral connectivity. Today, leading AI programming tools (including Claude, Cursor, and Codex) all support the MCP ecosystem, and platforms like GitHub, Figma, Notion, and Slack have released official MCP servers. This means Codex can theoretically connect to hundreds of external systems via MCP without waiting for OpenAI to build individual integrations.

Automation & Computer Use: Let AI Handle Repetitive Work

Automations: Schedule Recurring Tasks

Automation addresses the pain point of tasks you need to run repeatedly — not just once. Think daily data briefings or fetching the latest AI news each morning. At its core, it lets Codex automatically execute tasks at a specified time or interval.

In the demo, entering "Every evening at 8 PM, go to social media platforms, gather news and updates about Codex, and generate a briefing" caused Codex to automatically set up a scheduled task. In the automation panel, you can view task status (active/paused), the next run time, the runtime environment, and the reasoning model, and you can manually run, pause, or delete tasks. That said, beginners are better off not diving into automation right away.

Computer Use: Direct Control of Your Computer

Computer Use is one of Codex's "superpowers" — when authorized, it can operate your computer: click within applications, type text, take screenshots, and read UI information. In a demo, Computer Use was used to "open the Chess app on the computer and play a game against the AI" — and Codex successfully controlled the entire match.

But this capability comes with extremely elevated permissions. Beginners should use it with great caution.

How Computer Use works under the hood Computer Use combines vision and action: the AI captures screenshots to "see" the current screen state, then generates low-level instructions — mouse click coordinates, keyboard input sequences — to interact with the interface. This is fundamentally different from traditional RPA tools (like UiPath or AutoHotkey), which rely on pre-recorded fixed action paths or UI element IDs and break whenever the interface changes. Vision-based Computer Use understands interface semantics and can adapt its strategy when encountering popups or layout changes. This flexibility makes it ideal for tasks with unpredictable interfaces, but it also introduces security risks: the AI's judgment can be wrong, and without confirmation it may execute destructive actions (like deleting files or submitting forms). Before using it in any real work environment, it's strongly recommended to test thoroughly in an isolated test account or virtual machine.

Closing Thoughts: The Key to Using Codex Well Is Clarity

The real secret to getting the most out of Codex isn't memorizing every button — it's learning to describe your tasks clearly: what you want it to do, what reference materials to use, and how to verify the result.

Once you internalize that approach, Codex can save you enormous amounts of repetitive effort across writing, office work, studying, and programming. It represents the inevitable evolution of AI tools from "Q&A" to "execution" — and understanding and harnessing that shift is the new challenge for every developer and knowledge worker.