Codex Full Course 2026: How to Build Real Apps, Docs, and Automations with OpenAI’s New Desktop Agent

Codex is OpenAI’s new all-purpose desktop agent designed to do far more than answer chat prompts. It can create and edit files on your computer, browse the web, control other apps, build full iOS and web projects, generate decks and launch videos, and even run long tasks in parallel while you work on something else.

This guide walks through how Codex works in practice: from basic prompting and project setup to advanced skills, plugins, automations, and a full end-to-end build of an AI app called Chorus.

Getting Started with the Codex Desktop App

You install Codex like any other desktop app. Once downloaded and opened, the interface looks similar to ChatGPT: a main chat area and a left sidebar. The big difference is that Codex is wired directly into your file system and tools, so it behaves like a real working agent rather than a simple chatbot.

The sidebar is organized into a few key sections:

Projects: Each project is just a folder on your computer. Codex uses that folder as its workspace, creating and editing files inside it.

Chats: Within a project, you can have multiple chats running in parallel. Each chat can work on a different task but share the same project files.

Search: A global search lets you find any past chat by keyword and re-open its project, even if you removed it from the sidebar.

Plugins, Skills, Automations: These extend what Codex can do, from connecting to external tools like Google Calendar to running recurring workflows on a schedule.

Projects, Files, and the Preview Pane

The core mental model for Codex is simple: you give it a folder, and it works inside that folder like a very capable assistant.

For example, you might create a folder called “Codex desktop research” inside a broader “Codex projects” directory. When you start a new chat in that project and ask Codex to research the latest Codex features, it will:

1. Use built-in web browsing to gather information.

2. Summarize the results in the chat.

3. Create files (like spreadsheets or documents) in a subfolder called outputs inside that project.

When Codex generates a file, you see it listed at the bottom of the chat. Clicking Open loads it into a built-in preview pane: spreadsheets, docs, decks, and more all open directly inside Codex. You can full-screen the preview, hide the sidebar, and work as if you were in a dedicated editor.

The preview is live: you can keep chatting while a file is open and ask Codex to modify it. For instance, after generating a spreadsheet of new Codex features, you can say “remove the source column” and watch the sheet update instantly.

You can also @-mention files from the project in your prompts. Typing @ plus the file name lets Codex reference that file’s contents, which is powerful for research workflows and multi-file projects.

Models, Permissions, and Effort Level

Every chat in Codex has a few important settings at the top:

Model: For coding and complex workflows, the guide uses GPT 5.4.

Effort: An “extra high” effort level tells Codex to think deeper, use more tools, and spend more time on the task.

Permissions: This controls what the agent is allowed to do on your machine. Full access lets Codex create, edit, and delete files and use tools without asking every time. If you’re comfortable, this is the smoothest way to work.

Because Codex can literally control your computer (including mouse and keyboard via “computer use”), these settings matter. With full access enabled, you can hand off entire workflows and let the agent “cook” for long stretches.

Search, Organization, and Forking Chats

As you use Codex more, you’ll accumulate many projects and chats. The app gives you a few ways to stay organized:

Search: Pressing Command+G opens a global search where you can type any keyword (like “Karpathy” or “Codex outline”) and jump straight into that chat, even if its project is not pinned in the sidebar.

Re-attaching Projects: When you open a chat from search, Codex shows which project folder it belongs to. You can drag that project back into the sidebar to keep it handy.

Renaming and Pinning: Right-click a chat to rename it (e.g., “mobile app”, “web app”, “plan”) and pin important ones to the top.

Forking: You can fork a chat to branch off into a new line of work without losing history. For example, you can fork your “mobile app” chat into a new “investor deck” chat so the deck agent inherits all the context about your app and assets.

Skills vs Plugins: Extending What Codex Can Do

Codex supports two main extension concepts:

Plugins: Installable connectors that integrate external services (Google Calendar, Gmail, Figma, Remotion, etc.) directly into Codex. These are usually one-click installs from the Plugins panel.

