Learn Codex in 30 Minutes: Files, Skills, Plugins and Automations

By Synthex

Codex is easier to understand once you stop thinking of it as another chat box.

The useful way to think about it is this: Codex is an agent that can work inside a real environment. It can read files, edit files, run commands, use connected tools, test web pages, generate assets, organize information, remember useful context, and schedule recurring work.

That sounds like a lot because it is a lot.

So I would not start by trying every feature. I would start with the Codex desktop app, a small local folder, and one simple task. Once that feels normal, skills, plugins, browser use, computer use, and automations become much easier to understand.

Codex features, limits, and access can change, so treat setup screens and plan details as the source of truth when you try it.

What you'll learn

• What Codex is, in plain language.
• How to get started with the Codex desktop app.
• When the IDE extension, CLI, or web version makes sense later.
• How Codex works with local files and project folders.
• How Codex can help with non-coding work like spreadsheets, documents, research, assets, and website checks.
• What AGENTS.md, memories, and Chronicle are for.
• The difference between skills and plugins.
• How image generation, browser use, computer use, and automations fit into the workflow.
• What to do first if you have never used Codex before.

What this is really about

Officially, Codex is OpenAI's coding agent.

That wording is accurate, but it can make beginners assume Codex is only for programmers. It is not. Coding is a big part of what Codex does, but the desktop app can also help with normal computer work that involves files, tools, structure, and review.

For example, Codex can help you:

• Turn receipts into a spreadsheet.
• Summarize PDFs into a short client brief.
• Organize a messy folder into drafts, assets, exports, and notes.
• Create a Word-style report from scattered notes.
• Make a simple dashboard from a CSV.
• Draft a landing page from a product document.
• Generate image concepts or placeholder assets.
• Check whether a web page breaks on mobile.
• Create a weekly recurring report from connected tools.

The difference from normal chat is the working environment.

ChatGPT is usually where you ask questions. Codex is where you ask an agent to work inside a real project, folder, browser, tool, or computer workflow.

That environment might be:

• A folder on your computer.
• A set of PDFs, screenshots, CSVs, notes, or receipts.
• A Git repository.
• A project in your editor.
• A cloud environment connected to GitHub.
• A thread that uses plugins, skills, files, and browser tools.

Codex is strongest when the task has context and a result you can inspect.

It is still not a replacement for judgment. You should review what it creates, especially when it edits files, connects to private tools, or runs unattended work. But it can turn a vague pile of files into something much more workable.

How to get Codex

OpenAI's current Help Center says Codex is included across Free, Go, Plus, Pro, Business, Edu, and Enterprise plans, with usage limits and credit options varying by plan.

For most people, start with the Codex desktop app.

The app gives you the clearest version of the workflow: choose a local project folder, chat with Codex, inspect created files, use plugins, test pages in the browser, and review what changed. The IDE extension, CLI, and web/cloud version are useful, but I would treat them as later options unless you already know you need them.

A "surface" just means the place where you use Codex.

Option 1: Start with the Codex app

This is the easiest path for most non-technical or semi-technical users.

1. Go to the official Codex page or Codex quickstart.
2. Download the Codex app for macOS or Windows.
3. Open the app.
4. Sign in with your ChatGPT account, or use an OpenAI API key if that is your setup.
5. Choose a project folder.
6. Keep Local selected if you want Codex to work on files on your machine.
7. Send a small first message.

The local project folder is important. It gives Codex a clear place to look and a clear place to create files.

Files you add to the project and files Codex creates for that project live on your computer, inside the folder you selected or inside a subfolder it creates. You can inspect them normally in Finder or File Explorer.

Good first prompt:

Tell me what is inside this project folder.
Do not edit anything yet.
Summarize the important files and suggest one safe first task.

That prompt is intentionally quiet. It lets you see what Codex can read before you ask it to change anything.

For a non-coding first task, try:

Look at the PDFs, images, and notes in this folder.
Create a short Markdown brief called project-brief.md.
Include a summary, open questions, useful next actions, and any files that look important.
Do not delete or move anything.

Option 2: Use the IDE extension

Use the IDE extension if you want Codex beside your editor.

The official quickstart currently links downloads for:

