Courses Resource

Your first Codex project — a checklist

A list of steps to keep open while you build your first Codex project, from an empty folder to a published dashboard and a weekly automation running on its own. Come back to it to tick off each phase as you go.

This is the version you keep open while you work. You open it mid-task, take the next step, and tick the box. The order is deliberate: each phase builds on the one before it, so work through them in sequence, from setting up the project to an automation that runs without you.

The idea in one line: Codex is a collaborator you direct and correct, not a wish-granting machine. The first result is rarely perfect; the system gets better with every use.

0. Before you start — what you need

  • Sign up for or already have a ChatGPT account — that's all you need to begin. The free tier has limited access; for real work, get a paid plan so you don't hit the ceiling too fast.
  • Download the Codex app for your system. It also works inside a code editor and a terminal, but the app is enough to start.
  • Find the three dials at the top: model, its speed, and the "effort" level (low, medium, high, up to very high).
  • Set the effort level by this rule: medium for planning and simple tasks, high for a large project, and save the highest level for a hard bug nothing else solves. On a trivial task, the highest level tends to overthink.
  • Check the limits section in settings — it shows how much of your current session is left and when it resets. Each effort level costs a different number of tokens: low the least, the highest the most.

1. Set up the project and give it context

  • Click "new chat," add a project, and point it at the folder it should live in — an empty one is fine.
  • Ask Codex for an AGENTS.md file with context about you and the project's goal, for example: "Create an AGENTS.md file with context about me and the goal of this project." Codex will draft it itself.
  • Review AGENTS.md and check that it captured who you are, what the project's goal is, and where it's headed. This is the document Codex reads at the start of every new conversation.
  • Remember the rule: you record knowledge in files, not in your head and not in a single conversation. Without AGENTS.md, what you settled in one window disappears in the next.

2. Connect your data and set permissions

  • Check whether your data lives in a service with a ready-made plugin (connector) — Google Drive, Slack, SharePoint, GitHub. If it does, sign in the way you would for email and use it.
  • When there's no ready connector, ask the tool directly how else to connect: "Help me figure out how to connect to my data, and walk me through it step by step." Codex will guide you through setting up an access key (an API key).
  • Paste the key only into a file named .env (starting with a dot). The dot tells the tool never to share this file publicly. Never paste a key into a random document or send it anywhere.
  • Leave permissions on the default setting at first — Codex asks for your approval before each next step. Turn on full access (acting without asking) only once you understand what the tool does.
  • Ask it to test the connection: "Test whether this key works," and wait until Codex reports that it's pulling data.
  • If something failed along the way, ask it to record that knowledge in the project, "so this mistake never happens again." A recorded failure doesn't come back.

3. Produce your first result and turn it into a skill

  • Turn on plan mode — Codex doesn't execute anything, it just lays out a plan and asks questions. It only moves to action once you approve the plan.
  • Phrase your request as precisely as you can: say which metrics matter to you and what result you're after. A vague instruction gives a vague result — input quality decides output quality.
  • Review the plan Codex presents, and approve it only once it checks out. It's cheapest to correct mistakes at the conversation stage.
  • When the result is good, turn it into a skill — a saved recipe for how to do it well: "Turn what you just did into a skill, so you can repeat the same process every time."
  • Decide where to keep the skill: globally (works in every project) or locally (only in this one) — just ask for one or the other.
  • Treat every use as a chance to refine the recipe. A recipe can be improved, just like a cooking one.

4. Build a dashboard and publish it online

  • Point Codex at a finished spreadsheet (you can "tag" a specific file) and ask for a dashboard — a page with charts and takeaways.
  • Optionally ask it to use an image generator first and propose a look and a logo before it builds the rest.
  • Let the review loop run — Codex looks at its own page, catches flaws, and fixes them before handing back the result. You don't have to watch every pixel.
  • Remember the catch: the page you get only runs locally (the address starts with "localhost"). Send it to a friend and they'll see nothing. To open it on a phone or show it to anyone, you have to publish it.
  • Publish the project with two tools that are free to start with: GitHub (a repository — your files kept in the cloud) and Vercel (turns code into a live web address). Ask: "Help me connect this project to GitHub and publish it."
  • Take advantage of the two tools talking to each other: a change pushed to GitHub lands automatically in the Vercel version. Test changes locally — they only reach the public version once you approve them.

5. Set up automation and learn to check it

  • Open a new chat in the project and describe the automation — a scheduled task Codex runs on its own, for example: "Every Sunday at 5pm, run the skill, refresh the data, and push the changes to the site." The prompt can sound rough — Codex will ask for whatever details are missing.
  • Check the automation's settings and pick the right model and effort level. Left on default, the job can settle on a weaker model and then crawl or lose the thread.
  • Know that automation runs locally — turn off your computer or close the app, and it stops running. To have it work around the clock, you need to move it to the cloud (a separate, later step).
  • Don't expect the job to be perfect on the first run. When something jams, stop it, ask "what's going on?", fix the small thing yourself, and move on. That saves time and tokens.
  • Use browser use: ask Codex to open the finished page itself, click through it, try to "break" it, and report the flaws. This is useful for testing your own results and anywhere data has to be clicked through by hand.
  • Bake the check into the skill for good: "don't hand me a result until you've verified it yourself in the browser."

What to watch for

  • Don't delegate anything before you set up AGENTS.md. Without context in the file, the model's knowledge disappears between conversations.
  • The access key goes only into .env. It's a password to your data — nowhere else.
  • Full access is a risk when you don't understand the tool. Stories about agents that wiped a database or blasted out a flood of emails are usually the result of vague instructions and handing over full control too soon.
  • A vague instruction means a vague result. Most of the work happens in the precision of the request, not the strength of the model.
  • "localhost" is not a public address. The page only runs on your machine until you publish it.
  • Automation defaults to a weaker model and only works while the computer is on. Check both settings before you call a task done.

The whole project is just a plain folder of files. Thanks to a readable structure, any agentic tool can work in it — Codex, Claude Code, or others — because they all read the same directory. The first move is trivial: list the dull, repetitive things in your week, pick one, turn it into a skill. Then the next one.