Skills: Reusable workflows or “recipes” that sit on top of tools and APIs. A skill encapsulates how to do a specific kind of task (e.g., “mobile design”, “YouTube researcher”, “docs/word doc”).

In practice, the line between them is blurry. You often combine plugins and skills in a single workflow: a plugin provides raw capabilities (like accessing Google Calendar), and a skill defines how to use those capabilities to accomplish a repeatable job.

Using Plugins: Calendar, Email, Figma, Remotion

Google Calendar + Gmail: After installing the Google Calendar plugin and connecting your account, you can ask Codex to list all your events for the week. Then, with a Gmail plugin or email skill, you can have it send you a weekly recap email. From there, it’s one prompt to turn that into a recurring automation every Friday at 4 p.m.

Figma: The Figma plugin can inspect and modify existing Figma files. For example, you can create a blank Figma file called “Riley new design” and ask Codex to place a “hello world” text on the canvas. It will switch tools and edit the file for you. The integration is better for reading and transforming designs than for generating entire layouts from scratch.

Remotion: The Remotion plugin is used for motion graphics. Codex can generate a Remotion project, open a local timeline, and build multi-scene launch videos with animations, mockups, and music. You can then iterate by referencing specific timestamps or frame numbers.

Creating Your Own Skills

One of the most powerful parts of Codex is the ability to create custom skills around any API you like.

Example: building a YouTube Researcher skill.

1. Ask Codex to find APIs for pulling YouTube transcripts. It might suggest services like Super Data.

2. Sign up for the API, get your key, and copy it.

3. In a new Codex chat, write a prompt like: “Create a skill that, given a YouTube channel, fetches the latest 10 videos, pulls their transcripts via the Super Data API, and summarizes them in a document.” Include your API key at the end.

4. Use the built-in skill creator helper (by mentioning it in your prompt) so Codex scaffolds the skill correctly.

Once created, the “YouTube Researcher” skill appears in your Skills list. In a fresh chat, you can then say: “Use the YouTube Researcher skill to analyze my last 10 videos, summarize them in a doc, rank them by performance, and do a hook analysis.” Codex will:

1. Pull transcripts via the API.

2. Generate a structured report using the docs/word-doc skill.

3. Highlight which topics and hooks performed best.

You can then turn that workflow into a monthly automation that runs on the last day of each month and emails you the report.

Automations: Turning One-Off Tasks into Systems

Any multi-step workflow you run once in Codex can usually be turned into an automation with a single follow-up prompt.

For example:

Weekly calendar recap: After Codex pulls your week’s events and emails them to you, you can say “Make this a weekly automation every Friday at 4 p.m.” Codex creates an automation entry that you can see under the Automations tab, with status, next run time, and a manual “play” button for testing.

Monthly YouTube report: After using the YouTube Researcher skill and docs skill to generate a performance report, you can ask Codex to run the same process automatically at month-end.

Social media posting with Typefully: By connecting the Typefully API (v3) via a custom skill, Codex can draft and schedule X posts for you. Once the skill is set up and tested, you can create an automation like “Every morning, draft three posts for my account based on recent AI agent news and my latest content.”

All your automations are visible in one place, so you can edit, pause, or extend them as your workflows evolve.

Building Designs with Paper and Other Design Tools

While Codex can talk to Figma, the integration is currently better suited for inspection and code export than for full layout generation. For fast AI-driven UI design, the guide leans on a tool called Paper, which is built specifically to work with AI agents.

The workflow looks like this:

1. Install the Paper MCP (Model Context Protocol server) and expose it to Codex.

2. In a Codex chat, use a Paper skill to create a new board and ask for a landing page design for your product (e.g., a futuristic shoe brand called “NewShoe”).

3. Codex uses image generation to create product art, then uses the Paper integration to lay out a full landing page in the Paper canvas.