• Visual Studio Code.
• Cursor.
• Windsurf.
• Visual Studio Code Insiders.

After installing:

1. Open your editor.
2. Open the Codex panel.
3. Sign in.
4. Open a project.
5. Ask Codex to inspect a specific file or fix a narrow issue.

The IDE extension is useful because your open files and selected text can become useful context. It makes the most sense if you already spend a lot of time in an editor.

Option 3: Use the CLI

Use the CLI if you prefer the terminal.

On macOS or Linux, the official standalone installer is:

curl -fsSL https://chatgpt.com/codex/install.sh | sh

Then run:

codex

The first run prompts you to sign in with your ChatGPT account or an API key.

For Windows, OpenAI's docs describe native Windows app, CLI, and IDE extension options. Windows can also run Codex through WSL2, depending on how you prefer to work. If you are new, the desktop app is usually less confusing than starting with WSL.

Option 4: Use Codex web / cloud

Use Codex web when you want Codex to work in a cloud environment.

The important setup step is GitHub connection. Codex cloud needs repository access so it can clone the repo, run setup, make changes, and create a pull request.

Use this for:

• Work you want to delegate in the background.
• Tasks that should run away from your local machine.
• Pull-request workflows.
• Remote review and follow-up.

I would not start here if GitHub basics already feel unclear. Start locally first, then move to cloud once the workflow makes sense.

Capability 1: Local files and project folders

The first thing to understand is that the Codex app works best when it has a clear working folder.

A project is a folder Codex can use as the working location for a task. If you choose a folder that contains a website, app, spreadsheet, document set, or repository, Codex can inspect files inside that folder and create outputs there.

For beginners, this answers a very normal question:

Where did the files go?

If Codex creates a spreadsheet, a Word document, a web page, or generated assets while working inside a local project folder, expect those files to appear in that project folder or a subfolder it creates.

Start with a contained folder. Do not point Codex at your whole home directory.

A safe first folder might be:

Documents/codex-test-project

Put a few sample files in it, then ask:

Look at the files in this folder.
Create a short summary of what each file appears to contain.
Do not edit or delete anything.

After that, try a small output task:

Create a Markdown report called summary.md that explains the files in this folder.
Keep it short and include a section called "Next useful task".

This teaches you the basic loop:

1. Codex reads the folder.
2. Codex explains what it sees.
3. Codex creates a file.
4. You inspect the file.
5. You give follow-up instructions.

That loop is the foundation for everything else.

Once that feels clear, try different kinds of work:

Capability 2: Durable guidance, AGENTS.md, and memories

Current Codex docs separate durable guidance and memory into a few different pieces.

The useful distinction is:

• AGENTS.md is durable guidance you or your team control.
• Memories are optional local recall that Codex can generate from past work.
• Chronicle is a separate opt-in research preview that can use recent screen context to help build memory.

These sound similar, but they are not the same thing.

AGENTS.md

An AGENTS.md file is like a README for agents.

It tells Codex how to work in a repo or folder. Codex can load it automatically as context. Use it for instructions that should reliably apply every time Codex works in that place.

Good AGENTS.md content includes:

• Project layout.
• Important folders.
• Build, test, and lint commands.
• Coding conventions.
• Review expectations.
• Things Codex should not change.
• What "done" means.

Example:

# AGENTS.md

## Project

This folder contains my personal writing project.

## How to work

- Ask before deleting, renaming, or moving files.
- Keep drafts in the `drafts/` folder.
- Keep finished exports in the `exports/` folder.
- Preserve my writing voice: clear, calm, and practical.

## Limits

- Do not publish, email, or upload anything unless I explicitly ask.
- Do not rewrite the whole project when I ask for a small edit.

## Done

Before calling the task complete, summarize what changed and what still needs review.

In the CLI, /init can scaffold a starter AGENTS.md. Treat that as a starting point, then edit it down.

A short accurate file is better than a long vague one.

Memories

Memories are different.

OpenAI's current Codex docs say memories are off by default and are not available in the European Economic Area, the United Kingdom, or Switzerland at launch. When enabled, memories can help Codex carry useful context from prior threads into future work.

Good memory candidates are stable preferences:

• "I usually prefer Playwright verification for frontend changes."
• "This project is a weekly newsletter."
• "Do not suggest broad rewrites before reading the code."

