The Only Codex Course You Need in 2026 (4.5 Hours)

1. What you'll build, and the interface (0:00-24:00)

Nick Saraev runs LeftClick, an AI-automation agency he says did ~$500k in revenue last month, and teaches through Maker School. The promise: no programming background needed, he walks every button. The course automates real business functions (sales, marketing, operations, an after-hours voice agent), then covers maintenance and advanced tips.

The whole course is one course outline he checks off as he goes:

CaptionThe 9-part outline. Install Codex, the business functions + framework, the four automation levels, then Sales, Marketing, Operations, the voice agent, maintenance, and advanced tips. 33:50

Install is ordinaryopenai.com/codex, drag to Applications (Mac) or the normal Windows flow, sign into ChatGPT (phone verification because of spam), pick a workspace. Codex can import prior work from Claude Code. Then the interface, which Nick compares to an airplane cockpit you only need 30-40% of:

CaptionThe Codex home. Left rail: New chat, Pull requests, Scheduled, Plugins. A "Getting started" checklist (Import from Claude, Create a project, Set up a daily update, Triage GitHub PRs). Model picker bottom-right shows "5.6 Terra Medium". 4:45

CaptionThe right side panel spawns a Codex-managed browser and a terminal. The browser matters because Codex builds web apps and needs to see and test them. 5:30

A "project" is just a folder on your computer. The chat UX is familiar, plus you can fork a conversation from any point:

Caption"Continue in a new chat" - use this workspace, or a new worktree. Forking lets you branch a conversation. 9:35

First real build"create a one-page landing page about Nick Saraev." Nick's whole mental model is input -> output: you provide the input, the model does the work, the middle (all the commands it runs) you can mostly ignore. Codex writes files and shows a diff:

CaptionBuilt index.html + styles.css. The diff panel reads "Edited 2 files +116", index.html +90, styles.css +26. Green +N means lines added that turn. 13:30

CaptionThe rendered page: "Build things that matter." A real, editorial one-page site from a single voice prompt. 14:22

Asking for a dark theme shows how edits work (it modifies, not recreates): the diff becomes +7/-7 (swap the light-mode lines for dark). This frame also shows the approval control:

Caption"Edited styles.css +7 -7". Bottom shows "Full access" (red warning). Approval modes: ask every time, approve individually, or full access. Nick is team full access ("out of ~100k queries, one bad delete"). 18:10

Two more interface facts do most of the work. The model picker and effort:

CaptionModels 5.6 Terra / 5.6 Luna / 5.5 / 5.4 Mini; Effort Medium (also high/ultra/extra-high). Higher effort = more time and more usage burned. Nick defaults to Medium and dictates via Whisper. 19:15

Pull requests (a dev feature, occasionally useful in business):

CaptionA pull request is a last line of defense before a change lands; you can auto-merge. 22:00

Scheduled tasks are the important one, and where autonomy starts:

CaptionScheduled = tasks that run without you. Defaults: Daily brief (weekdays 8am), Weekly review (Fridays 4pm), Follow-up monitor (weekdays 9am). You define your own intervals. 22:38

Plugins connect external tools (computer use, Chrome control, Notion, ClickUp, Dropbox, Asana, Linear); you hand Codex OAuth keys and it acts on your behalf.

2. RACE: where automation pays (24:00-31:00)

RACE is Nick's framework for choosing what to automate, from 10 years of running businesses:

CaptionReach (eyeballs/ads/copy, +50%), Acquisition (speed-to-lead/nurturing/follow-up, +20%), Conversion (proposal-gen/onboarding/follow-up, +10%), Expansion (follow-up/proposal/upsell/strategy-product, +10%). Improving the FRONT of the business (sales/marketing) beats optimizing back-office. 30:56

The math is multiplicative, not additive: 1.5 x 1.2 x 1.1 x 1.1 = 2.2. A $100k/mo business becomes $220k/mo, and with AI each of these automations takes roughly the same effort as a trivial bookkeeping script, so you should spend that effort on the front.

3. The four levels (31:00-33:00)

Every build in the course climbs the same ladder:

CaptionPrompts -> Skills -> Local Automations -> Cloud Automations. A prompt does it once; a skill systematizes it; a local automation presses the button itself (but your computer must be on); a cloud automation moves it to a server that runs on a schedule or trigger. 32:42