4. You can open the Paper board in your browser while keeping a mini Codex chat window floating on top, steering the design in real time.

Paper is optimized for agent-driven design: Codex can create multiple variations, adjust layouts, and iterate quickly. This pattern—external tools built to be controlled by AI agents—is likely to become a major trend.

From Idea to iOS App with Codex

The second half of the workflow shows how Codex can go beyond documents and designs to build real software. The example project is an app called Chorus, a mobile app that teaches people about AI agents, agent platforms, and reusable skills.

Step 1: Planning the Project

First, you create a new project folder (e.g., “my new business”) and ask Codex to generate a simple markdown plan based on a screenshot of your rough notes. The plan includes:

1. Design mobile app screens.

2. Build the iOS app in Swift.

3. Build a web landing page with a waitlist form.

4. Create an investor deck.

5. Create a launch video.

6. Set up X post automations.

This plan lives as a markdown file inside the project, and you can ask Codex to update it (e.g., marking tasks as “done” or “in progress”) as you go.

Step 2: Designing the Mobile App

A custom mobile design skill (ported from Anthropic’s Claude design tool) is used to generate a full set of iOS screens for Chorus: a Learn tab, a Platforms tab, a Skills tab, and a Saved tab. The design is intentionally minimal and “Apple-like” to keep implementation straightforward.

Codex outputs a prototype link so you can click through the screens, check the UX, and make adjustments before coding.

Step 3: Bootstrapping the Swift App

With Xcode and the iOS Simulator installed, you ask Codex to:

1. Create a new Swift project called “Chorus”.

2. Display a simple “Hello world, this is Chorus” screen.

3. Open the Xcode project when ready.

Codex sets up the project, and you run it in the simulator to confirm everything works. From there, you instruct Codex to integrate the previously designed screens into the app, wiring up the tab bar and basic navigation.

You can then refine UX details by describing them in natural language, such as:

– Pinning page titles to the top with a blur effect while content scrolls underneath.

– Adding a blurred bottom tab bar with subtle fade-out of list items as they approach the bar.

Each time Codex updates the code, you hit “Run” in Xcode to see the changes live.

Step 4: Adding a Real Database with Supabase

To make Chorus more than a static demo, the guide connects it to a real database using Supabase and Postgres.

The flow:

1. Ask Codex which database to use. It recommends Supabase with Postgres as a good match for structured content like platforms, skills, and categories.

2. Create a new Supabase project in the browser and enable its MCP integration for Codex.

3. Copy the connection prompt Supabase provides and paste it into Codex so the agent can connect via MCP.

4. Have Codex create tables for skill categories, platforms, skills, saved items, and user data.

5. Confirm the data is flowing by checking the Supabase table editor and verifying that the app reads from those tables.

Now, when you add or edit skills and platforms, they live in a proper database that can scale over time.

Step 5: Populating Content from YouTube and the Web

To fill the Learn tab with real lessons, Codex uses the YouTube Researcher skill again:

1. It finds past videos about agents.

2. Pulls transcripts and analyzes them.

3. Drafts multi-section lessons like “What is an agent?”, “Narrow beats general”, “Workspace, memory, skills, team, handoff”.

4. Writes them into the database so they appear in the app.

You can ask Codex to lengthen or refine lessons, and it will update the content in Supabase and the app UI.

Step 6: Authentication with Supabase

To make saved items and profiles user-specific, Chorus needs authentication. Codex guides you through:

1. Enabling email/password auth in Supabase.

2. Adding the necessary keys to the app.

3. Implementing sign-up and login flows in Swift.

4. Wiring the profile screen to show saved platforms, tracks, and skills for the logged-in user.

After a bit of configuration (including turning off email confirmation for quick testing), you can sign up in the app, save items, and see your stats reflected on the profile screen.

Building the Web Landing Page and Waitlist

Next, Codex builds a simple web landing page for Chorus that collects early-access signups.

The stack:

React: Used to build the front-end.