Memories are stored under the Codex home directory, usually ~/.codex/memories/.

Treat those files as generated state. You can inspect them, but I would not use hand-editing as the main control surface. If something should always apply to a repo, put it in AGENTS.md or checked-in documentation.

Chronicle

Chronicle is more sensitive.

OpenAI's current docs describe Chronicle as an opt-in research preview that augments Codex memories with recent screen context. As of today, the docs say it is only available for ChatGPT Pro subscribers on macOS, and not available in the EU, UK, or Switzerland.

Use Chronicle only if you understand the privacy tradeoff.

It can help Codex infer what you were recently working on, but it also means screen context may be used to build memory. OpenAI's docs call out risks such as prompt injection and local memory storage concerns. For normal beginners, AGENTS.md plus explicit prompts are a cleaner starting point.

Capability 3: Plugins

A plugin is an installable bundle that extends what Codex can do.

OpenAI's plugin docs say plugins can bundle:

• Skills, which are reusable instructions for specific work.
• Apps, which connect Codex to services like GitHub, Slack, Google Drive, or Gmail.
• MCP servers, which provide tools or shared information from external systems.

In plain language, a plugin is something you install so Codex can work with a tool, app, or capability outside the current folder.

Examples:

The important word is permission.

If a plugin can read Gmail, Slack, Drive, or GitHub, it is dealing with real private data. Add plugins only when they enable a real workflow. You do not need to connect every account just because it is available.

Good beginner workflow:

1. Start with no plugins.
2. Learn local project work first.
3. Add one plugin for one clear task.
4. Test the task with harmless data.
5. Review what Codex read and what it produced.
6. Remove or disable access you no longer need.

Example prompt after connecting a mail plugin:

Use the Gmail plugin to find emails from the last 14 days that appear to be brand partnership inquiries.
Do not send any emails.
Create a table with sender, company, offer summary, requested deliverable, deadline, and follow-up recommendation.

The constraint matters: Do not send any emails.

That keeps the first run controlled.

Capability 4: Skills

A skill is a reusable workflow.

A skill is a package of instructions, resources, and optional scripts that helps Codex follow a workflow reliably. It is usually a folder with a SKILL.md file.

Plain version:

A skill tells Codex, "When doing this kind of task, follow these steps."

Use a skill when you repeat the same process and want Codex to stop guessing from scratch.

Examples:

• A brand-deal research workflow.
• A thumbnail prompt workflow.
• A code-review workflow.
• A spreadsheet-cleaning workflow.
• A launch checklist workflow.
• A frontend QA workflow.

Skill vs plugin

This is the part that usually confuses people.

The simple version:

• Use a skill to standardize how Codex should do work.
• Use a plugin to install a reusable capability or connect Codex to tools.

How to create a skill

The easiest way is to do the task manually with Codex first.

1. Ask Codex to complete the task once.
2. Review the output.
3. Correct it.
4. Repeat until the result is good.
5. Then ask Codex to turn that successful workflow into a skill.

Example:

This brand-deal analysis output is now correct.
Turn this workflow into a Codex skill called brand-deal-researcher.
The skill should explain what inputs it needs, what plugins it may use, what table columns to create, and what safety limits to follow.
Validate the skill after creating it.

This usually works better than starting with "create me a skill" before you know what the process should be.

Capability 5: Image generation

Codex can generate or edit images directly in a thread.

OpenAI's current Codex app feature docs say image generation can be used for UI assets, banners, backgrounds, illustrations, sprite sheets, placeholders, and similar assets created alongside code. You can ask in natural language or invoke the image generation skill with $imagegen.

Use it for:

• Blog thumbnails.
• Placeholder product images.
• UI backgrounds.
• Concept art.
• Presentation visuals.
• Game assets.
• Lightweight illustrations.

A good image prompt should define:

• Aspect ratio.
• Subject.
• Style.
• Lighting.
• Composition.
• What to avoid.
• Whether text/logos should appear.

Example:

$imagegen

Create a 16:9 blog thumbnail about Codex skills and plugins.
Show a tidy desk with a laptop, a small stack of labeled workflow cards, and soft side lighting.
Keep it polished and realistic. No readable text, no logos, no fake UI, no cartoon robot.