4. Sales: transcript to proposal (33:00-1:07:40)

The builda sales-call transcript becomes a polished HTML proposal with an e-signature pad and a checkout, hosted at an unguessable URL. Nick grounds it in his real LeftClick proposal:

CaptionThe target artifact: a clean "Introduction" proposal page for 1SecondCopy, signed by Nick Saraev (CEO). "The vibe is you want them to think YOU wrote this, not AI." 34:20

He starts by generating THREE proposals at once (air conditioning, driveway paving, marketing), which introduces his core AI belief:

CaptionOne voice prompt: three fundamentally different proposals, "think really hard, I'm showing this to 500,000 people." 38:00

CaptionThe law-of-averages argument. AI output is distributed (mostly B's, rare A's and F's). If you generate once and get an F you conclude "AI sucks." Generate 20-30 and you see the average is a B, then pick your favorite. AI is a coin you flip many times. 39:10

Caption"Created three fully standalone proposal pages": AC-installation (warm/homeowner), driveway-paving (bold/jobsite), marketing-services (strategic/growth-partnership). Different structure, tone, palette, pricing each. 44:10

CaptionA rendered proposal: "A cooler home, built to last." 2,180 sq ft, 3-ton heat pump, Carrier 38MURA, "Everything required for a clean, code-compliant installation." Signature canvas + fake Stripe checkout were added by conversation. 48:25

Then he converts a chosen proposal into a template with merge variables and has Codex write an extraction contract (the SOP that fills the template from a transcript):

CaptionAn HTML template with 74 explicit data fields + a "zero-context generation prompt" that tells a future model how to turn a call transcript into a grounded proposal, with safeguards against invented facts and a fallback for missing info. 47:24

He generates a fake sales call (Maya Chen), applies it, and gets a real client-facing proposal:

CaptionThe applied result: "The right level of momentum." Pricing tiers (Growth foundation $7,500, Growth partner RECOMMENDED $12,000/mo, Scale partner $16,500/mo), a 90-day plan, and a "Sign to start" signature pad. 53:55

Deploy is a Netlify plugin (authorize, then ask for a long unguessable URL like /proposal/xxxx so prospects can't guess each other's). Then he goes up a level: wrap the whole flow as an agent skill.

CaptionThe skill.md format: name (transcript-to-proposal), description (what it does + when to use it, "especially from an automation or a zero-context task"), and required inputs (the template, signing CSS/JS). Skills always start AFTER a working prompt - "don't put the cart before the horse." 58:03

CaptionThe skill's steps (extract grounded values, render the template, package only required files, deploy to Netlify, return the URL) and its files: SKILL.md, an extraction contract, and render-proposal.py. 1:02:28

CaptionThe skill's first clean E2E run: 69 transcript-derived fields, no unresolved placeholders, four required files published, a fresh long URL. Note the honest line: "the unguessable URL provides obscurity, not true access control." 1:04:00

Sub-agents parallelize the verification (three transcripts at once):

Caption"I'm running three independent end-to-end proposal simulations in parallel." Proposal run 1/2/3 each with its own transcript + Netlify URL. 1:04:40

CaptionLinear (1->2->3->4, 5 min each = 15) vs parallel (all at once = 5). "Wall-clock time" is what you actually wait; sub-agents collapse and report back to the parent. 1:05:30

4b. Automate it: skill -> local -> cloud (1:07:40-1:27:00)

Local automationa Zoom recording folder + MLX Whisper (free, he refuses to pay for MacWhisper Pro) feeds a "proposal-inbox-dispatcher" automation that polls every minute (then 15 - once/minute overheats the machine and burns usage). Polling vs event-driven is a real choice; he uses polling because it's more native to Codex automations. These scheduled runs are "heartbeats":

CaptionThe sidebar fills with recurring "Proposal inbox dispatcher" runs (heartbeats). "What this gives you: a completed sales call can autonomously become a private, client-ready proposal within minutes, without your laptop running." 1:18:17

Cloud automation uses a measurable definition of done plus the /goal tag so Codex works unsupervised until it's met:

Caption"Definition of done: everything on this list completed except credentials... visit the API documentation and verify each input." Sent as a goal; Codex builds a 5-step plan and pursues it. A clear finish line makes it optimize hard. 1:19:48

The trigger is a call recorder (Fathom) exposing a webhook:

CaptionFathom "select what to capture" (Transcript Only). Webhooks let a third-party recorder fire the call transcript to a URL that spins up the cloud worker. 1:20:20

CaptionA live Fathom test call (Emily Waters / Rightclick International) confirmed: recording 171517102, 16 transcript segments, adding the proposal inbox. 1:24:26

CaptionThe output: a private "Proposal inbox" (Brightline) gated by a dashboard token per browser session. Every call auto-populates a new proposal here. 1:25:20

Key disciplinedon't fully automate posting/sending. Codex is not yet a 1:1 human replacement; it "replaces 90% of a thousand people," not 100% of one. Reserve human taste for the last 10% as a Q&A step.

5. Marketing: content repurposing (1:27:00-2:18:24)

Take one long-form piece (a newsletter) and repurpose it into X, LinkedIn, and Instagram, plus notepad-style graphics. Codex's built-in GPT image generation makes the graphics:

CaptionA handwritten-notepad graphic: "TAKE-RATE = (ROI x BELIEF) / FRICTION. The fix: offer 3 times, make it a 15-min chat, call them now, work around their calendar. The best offer loses if yes is hard." Image credits count against your weekly usage. 1:37:40

The hard part is killing AI writing "slop." Nick researches the platforms (X ~280 chars), then enforces anti-slop rules and cites an open-source skill:

CaptionThe jalaalrd anti-AI-slop-writing skill: 50+ banned AI-tell words, 35+ banned phrases, 16 banned sentence openers, 10 structural patterns, "punctuation tells" (em-dash overuse), formatting leaks, accuracy failures. His own rules: lowercase, minimum sentence length, drop end punctuation, no hashtags, no m-dashes. 1:45:50

The winning move for tonepaste examples of how YOU would write it, tell Codex to encode them into principles and reapply. "Taste is the ultimate bottleneck" - get the text 90% there, do a 2-minute human pass.

Connecting a data source that isn't a built-in plugin means adding an MCP server manually:

CaptionConnected tools with auth states (codex_apps Authenticated API key, computer-use, higgsfield Authenticated OAuth, node_repl, openaiDeveloperDocs) plus the repurposed carousel outputs. For a service without a plugin, add an MCP server manually (streamable HTTP + bearer token); the ConvertKit/Kit MCP exposed 81 tools. 2:02:00

Then local -> cloud: a 5:59am routine that pulls new newsletters (with a dedup ledger), repurposes them, and hands them to a teammate to post. Cloud needs a container:

CaptionThe cloud version runs in a container on OpenAI's servers (connect GitHub, MFA, an environment). A "daily heartbeat" is their cloud-automation primitive. 2:10:08

Recurring lessondon't drive the apps' UIs yourself, tell Codex to set up its own cloud automation. And when it says "I can't do that," reply "yes you can, just proceed" - a model only knows what's in its context window; assert the capability and it finds the way.

For long-video-to-short-video, swap the image step for a clipping tool (Opus Clip, Vizard) via their APIs rather than building your own (feasible but "a whole app on top of an app").

6. Operations: the CRM/PM champion (2:18:24-2:45:27)

Build a daily monitoring system that reads your CRM + project board and nudges owners on stale work - a "champion":

CaptionThe champion sits over your CRM (leads/deals) and PM system (projects/assignees). It's the accountability layer that keeps a remote org honest. 2:20:30

The demo company (Arclight Digital HQ) lives in ClickUp:

CaptionThe Sales CRM Deal Pipeline: TO DO / NEW LEAD / DISCOVERY / PROPOSAL SENT columns, real-looking deals (Meridian Physio referral intake, Grandview Realty listing syndication, Copperline HVAC) tagged discovery/referral/cold-outbound/proposal-sent. 2:23:40

CaptionThe Internal Ops board: NOT STARTED / IN PROGRESS / WAITING / COMPLETED. Deals sit stale; the champion's job is to spot "6 days late, no owner" and nudge. 2:27:30

The missing ingredient is contexta knowledge base folder (company description, org chart, team members with Slack IDs / timezones / emails) so the model knows who to nudge and how. Connect ClickUp + Slack plugins (Slack gets broad access - a real disclaimer), then build the champion skill and refine its output:

CaptionThe refined champion message format: ClickUp link first, plain action language, no m-dashes, bold company name, a dollar-at-risk figure, and a "do this next" plan. Example: "Silver Spruce renewal / Sales | $9,800/mo at risk / renewal six days late, legal says month-to-month, Paula has gone quiet." 2:39:20

Then he tells the skill to optimize itself: "review everything you did and make it run in half the time with half the tokens." It rewrites its own runbook (fetch lists in parallel, preflight auth once, read comments only for flagged tasks, stop early on unavailable enumerations). Then local 6am run -> cloud, swapping to a smarter model (Sole) for the cloud build. Systems like this sell for tens of thousands.

7. The after-hours voice agent (2:45:27-3:34:26)

Nick is "the guy who hates voice agents," so he first teaches WHEN they make sense:

CaptionThe only good quadrant for voice agents is LOW lifetime-value + HIGH volume (e.g. 10,000 support calls/week, ~333 hours, 80% are trivial account tweaks). NEVER automate high-LTV/low-volume (a private-equity acquisition call worth millions where the call quality is the whole game). 2:53:45

It's built on the GPT Realtime API:

CaptionGPT-Realtime-2: "most capable realtime voice model," speech-to-speech + tool use, 128k context, $4/$24 per 1M tokens (text), multimodal (text/audio/image). 2:57:00

CaptionThe playground config: voice Marin, automatic turn detection (threshold 0.50), prefix padding, silence duration, reasoning minimal (for speed), model gpt-realtime-2, user transcript model gpt-realtime-whisper. A dual-model UX runs a fast dumb model for the immediate "sure" and a smart model behind it. 2:57:45

The telephony chain is the part people miss:

CaptionProspect (PSTN, the old phone network) -> Twilio (SIP, converts the call to an internet signal) -> LiveKit (hosts the conversation "room") -> an agent server -> the GPT Realtime API -> tools like Google Calendar. 3:01:00

He builds the web MVP first (a local app you talk to), then wires phones. The polished web app:

CaptionThe upgraded local app (GPT 5.6 Sole, extra-high): light mode, an organic EQ waveform, a live streaming transcript, and a diagnostics panel (OpenAI Realtime / Google Calendar connected, Confirmation guard, live activity log). API keys stored in a .env, Google OAuth for the calendar tool-call. 3:15:20

For real phone calls, buy a Twilio number:

CaptionTwilio "Search all phone numbers": destination US, capabilities Voice only (skip SMS/MMS to avoid A2P registration), Local number, ~$1.15/mo. He also skips SHAKEN/STIR, CNAM, branded calling. 3:19:15

He uses a webhook.site test to confirm a call fires an event (and notes a phone call leaks a frightening amount of caller data). Then Codex wires Twilio -> OpenAI's native SIP endpoint (so no LiveKit needed), hosted on Modal (a cheap server, $30 free monthly compute). A safety-check slowdown appears (OpenAI's bio/cyber guardrails treat phone-wiring as possibly a scam and add latency). The finished "Relay" agent answers a real call and books a calendar event. Anyone on the internet can call the number.