Tally: A form tool that handles submissions and storage.

The workflow:

1. Create a Tally form with fields like first name, last name, and email.

2. Grab the embed code from Tally.

3. Ask Codex to build a React app that embeds the Tally form and styles the page to match the iOS app (same font, minimal layout, clean white background).

4. Iterate on design. For more polished styling, the guide even calls in Claude Code from the terminal, pointing it at the same project folder and asking it to refine the layout.

Once the site looks good, Codex deploys it to Vercel and returns a public URL. You can test the form, then confirm submissions appear in Tally.

If you’re interested in similar AI-assisted web workflows, it’s worth checking out how Claude Code is used in this full Claude Code desktop workflow guide.

Creating an Investor Deck and Launch Video

With the product and landing page in place, Codex helps generate launch assets: an investor deck and a motion graphics launch video.

Investor Deck

Starting from the existing app and plan, Codex:

1. Generates a full slide deck using a built-in PowerPoint/slide skill.

2. Researches what investors are looking for in 2026 and structures the deck accordingly.

3. Exports the deck in a format that can be opened directly in Canva, where you can tweak visuals and animations.

To improve design quality, the guide again uses Claude Code from the terminal, asking it to reduce text, add visuals, and refine the narrative (e.g., “Curation is the wedge. Agents are the business. Most startups pray for distribution; we start with it.”).

Launch Video with Remotion

The Remotion plugin powers the launch video. Codex:

1. Creates a Remotion project and opens a local timeline in the Codex preview pane.

2. Builds scenes like:

– A title card: “Agents are taking over the world” with a toggle labeled “Learn”.

– A mouse cursor flipping the toggle on, triggering a phone mockup showing the Chorus Learn screen.

– A zoom into “learning about skills”, transitioning into a full-screen skills carousel.

– A sequence showing copying a skill, pasting it into Codex or Claude Code, and generating a new app mockup.

3. Adds background music by dragging an audio file into the project and asking Codex to place it at 50% volume across the timeline.

You can steer the video mid-run using Codex’s steering feature: type a prompt while it’s working, then click “Steer” to inject your instructions without waiting for the current tool call to finish. This is especially useful for fine-tuning animations and transitions.

Multitasking with Long-Running Agents

A key theme throughout the workflow is learning to multitask with AI agents. Modern agents can work for an hour or more on a single task—researching, coding, designing, or rendering—so you get the most value by:

1. Writing a clear, detailed prompt for one chat.

2. Hitting enter and trusting the agent to work.

3. Switching to another chat or project to start a different task while the first one runs.

4. Using notifications (like blue dots in the sidebar) to know when an agent has finished.

This “serial tasking” style—one strong prompt per task, then move on—is how you can have Codex simultaneously:

– Build a Swift app.

– Wire up a Supabase database.

– Design a landing page.

– Generate an investor deck.

– Render a launch video.

– Set up X posting automations.

If you’re new to agent-based coding and want a broader foundation before diving into Codex, you may also find this step-by-step Claude tutorial for beginners helpful, as it covers many of the same concepts from a different tool’s perspective.

Where Codex Fits in the 2026 AI Toolkit

Codex is positioned as a unified AI agent environment: chat, coding, browser, file system, plugins, and automations in one desktop app. Instead of juggling separate tools for research, coding, design, and operations, you can orchestrate everything from a single interface.

In practice, you’ll still mix in other tools—Paper for design, Supabase for data, Typefully for social, Canva for final deck polish, even Claude Code for certain design-heavy tasks. But Codex becomes the control center that:

– Knows your file system and projects.

– Manages long-running agents.

– Connects to external APIs and MCP servers.

– Turns ad-hoc workflows into reliable automations.

If you’re serious about building with AI in 2026—whether that’s apps, content, or internal tools—learning to think in terms of projects, skills, plugins, and automations inside Codex will put you ahead of most users who still treat AI as a simple chat box.