For larger production batches, use consistent style notes and save the prompts. Otherwise, every image can drift into a different visual language.

Capability 6: Browser use

Browser use lets Codex operate the in-app browser.

Use it when you want Codex to verify a web page visually or interactively. This is useful because many page problems only become obvious after the page renders.

Good uses:

• Open http://localhost:3000.
• Click through navigation.
• Check whether buttons work.
• Test a mobile viewport.
• Take screenshots.
• Verify a layout fix.
• Run read-only page inspection JavaScript.

Example:

Use the browser to open http://localhost:3000/blog.
Check the page at desktop and mobile widths.
Look for horizontal overflow, unreadable text, broken cards, or console errors.
If you find a problem, fix only the smallest relevant code path.

Important limitation: OpenAI's docs say the in-app browser does not support authentication flows, signed-in pages, your regular browser profile, cookies, extensions, or existing tabs.

If the task needs your signed-in Chrome session, use the relevant Chrome extension or another supported browser/computer-use path instead of assuming the in-app browser can access your logged-in state.

Capability 7: Computer use

Computer Use is different from browser use.

Browser use operates Codex's in-app browser. Computer Use lets Codex operate graphical desktop apps on macOS or Windows, after setup and permission.

Use Computer Use when the task depends on a real GUI:

• Testing a desktop app.
• Reproducing a UI-only bug.
• Clicking through app settings.
• Moving assets into a design tool.
• Checking a flow that cannot be verified from files or command output.

Current official limitations matter here.

OpenAI's docs say Computer Use is available in the Codex app on macOS and Windows, except in the European Economic Area, the United Kingdom, and Switzerland at launch. It requires installing the Computer Use plugin. On macOS, it also requires Screen Recording and Accessibility permissions.

For Windows, the docs say Computer Use runs on the active desktop. That means Codex can move the pointer, type, and take over the foreground while it works.

Beginner rule:

Use Computer Use for narrow tasks where visual interaction is actually necessary.

If a structured plugin, file-based workflow, command, or browser check can do the job, start there.

Capability 8: Automations

Automations let Codex run recurring tasks.

Use them when a workflow is stable enough to repeat:

• Every Friday, summarize new brand-deal emails into a spreadsheet.
• Every morning, check a repo for failing tests.
• Every week, review docs against recent code changes.
• Every day, look for unread support issues and group them by theme.

OpenAI's current docs say project-scoped automations need the machine running the local Codex app to be powered on, Codex running, and the selected project available on disk when the automation is scheduled to run.

That detail is easy to miss. A local automation is not magic cloud infrastructure. If the computer is off or the folder is unavailable, the run may not happen as expected.

Good automation pattern

Before scheduling anything, run the workflow manually.

1. Run the task once in a normal thread.
2. Review the output.
3. Turn the repeatable part into a skill if needed.
4. Run the skill manually.
5. Only then schedule the automation.

Example automation prompt:

Every Friday at 9:00 AM, run $brand-deal-researcher.
Use the Gmail plugin to find brand partnership inquiries from the last 7 days.
Update the existing brand_deals.xlsx file in this project.
Do not send replies.
If anything looks uncertain, add it to a "Needs review" sheet instead of deciding automatically.

The useful part is the boundary:

• What to read.
• What to update.
• What not to do.
• What to mark for review.

A complete beginner path

If you have never used Codex before, do not start with every feature.

Use this order.

Step 1: Install Codex

Start with the Codex app. It is the easiest path for most people because it puts the project folder, chat, file outputs, plugins, browser use, and review flow in one place.

Use the CLI, IDE extension, or web/cloud version later if you already know why you need them.

Step 2: Create a small project folder

Make a folder with harmless sample files.

Example:

Documents/codex-test-project

Add a few PDFs, notes, CSVs, screenshots, or Markdown files.

Step 3: Ask Codex to inspect, not edit

Inspect this project folder.
Explain what files are here and what each one is probably for.
Do not edit, delete, move, or create files yet.

This builds trust in what Codex can see.

Step 4: Ask for one small output

Create a file called project-summary.md.
Summarize the files in this folder.
Include a short table with file name, likely purpose, and suggested next action.