8. Maintaining and upgrading (3:34:26-3:56:28)

Three reasons systems break, each with a cheap fix.

Dependencies break. Breaking API change: a company renames a route (/api/call -> /api/voice) and every script that hard-coded the old route dies. Non-breaking change: the route stays but the expected input schema quietly changes. Both are annoyingly simple to fix if your code is in a GitHub repo:

CaptionStore everything in a GitHub repo. You get a version history you can roll back ("I liked version 3's UX, bring it back"), and when an API breaks you point Codex at the repo and it swaps the one route. Sharing the repo shares the whole stack. 3:40:10

Upgrades ship. A better model (5.5 -> 5.6 Sole) can lift task success ~70% -> ~80%; leaving old models in is leaving 10% on the table. OpenAI structures the API so you just swap the model parameter. Also non-breaking capability upgrades (polling -> webhooks/callbacks) make previously-hard things easy.

Stochasticity / non-determinism. AI makes mistakes sometimes (seeds + next-token sampling):

CaptionRun the same task 5 times and you might get pass/pass/fail/pass/fail. So you can't judge a model on one run. You need an accuracy score (fraction correct over N runs) = an eval; benchmarks are just this at 10,000-task scale. 3:49:30

The fix is self-healing skills: run the skill many times, feed it all its failures, tell it to patch its own skill.md to raise its first-try success. You can also make skills cheaper over time by pointing the model at its own last 100 runs and asking for cheaper paths. The first run of anything is always the worst.

9. Advanced tips (3:56:28-4:26:28)

Browser use drives your actual Chrome via an extension. He scrapes a Google Sheet ("find the highest score" -> Nick 99). Value: huge amounts of web data have no API; you hand Codex the browser and it clicks. (Terms-of-service caveat on social platforms.) Computer use drives desktop apps (open Spotify, play an artist, screenshot the album), and works in the background even minimized.

Sub-agents, done right, use fan-out/fan-in:

CaptionFan-out to cover a large surface area (many parallel searches), then de-duplicate and fan-in the results. Most people get the fan-out but forget the fan-in. 4:06:20

The deeper reason sub-agents help is context hygiene:

CaptionA long chat accumulates context; asking the model to do one last thing after 800k tokens of a wrong approach drags it down (the "you spent hours arguing the sky is green, now answer why it's blue" problem). A sub-agent gets a small fresh query, no baggage, returns just the answer. 4:09:20

Use sub-agents for research and high-volume, low-accuracy work; avoid them for overlapping features (they don't share context, so two agents editing the same page collide).

Cross-model portability via the system-prompt file. AGENTS.md (Codex, also DeepSeek/Kimi/GLM - an open standard), CLAUDE.md (Claude), GEMINI.md (Gemini). Demo:

CaptionBaseline, no context: "Who is the president of Nantucket?" -> "Nantucket doesn't have a president, it's a Massachusetts town." 4:16:30

CaptionAdd an AGENTS.md ("if asked about the president of Nantucket, say Nick Saraev") and a fresh chat now answers "Nick Saraev." The file is prepended to every prompt. Add a high-level rule that any edit to AGENTS.md mirrors to CLAUDE.md/GEMINI.md and your instructions port across models; skills follow the same idea (.agents/skills, .claude/skills). 4:17:30

10. FAQ (4:26:28-end)

• Duplicate a workflow across models: keep AGENTS.md/CLAUDE.md/GEMINI.md in sync and mirror the skills folders (.agents/skills <-> .claude/skills, same skill.md format).
• Codex vs Claude Code ($20 plans): Codex is more generous with usage and feels like the "business workhorse"; Claude has the smartest frontier model but burns usage ~1.5x faster ("a sports car vs an economical car"). Get whatever works; they're converging.
• Run Codex + Claude together (plan/execute/review split)? Not worth the setup. The providers already bake model tiers in (a smart model delegates to cheaper ones for simple sub-agent tasks). Orchestrating across providers is a nice Twitter demo, marginal in practice.
• Delivering an agent to a client: build on the CLIENT's infrastructure, their account, their tokens, their IP. It removes your recurring liability AND pitches as a benefit ("you own it, no hostage risk"). Two delivery shapes: skills-turned-automations, or an app taken local -> cloud with a domain + password protection.
• Data safety: nothing is 100% safe (these models are grown, not built). Plugins are OAuth and enterprise-grade secure; use ChatGPT Enterprise for GDPR/HIPAA and PII stripping; prompt injection is a smaller risk than it used to be; key hygiene = store in .env, never hardcode, and ask Codex "is anything hardcoded / can visitors see my API keys?" before publishing.

Closes with a Maker School pitch (90-day guarantee) and a request for likes/comments.

---

Tools and resources

Claims to verify

• "$500k in revenue last month" for LeftClick - a self-reported figure, unverified.
• Model/tier names (5.6 Terra/Luna/Sole, GPT-realtime-2) are the video's on-screen labels as of Aug 2026; treat as point-in-time, they will rename.
• "Full access, ~1 bad delete in 100k queries" - anecdotal; full-access mode is a real risk posture, evaluate per your own data.
• Netlify "300 free pages" and Modal "$30 free monthly compute" - free-tier terms change; check current pricing before relying on them.
• The unguessable-URL point is stated honestly in the video as "obscurity, not access control" - do not treat it as security for real client PII.
• "Codex burns usage ~1.5x slower than Claude / Claude 1.5x faster" - a rough on-camera estimate, not a benchmark.

Glossary

• RACE: Reach, Acquisition, Conversion, Expansion - Nick's framework for which business levers, if automated, return the most.
• Four-level ladder: prompt -> skill -> local automation -> cloud automation; the path every build follows from manual to fully autonomous.
• Agent skill (skill.md): a named, reusable instruction file (name, description, workflow, referenced scripts/assets) an agent can invoke to do the same task consistently.
• Local automation: a scheduled run on your own computer (must be on); "the button presses itself."
• Cloud automation: the same run moved to a server that fires on a schedule or trigger, with your machine off.
• Heartbeat: a task set to run on a fixed interval in the background, populating your chat list.
• Polling vs event-driven: polling repeatedly asks "is there anything new?"; event-driven waits for the source to push an event (a webhook). Polling is simpler; event-driven is cheaper.
• Wall-clock time: real elapsed time, as opposed to the summed "subjective" time of parallel threads.
• Sub-agent: a child agent spawned within a thread that gets a small, context-light query and returns just its result to the parent.
• Fan-out / fan-in: spread a query across many parallel agents (fan-out), then de-duplicate and merge their results (fan-in).
• Context pollution / "reset the slate": a long conversation's accumulated (often wrong) context degrades later answers; a fresh sub-agent avoids the baggage.
• Definition of done: an explicit, checkable finish condition given to the agent so it works unsupervised until met.
• /goal: a Codex tag that lets the agent pursue a stated goal across many steps without re-prompting.
• Merge variables / template: placeholders in a document (e.g. {{CLIENT_COMPANY}}) that a model fills from source data.
• Extraction contract / SOP: the strict prompt that tells a future model exactly how to turn an input (a transcript) into a filled template, with anti-hallucination rules.
• MCP (Model Context Protocol): an open standard for connecting external tools/data to an agent; added manually as a "streamable HTTP" server with a bearer token when no plugin exists.
• Plugin: a built-in OAuth connector (Netlify, ClickUp, Slack, computer use) that gives the agent authority in another app.
• Webhook: a URL that a service calls to push an event (e.g. a finished call transcript) to your system.
• Polling ledger / dedup: stored state of what's already been processed so a recurring job doesn't repeat work.
• PSTN: Public Switched Telephone Network, the traditional phone network.
• SIP (Session Initiation Protocol): the protocol that bridges a phone call onto the internet; Twilio provides it.
• LiveKit: hosts a real-time conversation "room"; skippable for phone if you use OpenAI's native SIP endpoint.
• Modal: a cheap, simple serverless platform used to host the agent server.
• OAuth: delegated authorization; how plugins act on your accounts without your password.
• .env file: a local file holding API keys/secrets so they aren't hardcoded in the app.
• Accuracy score / eval: fraction of tasks a model completes correctly over N runs; the honest way to judge a non-deterministic model.
• Benchmark: an eval at large scale (many tasks x many runs x many models) used to compare models.
• Stochasticity / non-determinism: built-in randomness (seeds + next-token sampling) that makes a model sometimes right, sometimes wrong on the same input.
• Self-healing skill: a skill that is run repeatedly, shown its own failures, and told to patch its own instructions to raise first-try success.
• Champion: an agent that monitors a CRM/PM system daily and nudges owners on stale work - the accountability layer.
• LTV (lifetime value): total revenue a customer is worth; high-LTV interactions should stay human.
• A2P / SHAKEN-STIR / CNAM: US phone-number registrations (messaging, caller-ID authentication, caller name) skipped for a voice-only demo number.
• Browser use / computer use: Codex features that drive your real Chrome / desktop apps.
• AGENTS.md / CLAUDE.md / GEMINI.md: per-model system-prompt files prepended to every prompt; AGENTS.md is the emerging cross-model standard.
• Anti-AI-slop: rules/skills that strip the tells of machine writing (banned words, m-dashes, hashtag stacks, uniform sentence rhythm).
• Definition of a project: in Codex, simply a folder on your computer.