Now you have a real artifact to inspect.

Step 5: Add AGENTS.md

Once you know what you want Codex to remember for the folder, create AGENTS.md.

Create an AGENTS.md file for this project.
Keep it short.
Include folder purpose, allowed actions, verification expectations, and things Codex should not do.

Read the file. Edit it. Keep only rules that are actually useful.

Step 6: Add one plugin only when needed

If your next task needs Gmail, Slack, Drive, GitHub, Browser, or Computer Use, install only that plugin.

Then run a read-only task first.

Step 7: Turn repeated work into a skill

After Codex completes a useful workflow two or three times, convert it into a skill.

This workflow is now useful.
Turn it into a reusable skill.
Include the exact inputs it needs, the steps it should follow, the output format, and the safety constraints.

Step 8: Automate only after the skill works

Schedule the task only when the manual version is reliable.

This reduces surprise. Automations are useful, but unattended work needs clearer boundaries than normal chat.

Common misunderstandings

"Codex is just ChatGPT with files"

It is more than that.

Codex can operate inside a project, edit files, run checks, use skills, call tools, open browser previews, use plugins, and manage reviewable work. That makes it closer to an agent workspace than a normal chat window.

"Codex is only useful if I code"

No.

Coding is one of its strongest areas, but the app can also help with file-heavy work: research summaries, spreadsheets, reports, folder cleanup, website checks, image prompts, presentations, and repeatable admin workflows.

"AGENTS.md is the same as memory"

No.

AGENTS.md is durable guidance you control. Memories are optional generated recall. If a rule matters, put it in AGENTS.md or project documentation.

"Plugins and skills are the same thing"

No.

A skill is a workflow instruction package. A plugin is an installable bundle that can include skills, app integrations, and MCP servers.

"Computer Use is the best way to control everything"

No.

Computer Use is for GUI tasks where file access, commands, browser use, or structured plugins are not enough. It has stronger privacy and state-change implications, so use it narrowly.

"Automation means Codex can run safely without review"

No.

Automation means a task can run on a schedule. You still need constraints, sandbox settings, review steps, and clear instructions for uncertain cases.

"If a feature exists, everyone has it"

No.

Codex features can depend on plan, platform, region, workspace policy, app version, and whether a feature is in preview. Check your current settings and setup screens before assuming availability.

What to do first

Start with this sequence:

1. Install the Codex app.
2. Sign in with your ChatGPT account.
3. Create a small test project folder.
4. Ask Codex to inspect the folder without editing.
5. Ask Codex to create one simple output file.
6. Create a short AGENTS.md.
7. Add one plugin only when a task requires it.
8. Turn one repeated workflow into a skill.
9. Schedule an automation only after the workflow works manually.
10. Keep reviewing outputs, diffs, permissions, and generated files.

That order teaches Codex in a way that feels less abstract: context first, files second, tools third, automation last.

Final takeaway

Codex becomes much easier to understand when you start with the app and one local folder.

Do not try to learn the whole system in one sitting. Ask Codex to inspect files. Ask it to create one small output. Add durable guidance with AGENTS.md. Use one plugin when there is a real reason. Turn repeated work into a skill. Automate only after the manual workflow behaves the way you expect.

That is enough to make Codex useful without turning it into another confusing AI dashboard.

Further reading

• Codex overview: https://developers.openai.com/codex (opens in new tab)
• Codex quickstart: https://developers.openai.com/codex/quickstart (opens in new tab)
• Using Codex with your ChatGPT plan: https://help.openai.com/en/articles/11369540-using-codex-with-your-chatgpt-plan (opens in new tab)
• Codex skills: https://developers.openai.com/codex/skills (opens in new tab)
• Codex plugins: https://developers.openai.com/codex/plugins (opens in new tab)
• Codex memories: https://developers.openai.com/codex/memories (opens in new tab)
• Chronicle: https://developers.openai.com/codex/memories/chronicle (opens in new tab)
• In-app browser and browser use: https://developers.openai.com/codex/app/browser (opens in new tab)
• Computer Use: https://developers.openai.com/codex/app/computer-use (opens in new tab)
• Automations: https://developers.openai.com/codex/app/automations (opens in new tab)