Modern Creator
Why Modern Creator?
Aniket Panjwani · YouTube

OpenAI Codex Full Course: Build & Ship in 4 Hours

A four-hour, screen-recorded course that starts at "what is Codex" and ends with a working carousel app deployed to a public URL.

Posted
4 months ago
Duration
Format
Tutorial
educational
Views
61.9K
1.7K likes
Big Idea

The argument in one line.

Agentic coding stops being a chat toy the moment you stack five capabilities on top of it, and the fastest path to a shipped app is deciding what to build with the agent before you write a line of code.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…
  • You pay for ChatGPT already, have never opened the Codex desktop app, and want one pass that covers everything instead of forty scattered tutorials.
  • You can describe what you want built in plain English but freeze at the words git, branch, pull request, or deployment.
  • You have been using an agentic coding tool as a fancy autocomplete and suspect you are leaving 80% of the capability on the table.
  • You run a small business or a newsletter and want internal tools built for you rather than bought as another monthly subscription.
  • You are already fluent in one agentic coding tool and want a fair, hands-on comparison of how the other one handles skills, subagents and parallel work.
SKIP IF…
  • You are on Windows and mainly came for computer use, which is Mac-only at the time of recording.
  • You want deep instruction on Next.js, Convex or Vercel individually, because the stack is introduced only far enough to get one app shipped.
  • You want a tidy, heavily edited course, because the last hour is deliberately loose and the presenter narrates his own laziness while the agent works.
  • You need enterprise-grade sandboxing guidance, since the safety advice tops out at one hook-based guard tool and a permissions toggle.
TL;DR

The full version, fast.

Agentic coding tools run on your machine, so they can touch your real files and your real terminal, which is the entire difference between advice and work getting done. Five capabilities stack on top of that: plugins for one-click connections, computer use for anything that needs a real browser or app, skills for your own repeatable workflows, MCPs for services that only expose a server, and subagents for clearly divisible parallel work. Wrapped around them is a product loop: ideate, brainstorm requirements, write the plan to a markdown file, split it into GitHub issues, then run issues in parallel with worktrees. Ship by pushing to GitHub and letting the host deploy. The blunt contrarian calls are that project instruction files are usually a net negative, that nobody should buy skills, and that cloud delegation is not worth it yet because it runs an older model.

Free for members

Chat with this breakdown — free.

Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.

Create a free account →
Chapters

Where the time goes.

00:00 – 07:25

01 · The promise and the map

Why the desktop app rather than the terminal, and a full walk of the 24 sections to come.

07:25 – 15:50

02 · What Codex is, what it costs

The difference between a chat window and a tool running on your machine, a live PDF-summarizing demo, then pricing and install.

15:50 – 39:25

03 · Desktop app tour

Every panel: projects, threads, search, plugins, skills, automations, the terminal, the file tree, review UI, slash and dollar and at shortcuts, models, reasoning effort, permissions, settings.

39:25 – 47:21

04 · Context windows and voice

What eats tokens, what compaction actually does, and why dictating prompts beats typing them by a factor of nearly four.

47:21 – 56:05

05 · Permissions and guardrails

Default permissions versus full access demonstrated side by side on a messy desktop, then a hook-based guard that makes destructive commands impossible.

56:05 – 1:01:24

06 · The case against project instruction files

A contrarian argument, backed by two benchmark charts, that most project instruction files cost more than they return.

1:01:24 – 1:22:16

07 · Plugins and computer use

The five primitives introduced, then the two that need no setup: one-click plugins installed and stress-tested live, and an agent driving Chrome in the background.

1:22:16 – 1:58:18

08 · Skills, and skills versus MCPs

Skill anatomy, progressive disclosure, where skills live by scope, building one from scratch, installing someone else's, then why an MCP is sometimes the only option.

1:58:18 – 2:17:00

09 · Subagents and the decision ladder

Parallel instances explained, six agents mapping an unfamiliar codebase live, then a walk down the ladder of which capability to reach for and when.

2:17:00 – 2:33:25

10 · Git and GitHub from zero

Commits, branches, pull requests and issues taught through actually initializing the course project and pushing it to a private repo.

2:33:25 – 2:56:28

11 · Deciding what to build

The ideate, brainstorm and plan skills run in sequence on a vague carousel idea until it becomes a scoped, committed plan document.

2:56:28 – 3:16:24

12 · Cloud delegation, issues, automations

Why running tasks in the cloud is not worth it yet, then splitting the plan into GitHub issues and setting a recurring automation to triage them.

3:16:24 – 3:33:19

13 · The stack and worktrees

Front end, back end and hosting explained in one diagram, the installs done live, then worktrees and the bootstrap script that makes a fresh worktree runnable.

3:33:19 – 4:02:17

14 · Building and shipping Creator Carousel Studio

Issues worked one at a time, then two in parallel worktrees, then a deliberate hands-off run through the whole backlog, ending with a live deployment and a closing pitch.

Atomic Insights

Lines worth screenshotting.

  • The difference between a chat assistant and an agentic coding tool is that one gives you advice and the other sits down at your computer and does the work.
  • You should probably never write a project instructions file, because a beginner's version over-specifies things that go stale and quietly poison every future run.
  • Benchmarks show project instruction files help weak models and do nothing for strong ones, while consistently raising the number of steps and the cost.
  • If you do write project instructions, write them only as a corrective for what the agent keeps getting wrong, like pinning a library version past the model's cutoff.
  • You type at roughly 40 words per minute and speak at roughly 150, so dictation is the single cheapest upgrade to the quality of your prompts.
  • A typed "fix the login bug" and a spoken forty-second version of the same intent produce completely different results, because only one carries enough context to solve it on the first try.
  • Skills only load their name and description into context, about 100 tokens each, so fifty skills cost you 5,000 tokens instead of the 100,000 the full bodies would eat.
  • The reason skills exist at all is progressive disclosure: a way to give an agent specialized abilities without spending the context window before you have typed a single message.
  • Anyone selling you agent skills is trading on your lack of knowledge, because the tool ships with a skill whose only job is writing skills.
  • Plugins get you value on day one, but they break the moment your workflow is specific, because nobody built them around your pagination quirk or your triage rules.
  • Subagents protect your context window but not your usage limits, which is exactly why the tool refuses to spawn them without being told.
  • Use subagents when the task is clearly divisible and skip them when the task is fuzzy, because "fix the app" is a bad instruction whether one agent or six is reading it.
  • Cloud delegation runs a model two generations behind the one you get locally, so the convenience costs you the intelligence you were paying for.
  • One developer running a one-man startup on a competing cloud agent pays $2,500 to $3,000 a month in API credits, which is the real price of skipping subscriptions.
  • Git is not a developer ritual, it is memory for the agent: it can see what changed, when, and in what order, which file timestamps can never tell it.
  • Commits are checkpoints, branches are experiment lines, pull requests are review before merge, and issues are named units of work. That is the whole mental model.
  • Write the plan to a markdown file in the repo rather than to a plan mode, so you can start a fresh context window, point at the file, and skip the exploration you already paid for.
  • Issues are the cure for coming back to a project after three weeks with no idea what you were doing, and they let the agent pick up the next unit of work unprompted.
  • Worktrees give each parallel task its own physical copy of the repo, which is why two features can run at once without overwriting each other's files.
  • A worktree only copies committed files, so anything gitignored (secrets, installed packages) has to be recreated by a bootstrap script or the copy is dead on arrival.
  • Merge conflicts are not failure, they are the signal that two parallel tracks touched the same design surface, and the agent can now do the reconciliation you used to do line by line.
  • Two parallel issues that would have taken 20 minutes back to back finished in 11 and 10 minutes side by side, which is the entire argument for worktrees in one number.
  • Building software with an agent is closer to sculpting than to writing: let it run all the way through, then chip off what you did not want.
  • Coding agents do not remove the need for thinking, they move it, and the real skill is knowing which parts of the job still deserve your attention.
  • Deciding what to build is a step you can run with the agent, and skipping it is why vague prompts produce results you did not ask for.
Takeaway

What four hours of agentic coding actually teaches

WHAT TO LEARN

The capability that matters is not the model, it is the stack of five extension points around it plus a product loop that decides what to build before anything gets written.

02What Codex is, what it costs
  • An agentic coding tool differs from a chat window in one way that changes everything: it runs on your machine, so it reads your real files and executes real commands.
  • Because it has your files and your terminal, the use cases run far past code, into drafting, spreadsheet analysis, PDF research and document assembly.
  • Pick the subscription tier by how many parallel agents you plan to run, not by which one sounds professional, and skip the API unless you have a reason, since subscriptions are the subsidized path.
03Desktop app tour
  • Every panel in a desktop agent app is a capability you are paying for whether or not you use it, so tour the whole interface once before deciding what your workflow is.
  • Reasoning effort is a real dial with a real cost, worth turning down on simple tasks and worth leaving high on anything you would have thought hard about yourself.
04Context windows and voice
  • Tokens are consumed by everything, not just your prompts: file reads, tool outputs, the system prompt, and every skill description loaded at startup.
  • Compaction summarizes a long session so work can continue, and letting it fire automatically is usually the right default rather than compacting early by hand.
  • You type at roughly 40 words per minute and speak at roughly 150, so dictation is the cheapest available upgrade to prompt quality.
  • The same intent typed and spoken produces different results, because the spoken version carries the surrounding detail that lets the agent solve it on the first attempt.
05Permissions and guardrails
  • Default permissions stop the agent before each risky action, full access removes the friction, and the honest tradeoff is speed against recoverability.
  • A hook that inspects every command before it runs makes catastrophic operations impossible, which is what makes full access defensible rather than reckless.
06The case against project instruction files
  • Most project instruction files are net negative: beginners over-specify, the details go stale as the project changes, and stale instructions actively mislead the agent.
  • Benchmarks show these files help only the weakest models, and consistently increase the number of steps and the cost even when they do not change the outcome.
  • If you write one, use it purely as a corrective for what the agent keeps getting wrong, such as pinning a library version that postdates the model's training.
07Plugins and computer use
  • Plugins are the right first move because they install in one click and pay off immediately, and the right time to leave them is the moment your workflow gets specific.
  • A plugin failing on your particular case is diagnostic, not a defect: it tells you exactly which custom instruction your own skill needs to carry.
  • Computer use covers everything that has no API worth using, from driving a browser in the background to testing your own app the way a person would.
08Skills, and skills versus MCPs
  • A skill is a folder, not a file, with only SKILL.md required and heavier material kept in subfolders so it loads only when needed.
  • Progressive disclosure is the whole design: about 100 tokens of name and description per skill up front, with the body pulled in only on use.
  • Scope decides where a skill lives, project-level for repo-specific workflows and user-level for anything you might want from any directory.
  • You do not need to write skills by hand, since describing the workflow in plain language to a skill-creator skill produces the folder and its scripts.
  • Nobody should buy skills, because the barrier to making your own is a paragraph of description and the tooling ships in the box.
  • MCP is a shared standard that lets any AI application talk to any service, and most one-click plugins are wrapping an MCP under the hood.
  • Prefer a skill over an MCP when you plan to customize, and accept the MCP when the service exposes no API you can reach directly.
09Subagents and the decision ladder
  • Subagents are separate context windows that report only their conclusions back, which is why they suit codebase exploration and multi-document summarizing.
  • Use subagents when the task divides cleanly and skip them when it does not, because a fuzzy instruction stays fuzzy no matter how many agents receive it.
  • Subagents cost usage even though they save context, which is exactly why a tool that respects your limits will not spawn them without being asked.
10Git and GitHub from zero
  • Version control gives the agent memory, since a commit history is a reliable record of what changed and when in a way file timestamps never are.
  • Commits are checkpoints, branches are experiment lines, pull requests are review before merge, and issues are named units of work.
  • You can get remarkably far knowing only commit and push, and the more advanced concepts earn their keep only once work runs in parallel.
11Deciding what to build
  • Vague prompts produce disappointing results because the idea was vague first, so run ideation and requirements with the agent before asking for code.
  • Write the plan to a markdown file in the repository rather than into a transient plan mode, so a fresh session can pick it up without repeating the exploration.
  • Committing the ideation, brainstorm and plan documents turns your reasoning into project history that future sessions can read.
12Cloud delegation, issues, automations
  • Cloud delegation sounds appealing but runs an older model and forces you to recreate secrets and network access, so local execution stays the better default.
  • Issues solve the problem of returning to a project weeks later with no idea what is next, and they give the agent a queue it can pull from unprompted.
  • A good issue names the work, records what it blocks, links to the plan for detail, and states how to verify it is finished.
  • Automations are scheduled prompts, useful for standup summaries, issue triage and watching a deployment, and they inherit your project's permissions rather than getting their own.
  • Test any automation you depend on, because missing credentials or blocked network access fail silently until you look.
13The stack and worktrees
  • Every web app is a front end, a back end and a hosting layer, and that level of understanding is genuinely enough to ship your first one.
  • Naming the stack up front constrains what the agent builds, which is more useful than knowing the stack deeply.
  • Worktrees give each parallel task its own copy of the repository, which is why two features can be built simultaneously without clobbering each other.
  • A worktree only carries committed files, so a bootstrap script has to recreate secrets, dependencies and non-conflicting ports or the copy will not run.
14Building and shipping Creator Carousel Studio
  • Two parallel issues that finished in 11 and 10 minutes would have taken 20 minutes back to back, which is the whole case for worktrees in one measurement.
  • Conflicts are a signal that two tracks touched the same design surface, and reconciling them is now work the agent can do for you.
  • Give the agent a visual source of truth, such as reference images of the output you want, and the target stops being a description and becomes a comparison.
  • Letting the agent run an entire backlog uninterrupted is a legitimate strategy for throwaway or internal tools, where chipping away what you did not want costs less than specifying it up front.
  • Deployment is the easy part once code is pushed and hosting is connected, which means the real work was always the decisions made before the build.
Glossary

Terms worth knowing.

Agentic coding
Using an AI tool that runs locally with access to your files and terminal, so it can read, edit and execute rather than only suggest.
Context window
The maximum amount of text a model can hold in a single conversation, counting your messages, its replies, every file it reads and every tool result it receives.
Compaction
When a conversation approaches the context limit, the tool summarizes what happened so far, keeps key decisions and file references, and continues from that summary.
Skill
A folder containing a SKILL.md file with a name, a description and instructions, optionally plus scripts, reference docs and assets, that teaches an agent one repeatable workflow.
Progressive disclosure
Loading only a skill's name and description into the model's context up front, and pulling in the full body only when that skill is actually invoked.
MCP
Model Context Protocol, an open standard for connecting AI applications to external systems, so any tool can talk to any service without a bespoke integration.
Plugin
A packaged bundle of skills, MCP servers and app connections that installs in one click to hook an agent up to a service like Notion, Gmail or Drive.
Subagent
A parallel instance of the coding agent with its own context window, given a scoped task and reporting only its result back to the main thread.
Hook
An extensibility point that fires deterministically at a stage of the agent's lifecycle, for example checking every command before it runs and rejecting dangerous ones.
Commit
A saved snapshot in version control with a message describing what changed, along with the exact line-by-line differences from the previous snapshot.
Branch
A separate line of history in a repository, used to try a feature or experiment without disturbing the main line, and either merged in or thrown away.
Pull request
A proposal to merge one branch into another, showing the full set of changes so someone can review them before they land.
Worktree
An independent working copy of the same repository on disk, letting several tasks run on different branches at the same time without file collisions.
Detached HEAD
A repository state where the current checkout is not attached to any named branch, common when a fresh worktree is created before you name a branch for it.
Rebase
Replaying one branch's commits on top of another branch's latest state, used to bring a parallel line of work back in sync before merging.
Continuous deployment
A setup where merging code into the main branch automatically triggers a build and publishes the new version to the live site.
Resources

Things they pointed at.

07:36productOpenAI Codex desktop app ↗
44:48toolWispr Flow (voice dictation) ↗
52:41toolDestructive Command Guard
22:46toolVisual Studio Code ↗
1:09:07productNotion plugin
1:08:26productRemotion plugin ↗
1:08:52productReadwise plugin
1:34:11toolyt-dlp ↗
1:35:30toolHomebrew ↗
1:44:13toolAnthropic front-end design skill
1:48:52linkModel Context Protocol ↗
2:03:55toolpi coding agent by Mario Zechner
2:36:48productCompound Engineering plugin
3:02:05productDevin
3:02:33productOpenAI Symphony
3:17:11toolNext.js ↗
3:17:40toolConvex ↗
3:19:11toolVercel ↗
2:24:09toolGitHub CLI (gh) ↗
3:21:10toolNode.js ↗
4:00:44productThe AI MBA (free Skool community) ↗
4:01:13productThe AI MBA Pro (paid, weekly calls + MCP transcript server) ↗
2:21:41linkNieman Lab feature on local newsletters
Quotables

Lines you could clip.

08:18
“Things like ChatGPT and Cloud are like asking a friend for advice, and then Codex and Cloud Code are like your friend actually sitting down at your computer and then doing the work for you.”
the cleanest one-sentence definition of agentic coding, no setup needed→ TikTok hook↗ Tweet quote
57:49
“My opinion is that you actually should never make agents.md files.”
flat contradiction of the standard advice, lands in four seconds→ IG reel cold open↗ Tweet quote
45:41
“When you are typing, you can on average type at just 40 words per minute, whereas you can speak at 150 words per minute.”
hard number that justifies a habit change immediately→ newsletter pull-quote↗ Tweet quote
1:43:06
“Most of the people who are trying to sell you skills are just taking advantage of your lack of knowledge about this space.”
names a live grift, invites argument in the comments→ TikTok hook↗ Tweet quote
1:29:38
“The only parts of the skill that enter into Codex's context before you've done anything is this metadata, so the name and description. And that only costs about 100 tokens.”
the single most useful technical fact in the skills section→ newsletter pull-quote↗ Tweet quote
1:59:44
“Codex doesn't work like that. You have to explicitly tell it when you want subagents to be invoked.”
corrects a wrong assumption most viewers arrive with→ IG reel cold open↗ Tweet quote
2:06:33
“It's true that they're not affecting your current context, but they are going to affect your usage.”
the hidden cost nobody mentions when they hype parallel agents→ newsletter pull-quote↗ Tweet quote
2:59:56
“Locally you're able to use GPT 5.5, which is the most powerful current model. But in the cloud, the most powerful model available is GPT 5.3 Codex, which is now two generations old.”
concrete reason to ignore a feature the app pushes at you→ TikTok hook↗ Tweet quote
3:02:05
“He's told me he's using Devin to run a one-man startup, but he's paying $2,500 to $3,000 a month just on API credits.”
a real number that reframes what a subscription is worth→ newsletter pull-quote↗ Tweet quote
2:47:24
“I really don't think that these coding agents obviate the need for thinking.”
the honest counterweight to four hours of automation→ IG reel cold open↗ Tweet quote
3:47:37
“Software building in this modern agentic era is sometimes a bit like sculpting, except you can take the pieces that you sculpted off and graft them back on costlessly as well.”
memorable metaphor that reframes how to sequence a build→ newsletter pull-quote↗ Tweet quote
3:42:16
“This one worked for 11 minutes and then this one worked for 10 minutes, and so if we didn't use worktrees these two things would have stacked one on top of each other and would have taken 20 minutes.”
the payoff of the whole worktree section stated as a measurement→ TikTok hook↗ Tweet quote
2:33:12
“Git is kind of like a safety layer for agentic coding. Commits are checkpoints. Branches are experiment lines. GitHub is the online home for those lines.”
four lines that teach version control faster than any tutorial→ newsletter pull-quote↗ Tweet quote
1:49:35
“MCP has been established as one official standard that everybody uses, so that any time your AI wants to connect to external systems, it knows the general method of doing so.”
plain-English MCP explanation for people tired of the jargon→ IG reel cold open↗ Tweet quote
The Script

Word for word.

Read-along

Don't just watch it. Burn it in.

See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.

metaphoranalogystory
Welcome to the definitive course on OpenAI Codex. I use Codex every single day as the director of AI and ML at Payslice, a VC -funded fintech startup. I also teach over 1 ,700 people in my school server, the AI MBA, how to use agentic coding tools like Codex and CloudCode for both personal, professional, and also academic research applications.
Now, I also recently made a three -hour full course on cloud code for beginners. But the reality is that for the last few months, I've been using Codex for 80 to 90 % of my work.
And my recommendation to... Anybody new to the agentic coding space is that regardless of your budget, whether it's $20, $100, or $200, is that your first subscription should be to ChatGPT, which gets you access to Codex. As I discussed in a recent video, there are many reasons for this, and I'll also discuss them in this course, but in a nutshell...
codex is the best model it has the best usage limits and it's got the best interface for agentic coding the codex desktop app in this course you're not going to have to have any technical background maybe you've played around with ChatGPT or Clawed in a Web Interface or you skimmed through my Clawed Code course. Either way, I'm going to take you step by step all the way from not knowing anything about agentic coding to being able to deploy a full -blown web app with Codex.
Additionally, this isn't one of those courses where I'm going to fill you up with hours of theory before we get to anything practical. I'm going to give you practical applications of Codex that you can take takeaway and which will add value to your life within the first 10 minutes.
And that's going to be a common pattern in the rest of the course. I'm always going to take little bits of theory and get as quickly to practice as I can. Now, one more thing I want to flag before we get started.
This course is specifically concentrated on the Codex desktop application. Codex actually ships as several different interfaces. There's the command line interface that you have to use in the terminal.
There's an extension inside VS Code, and then there's the desktop application. I'm going to be focusing on the desktop application because it's the best interface for agentic coding, but nobody has put out materials that teach people how to use it yet. In the desktop app, you can easily run multiple codex agents working on different aspects of your project in parallel, set up automations, which will run on the background on a timer.
and review all of it in one place. Let me first give you guys a brief overview of everything that we'll be covering in this course. We'll start by talking about what Codex actually is.
It may be unfamiliar to some of you. how much it costs, how to install it. I'll give you a tour of this desktop app interface, which may be new to some of you who may be used to a terminal interface.
And then we'll start getting directly into some of the fundamentals of agentic coding, such as context windows and compaction, and why you should typically be using voice for most of your work with Codex. Next, I'll cover some of the basics of agentic workflows past simply using it in a sort of chat GPT sort of way. We'll talk about permissions, guard.
rails and just the basics of what you need to know about terminals. I'll talk about this agents .md file, which gives Codex context about what to do in a project when it's starting up. And then we'll start getting into what I call the five practical primitives of agentic coding.
Those are command line interfaces, skills, MCPs, plugins, and sub -agents. We'll talk about plugins and the plugin system in Codex. We'll talk about a particular plugin called computer use, which allows codecs to control every single application on your computer.
And then we'll do a deep dive into skills, which are a fundamental concept in agentic coding to give agentic coding tools the ability to do repeated workflows with all sorts of external systems. I'll compare this with an alternative way of getting access to external systems called MCPs. And then we'll go into subagents, which allow you to parallelize work.
allowing you to do things a lot more completely and quickly. We'll talk about when to use which of these different tools. And then from there, I'll start bridging into the last third of the course, where we talk about how to go from doing automations on your computer to building full -blown web applications.
And the first prerequisite to understanding this is to understand the version control system, Git, and how it interacts with GitHub. Then I'll take you through a sort of product agentic coding course where we'll go and learn how to use agentic coding tools to think about what you want to build from a product perspective.
And there's particular skills that I'll introduce to help automate this. Next, we'll go into the idea of cloud delegation, running agentic coding tasks in the cloud instead of your local computer. After that, we'll get into GitHub issues, which I find to be a very useful basic project management tool.
And once we have GitHub issues in place, automations become very useful. concept in Codex to have certain sort of workflows that run on a timer. And so you could imagine, for example, checking in every single few hours, what sorts of new bugs arise, and perhaps if they're simple, automatically starting up on solutions to those bugs.
That's the kind of thing that you'll be able to build after going through this automation section. Then for the application that we're building, I'm going to introduce the general stack that we're using of Next .js, the front end framework. Convex, the backend framework, and Vercel, the place where you host your applications.
After introducing the stack, I'm going to introduce the concept of work trees, which are a little similar to sub -agents, but instead allow you to parallelize work across an entire repo rather than just within a repo. And this is very powerful to be able to scale up the rate at which you're able to complete agentic coding tasks.
Then finally, we're going to build out this creator carousel studio. So I'm going to build a kind of social media creation automation. Now, this app, which I'm going to develop, may not be relevant to every single person who is taking this course, but I still do recommend you go through this section if you're interested in general with app development, because what's important to get out of this section is different methodologies that I'm going to show you on the fly.
both simpler ones both less automated and more automated more hands -off workflows when you're building any kind of complex web application and the nice thing is that you're not going to need to know about the deep technical foundations of what you're building because i'll show you how with natural language just expressing your intent you're able to build fairly complex applications by yourself.
I'm going to create a companion skill to this application so that we're able to interact with it both in a web UI and from our local computer, and then we'll deploy it so that it's available on the wider internet. All right, let's get started. So first, what exactly is Codex?
If you've used ChatGPT or Clawed in the browser in the past, you know how it works. You open a tab in your browser. type in a message and then the AI responds.
You can upload a document and you can ask it to write some code, but it can't access the actual documents which are on your computer and it can only run code in a very limited sandboxed environment. It can't run code actually on your computer. That's the fundamental problem which Codex is here to solve.
When you run Codex, it's running on your computer. So it sees your actual files, it can edit them, and it can run commands whether to test some code or move files from one location or to another, or to do really anything you can, it can also do from your computer.
The analogy I gave in the Claude Code course, which also applies here, is that Things like ChatGPT and Cloud are like asking a friend for advice, and then Codex and Cloud Code are like your friend actually sitting down at your computer and then doing the work for you. Now, Codex starts with code, and so you might think that this is primarily a coding tool, but...
Really, since it's got access to your computer and to your files, it can do and help you automate anything that can be done with access to your files and your computer. For example, you can use Codex to draft emails. analyze PDFs, analyze your business spreadsheets, or even help you do your taxes.
If it's on your computer, Codex can help you out with it. Let me show you a quick demo right before I get into installing Codex. Here we are in the Codex desktop environment.
So if all of this looks very unfamiliar to you, don't worry. I'm going to be getting into that in just a few sections. What I wanted to show you quickly is just a practical demo.
that shows you the power of Codex and which you'll be able to do right after going through the very next section. As you can see right here, Codex ships with a file browser and... This is the directory that I use to organize all my research and my thinking about different YouTube videos.
And so one thing you can see here is that I have a folder with about 10 different PDFs of different papers on AI job loss. And let's say I wanted to make a summary of all of these PDFs. How can I do that?
Well, I'm simply going to come in here and say. Go to the content directory for 2026 -04 -12 AI job loss. And then I want you to create a sub -agent to...
Read every single paper in the research sources PDFs directory and create a detailed summary of the paper and different angles that might be good for YouTube videos. Then I want you to take the markdown created by each sub -agent and compile it all together in one attractive PDF using Pandoc and IceVogel. Now...
If that all sounds like gobbledygook to you, I totally understand because I haven't explained anything yet. But I just kind of want to prime you with some ideas because we're all about. practice we're not about theory we're about practice and so i want you guys to see the power of codex at a kind of basic skill right now or like a basic task right now but which is likely to be very useful to you all you may have lots of different documents or papers across which you want to do some kind of research and This kind of thing that I'm doing right here, it doesn't get rid of the need for actually doing your own reading.
In fact, if you look over here on the left -hand side, you're getting a little bit of a taste of what's to come. This is where you can see all your project. And you can see here that I'm building my own PDF reading app.
I'm even building my own focus app. And I'm building my own general learning system for how I like to learn things in a gentic way. All right, so Codex now.
in parallel is doing research across many of these different pdfs and then it's going to come back to me with some kind of comprehensive summary all right it finished let's take a look so we're gonna click this open and one of the nice things is that these briefs can open up right in your browser so let me close the file tree ai job loss research packet detailed paper summaries and youtube angles and i've got like 10 different papers in here so let's take a look at this i guess i can't click on it it's still pretty cool let's make this a little bit more small and so this is nice so i would often take something like this and just stick it on my phone and now i have something to like keep my mind running while i'm on the go in an uber at the gym whatever so This is a pretty cool first demo that I wanted to show you guys of the power of Codex and something that's really not possible when you're just using these tools in the web UI.
All right. So how do you do something like that yourself? Well, first, you're going to have to install the Codex desktop app.
So that's what I'm going to get to now. Let's talk about installation and also pricing for Codex. All right.
So as you can see here. Codex is included in your ChatGPT subscription. So which subscription should you get?
Now, technically, you would be able to use Codex in a very lightweight way on the free or go levels. But the minimum that I suggest to most people in order to get the latest models and have even a decent amount of usage is the $20 per month plan. If you're on the $20 a month plan, it is very likely that you're going to hit your session or weekly usage limits.
So if you come in here to the Codex desktop application, click on settings and then click on rate limits remaining, you see that it tells you here in the bottom left corner in every five hour window, how much can you use? And then also on a weekly basis, how much do you have left? So I'm actually likely to run out of my weekly.
And that's on the pro plan. at $200 per month. Now, I use Codex extremely heavily because I'm working with multiple coding agents across many projects simultaneously.
But what I would recommend for most of you is to get on the $100 per month plan, which gives you five times the limits of the plus plan. I'm on the $200 per month plan, which isn't listed here, but that's why it says from, and then it's a 20x. And so I have even higher limits.
one thing to note here is that you can also use Codex by the API. I don't recommend that because the subscriptions are giving you a subsidized rate. for the amount of usage that you get.
So choose whichever subscription makes most sense for you. Next, you'll want to install Codex and you'll see here that there's a command line interface and then a Codex app. Now this command line interface is actually mostly open source, which is a pretty cool feature of Codex as opposed to Cloud Code.
But we're going to be focusing on the desktop app, which is both better, surprisingly, for beginners and for power users. So you come over here to developers .openai .com slash codex slash app, and then you can install it either for Mac or for Windows. So I would just click on the one for Mac.
Then once it's installed, it's going to show up over here in your downloads. Double click on it, grab it, drag it. Then say replace if you've already got an old version.
Now you can open it up. You'll see something like this press. Come up.
Say open. Okay. Now there's two options.
You can continue with ChatGPT or enter an API key. You should have a ChatGPT subscription now. Sign in with your email address.
Say continue. There. And then if this is your...
first time in codecs you're not going to see all this stuff on the left or any of these things but it remembers that i had codecs installed before so i get to come back to my previous state all right now before we do any deeper exercises i want to give you a full tour of the desktop application i'm going to go through every single interface explain where it is, what it is, and how to use it.
We're not gonna go fully into detail, but I want you to have at least a cursory overview, and then we'll go more into detail later in the course. So this is what you see when you launch Codex. On the left -hand side, you see different projects, each of which are defined by a particular folder.
If you want to add a new project, you just click this Add New Project button. And then if you, like me, have a projects folder, where you like to keep everything.
You can either have a new folder and create a folder in there, open it up. And now the files and work that Codex does will by default be done just in that folder. And so I can scroll here and I can see that there are different threads here that have been created for a wide variety of different projects.
And then if I want to start a new chat in some project, I just come here. click on new chat. I can choose between my different projects that I have available.
And then I can simply ask codec, make me a Python script to make a map of the United States in a virtual environment. And so now codecs will start working and. the unit user interface has changed a little bit now here we can see the work that codex is doing which includes running various commands and then down here there's an interface in which I can ask for follow -ups or whatnot.
Now we'll come back to this, but I want to show you a few more interfaces. Next, besides this new chat button, we see a search button. So if I wanted to look, for example, in which, where was I talking about making a Spanish course?
So I'm making Spanish versions of some of my materials. And so you can use that to find a thread when you have lots of projects and lots of threads in each project. then this button for plugins is where you can see different plugins which are available in Codex.
You can think of these as capabilities that allow you to connect with external systems or to do things that Codex otherwise couldn't do. So this one, the computer use plugin on which I recently made a video and we'll be talking about in more detail later in this course, is a plugin which allows you to control Mac apps from Codex.
But if you come here, and select this built by OpenAI plugins, you'll see that there are all sorts of plugins for lots of different things. So there's like a Figma one, Google Drive, Gmail, Slack, et cetera.
So we'll be experimenting with some of these plugins later in the course, but I just want you to be aware of them for now. Now, also, if you look up here on the top left, you'll see there's plugins, but also skills. So skills are a concept similar to plugins, but they're...
perhaps more specialized particular capabilities and some skills come bundled with Codex. And so you can see, for example, that there's a skill to create skills and a skill to install skills that comes bundled with Codex.
Now, if for whatever reason you didn't want to have this skill available, you could just come here and choose to disable the skill and then enable it again if you wanted to enable it. Again, we'll go more into detail on what skills are, how they work, how to make them, how they differ from plugins and other things like MCPs and CLIs, which you might've heard of.
Doesn't matter right now. We'll get into it later in the course. And I also have tons of plugins that I've made across many different projects.
So you can see some of them are all in here and you'll be able to see all the skills that you make over time, whether they're for particular projects or general ones that you always want to be available all the time. An additional concept that... codex has is that of automations and so these are literally automations just things that run on some schedule, like every single day at a particular time.
And so for example, at Payslice, where I work as a director of AI and ML, I have a standup summary plugin, which I have run every single day before our weekly standup, just to summarize the changes that have occurred in the Git repository. And this is useful for communicating both to the rest of the team, what I've done in a summarized way, but also for me to get insight into what the other engineers I work with have been working on if I haven't spoken to them recently.
And so you can create all sorts of automations in this interface. Again, we'll be getting into this in more detail later in the course. So if we come back over here to this pane, I wanna show you a...
few more features about what's available in this interface now sometimes to install certain kinds of software maybe you don't want codex to just do it for you codex can do software installation for you and if you want to be able to do it yourself if you're on a mac or on windows option 2 what you want is access to the terminal now In this course, unlike the Cloud Code course, I'm not going to go into the terminal in detail because the desktop app is such a beautiful, amazing interface that you end up not really having to use codecs of the terminal or the terminal very much.
But if you want to use the terminal, there's two ways to do it. One is that you can click this button over here for the terminal, or as you can also see, you can just toggle it on with Command J. And so that's what I'm doing right there, Command J.
That gets me to a terminal and this terminal opens up in the same folder that you're in. And if you go to another one, there will be a different distinct terminal in each project and each threads interface. So there's no risk of them interacting with each other.
If you want to open multiple terminals in a single interface, you can just click that plus button. And so that's handy to have now. The next button over here is for toggling the file tree.
So you can see all the files which are in your project. And if you click on them, you can even look at the file itself. Now, most of the time.
I almost never have to edit files by hand anymore. But in the rare occasion that we do, I don't recommend doing it within Codex. I instead recommend doing it with an external application.
The particular application that I recommend you have installed is Visual Studio Code, which is a very good, very useful external editor. So you just look up VS Code, then you'll have a download, install it. You're all pros at installing software.
I'm sure I don't need to show you how to do that. In order to easily open up a folder or a file in a particular editor of your choice, you need to first have a Git repository initiated in your project. So the way I would do that is just ask Codex, can you create a Git repo for me and make a first commit?
If you're not familiar with Git, don't worry. We're going to be getting into that later in the course. But basically, Git is a version control system which helps you keep track of changes to your files in your project as you work on it.
And Git is both really good to use for a variety of reasons as a software developer or for anybody really working with files at all. But it also... is very helpful for agentic coding tools like Codex to give them memory because they're then able to see all the changes that have been made in a project and that helps them do better work.
And so if you look here at the top right, you'll see that the user interface has changed a bit. There are a few new things that have come up. So there's this menu that has come up now with which you can choose to commit.
push or create PRs or create branches. Again, these are Git concepts that I'll get to later in the course. But you can also now choose to open up this project in an application of your choice.
And so Cursor and VS Code are two editors that I have open. The one that I just recommended you install is VS Code, but you can also open it up in a terminal or if you're building some application, then you can build it up in Xcode or Android Studio. So I'm going to choose to open this up in vs code let's click that and there it is now it's open up in vs code and so this can be a nicer environment it's like more particular to looking through your files and you can customize it with extensions as you like and so for most of you even though i do recommend codex for doing most of the operations that you'll need done having vs code available will be very useful next you'll also see this other side panel available so i can flip it out and In that side panel, one of the things that you could do is to see files.
But there's two other things which are cool to know. There's a review UI. So this helps you see the different changes that have been made in your repo as changes are made.
Can you make it prettier? And so I'm going to ask Codex to fulfill this vague instruction to just make the map look more beautiful. And then we're going to see.
the changes come up on here but they're just going to be the changes relative to what the last change is that we committed is the git term to git all right so we've pretty much talked at this point about the main ui but We haven't really talked yet about this very important interface down here. And there's actually quite a lot going on in this small space.
So let me go through it piece by piece. First, this thing is now making changes. It deleted one file.
And so as you can see, we can now see these changes coming up on the right -hand side in this review user interface. So in this UI, when... codex has finished doing something you can chat with it just like you would chat with chat gpt and so let's say uh i wanted to just say make it prettier after this it would be able to understand that instruction and then try to fulfill it to the best of its ability but there's also some additional capabilities just in this little text area so First, I'm going to just press in slash and you'll see a bunch of things come up now.
These are inbuilt capabilities in Codex, which are neither plugins nor skills. So plugins and skills, as you saw, were these sort of specialized things that Codex has to be able to interact with different external systems or give it new abilities. Everything that shows up when you press slash up top are the default things that.
come baked into codecs. These aren't additional capabilities. And so one of these, for example, is fast.
And so as you can see, what fast basically does is it will give you faster inference meaning you're going to get the responses from codex faster but the cost is going to be that you're going to spend your tokens your weekly limit twice as fast and so i'm going to show you this full settings ui later but as you recall if you click on settings and then go to rate limits remaining you can see what your five hour and weekly limit remaining are so if you choose to have fast on then you're going to be going through your tokens a lot faster you can also do things like see your different mcp servers which are available some of you guys may be familiar with mcp servers if not no worries we're going to get into it later in the course you can also compact your thread which is a way to summarize everything that's been done in your current thread and start fresh again.
We'll also get into that later in the course. You can choose the particular model that is used. So right now I have it set to GPT 5 .4 and there's also a few others.
So that's what slash does. Now, if you do dollar sign, then what comes up at top are the skills. And so these are the specialized capabilities, most of which I've made myself or which.
other people have made and I have installed in my own system to allow Codex to do other specialized things. And so if you want to instantiate or use one of them in your current context, you can use $. Finally, the last sort of shortcut I want you to know about is at.
And so when you use at, it's going to surface agents that you may have installed, but also plugins which are a concept we talked about we'll also get to agents and sub agents later but you can also if you want to reference a specific file for whatever it is you're doing you can reference that file by like going like that typing it in and now codex will know that whatever you say next refers to or needs to include as context that file now in this user interface you can also paste in images or PDFs if you want to give those as context to Codex.
So something I do pretty frequently is we can click this and something cool is that HTML files and images along with PDFs can be viewed right in the user interface. And so what I could do if I wanted is just take a screenshot, drag it right in and say, can you... mark the state capitals as well and you know that instruction didn't really require me to take the screenshot but let's say i wanted to say hey it looks kind of ugly i don't like this map but hey take a look at this map it looks better most of open ai's models and all the ones which are available in the Codex desktop app are multimodal, meaning that they can sort of see images and text.
And so you'd be able to use them in that way too. Now, the last little detail I want to mention is this button over here for voice dictation. So we'll talk about this in a little bit.
later in the course. But if you want to give voice instructions, you can just click that. I am the walrus.
Press stop. And then your very important instructions will come up into the interface. All right.
So we're almost done with the interface. The last main thing I want to talk about is models and tokens. if you look over here you'll see this little dial and that dial is telling us how much of the context window meaning the available maximum limit of a given thread has been used and so it says 25 of the maximum available context has been used we'll get into more detail about what takes up the context window but one of the main things and you can see that it's increasing as Codex does more things is the files it's reading and the messages that we're giving it and the messages that it's giving us back.
The next thing you'll see here is a model selector. So there are all sorts of models and you'll see that some of them are marked as Codex and then some of them are marked without Codex. So what I recommend generally to everybody here is that you just use GPT 5 .4.
It's kind of the best model right now, in my opinion, for any coding task, any task, really for anything other than writing. For writing, Cloud Code, Opus 4 .7 is pretty good. For pretty much everything else, GPT 5 .4 is the best model available right now.
Now, what often happens after a new model release is that OpenAI will come out later with a model that's optimized for coding tasks. And so before you used to be able to see GPT 5 .3 and GPT 5 .3 Codex.
And so I would use GPT 5 .3 Codex to do my coding before 5 .4 came out. For now, I just recommend you use 5 .4. So because it's such an important toggle.
It's available right here in the interface, but you can also toggle it by going slash model and then choosing your model from there. The last bit you'll see here is this button for reasoning effort. And so you can choose to have your reasoning effort at low, medium, high or extra high.
And roughly reasoning effort refers to for a given model, how much time it's going to spend in a thinking stage before. doing something now generally i would say that if you add additional or higher reasoning effort you get better results but it's not perfectly the case and often when i want to get things done fast or i'm working on something simple i'll switch to medium but most of the time i have it on extra high if you're on a 20 per month plan it might make sense to not use extra high that much or stay mostly on medium probably later in the course i'll talk more through strategies on how to conserve tokens if you are primarily using a $20 per month plan.
If you're on the $100 or $200 per month plan, I would mostly just recommend using extra high as your default for everything. That's how I use it. Just a few more comments about these models because you may hear about some of them.
So Mini is a model that I don't really recommend for coding, maybe for certain simple things. And Codex used to have this ultra fast Codex Spark model. Again, I didn't really find any particular use for it, but I just want you guys to be aware of those two as well.
Over here on the left -hand side, you'll see two toggles. One is this plus sign, and then this thing, which I currently have set to full access. By default, Codex will run with default permissions.
And so that means that it's allowed to do certain things in the folder that it's in, but it's not allowed to do things outside that folder. Or it may not be allowed to do things without asking for your permission, such as installing applications or going to certain websites. Now, I usually leave it on full access, which is a little bit more dangerous because now...
Codex can go all over my entire computer and pretty much do anything. But in the next section, I'm going to talk about how to stay on full access, but still make that safer. Not the next section, but in the next few sections.
So we'll talk about the permission system in much more detail, but I prefer having it on full access. It's just a little bit faster. I'm comfortable with it.
So that's where I've got it. And you also see this plus sign here. And so you can add photos and files, just like I showed you adding the photo.
there's also this concept of a plan mode so when you turn plan mode on codex will not actually write files it will read files but it'll make a plan of whatever it is that you want it to do and so this is generally a good practice when agentic coding but my preference for many reasons which i'll talk about a little bit later in the course is to just make plans on my actual file system like not go to a separate plan mode and so if you've got it on you can turn it on with shift tab and then turn it off just by clicking on it i'm going to leave it off for now you can also access your plugins right here so i showed you that you can access them with at symbol.
And over here, you'll see that there's a few different options for how you can use Codex. So you can use Codex on the web. You can send it to the cloud if you set up a cloud environment.
And you can also hand off to a work tree. So I'm going to teach you all about work trees because they are very useful. I'm not going to teach you so much about cloud usage because I don't find it.
that useful and i'll explain a little bit why when we talk about work trees and finally here if you're familiar with the git system one of the main concepts in git is a branch we're going to talk about branches later but just so you're aware you can create and check out new branches from this ui or switch between your different branches that you have available over here so we can actually see this thing got regenerated i guess i gotta refresh ah there and now we've got the state capitals in here that's pretty cool All right, the last bit that I want to tell you about in this interface is the settings UI.
And there's a lot in it that's not that important, but I'll try to walk you through some bits which might be more important. So first, here in the configuration tab, there's a user interface in which you can add some configuration options to. codex and a lot of codex's configuration is defined in a file called config .toml which is located in a specific location on your computer and so if i open it up here we'll see that this is what this config .toml file looks like now most of you will never really need to edit this by hand but it is important to know that it lives in your home folder in a folder called dot codecs so just important to be aware of and you can also in this section make some changes to how the permission system works on your computer again we'll get into this a little bit later now over here in the threads ui you can see that if i click on this i can remove some project if it's not relevant to me but i can also once a thread is not useful to me anymore i can archive it so this is an old one that i don't really need anymore is i can go here and then archive that thread but then
If you ever want to recover an archived thread in your settings, you can come here to archived chats and you'll see all these different chats. You can try to find the one, hopefully by its name or the timestamp or the project name and click on archive to unarchive it. There's also some user interfaces here for Git.
You really will never need to touch this. You can just leave it on its default for. environments i'll teach you about these when we get to work trees again here for work trees we'll talk about this in more detail once we get to that this one for personalization i don't find that important i just leave it on friendly or you can put it on pragmatic up to you and then just some general config options for how you like your codex ui to look lastly codex updates pretty often and when there's an update available you'll see right over here an icon that says update so you just select it press it it'll restart and that'll do an update otherwise you can always go here to codex check for updates and update it from there all right so we just covered the entire interface and you now know enough to get started with codex on your own project just open up a folder start up a thread and then start prompting away but next i want to introduce a fundamental concept that you're going to encounter quite quickly as you get started with Codex.
And that is the idea of a context window and compaction. As I had mentioned, right here in Codex, there's a dial which tells you how many tokens you've used and how many you have left until this compaction event occurs. But let me go into a little bit more detail what a token is, what the context window is and what.
compaction is. A token in the context of agentic coding and large language models is roughly a word. And so you have limits on hominy.
tokens you're allowed to use at a time in a given conversation. And so what counts as tokens? Well, obviously, like if you're giving a really long message, that's going to have more tokens.
And so your actual messages count. But Codex's responses also add to this maximum number of tokens that you can use. But now that we're in the agentic coding world as well.
the files that it's reading are going to count so if it's reading bigger files that's going to use up more of this token limit now codex has access to tools to run commands on your computer to search for code to fetch things on the web and the output it gets from these tool calls are also going to count towards your tokens finally as i've mentioned there are these concepts called mcps skills and plugins which we're going to get into later and the use and the awareness of these tools has some token usage for codex as a default and then finally your system prompt meaning the prompt that codex always has in memory to tell itself about what it is your agents .md which we'll get into a little bit later but is a description that you can create of your project with project specific instructions for codex also eat up tokens and so i've got here 258 000 tokens available in this thread and it says that this compaction thing is going to happen once it reaches that threshold so what is compaction what compaction basically does is take all these things that are using up tools that i just talked about and it efficiently creates a summary with references to some key decisions that were made here and important files so that
Codex can just keep working after hitting that limit, start not totally fresh, but fresh -ish, and then keep going on with new work. This graph here is from Anthropic, and it shows the performance along a measure called mean match ratio. You don't have to understand what that is, but the basic idea is that as we have more tokens, the performance of most of these models gets worse.
over time. The model performance also becomes more expensive as you're having conversations that use more tokens because effectively what's happening every single time you send a new message to Codex is that Codex sends all the previous messages back to OpenAI's API and then sends you a response and adds that on. But there's going to be this kind of pyramiding that occurs as you do this over time where the amount of messages or the size of the message you're sending is bigger and so if you're frequently going all the way to the end of your potential usage you'll see these rate limits decrease more quickly now In practice, what I do is I just let it automatically compact all the time.
So I'm on this $200 plan and I come up close to my limits, but not all the way there. And so I'm making the most out of my usage and I don't feel the need to do this compaction earlier on my own. Instead, I just leave these threads running really long.
And I have various strategies that I'll talk about that I use to make sure that Codex stays on top. of work across long running sessions. But if you ever want to do this compaction early, you can come here and just do slash compact.
And if you have something that you want. codecs to focus on in the compaction, you can say focus on new host hog features. So this is a project I was just working on right now, and maybe I would want it to focus on something in particular.
I can just say that in the compaction instruction. That's basically all I wanted to tell you about context windows. It's a pretty straightforward concept.
You're going to hit this compaction event often, and my recommendation to most of you is just let codecs do the compaction for you that's the easiest way to go about doing things the next topic i want to cover briefly as a fundamental of agentic coding is voice mode now we saw this little voice mode feature earlier when i was introducing the interface and you can use it by just going ctrl m and then saying whatever it is that you want to say and then you can just do ctrl m again and it'll show up here on the screen now depending on how i edit this you may not see how slowly or quickly it showed up, but it was kind of slow.
The tool that I like using for voice input is whisper flow, which costs money. But if you have an academic email, you get three months for free. And there are lots of other free options that are hosted on your computer that people are coming out with to do voice input.
Sort of initial question is why use voice input at all? Why am I emphasizing this as an explicit section of the course? Well, fundamentally, one of the best ways to get better results out of Codex is to give it better context.
So if you're giving more complete instructions with more context about what you want for designing an app or every little detail of how you're thinking about some research problem, then you're going to be likely to get. better results. But when you are typing, you can on average, let's say type at just 40 words per minute, whereas you can speak at 150 words per minute.
So just naturally by speaking as a default mode of working with agentic coding tools, you're going to get better results. So here's an example of the kind of thing that I might myself do behaviorally, if I was giving instructions typed versus giving instructions spoken so the spoken instruction is going to be a lot more natural, but also a lot more effusive.
And so the same person with the same intent is likely to get better results from Codex when speaking right on the first try. Whereas if you say fix the login bug, maybe Codex is now going to ask you for clarification questions, go off in incorrect directions, and use a context which doesn't help you solve the problem. On Whisper Flow, I have control space mapped to the text to speech or rather speech to text usage.
So if I wanted to do the same thing here, I just do that and then I do control space again and it showed up. again depending on how i edit this you wouldn't see it but there was like a five or six second lag when i was using voice mode over here whereas it took about one second for that to show up and that makes me it seemed like a small thing but when you're using these tools uh you get kind of annoyed if there's a six second lag before some action occurs so i would recommend whisper flow if you have the budget for it or especially if you can get that academic discount otherwise there are other free options coming out and the inbuilt control M voice input option is not bad either.
All right, that's it for voice mode. The next thing I want to get to is the permissions system and guardrails in Codex. So one of the things I covered when I was discussing Codex's interface is this thing right here.
You can choose to either have full access or default permissions as the two ways in the Codex desktop app to give Codex permissions over your computer. So what does this exactly mean? What is this sandbox and what is full access?
access and what are the risks with full access to demonstrate the difference let me first give you a little bit of a demo using default permissions so I'm gonna use whisper flow I'm just gonna ask can you look at my downloads folder or actually look at my desktop and help me clean up all the screenshots over there they're kind of like messy I don't like them so I have like I don't know, two years of screenshots, which are all in my desktop folder.
And we're going to see how with default permissions, codex does at helping me clean that up. In order for codex to move a little bit faster, I'm going to tweak down the reasoning and then say to continue. So let's try that.
All right, so Here we got the first sort of useful example to show the difference between default permissions and full access. So as you can see here, Codex was able to run certain commands like ls, which just helps it list files and find, which is a Unix command to help it find files without needing to ask for permission.
But now it's come to something where it actually wants to move files from one location to the other. And so... What it's suggesting is that you've got like 1 .1 gigabytes of screenshot files and I can move them to a location where they'll be sorted and leaving other desktop images alone.
And so two options come up here. One is that I can just approve this action. Second, I can say yes and don't ask again for commands that start with this.
So I'm going to say that I'm going to say just yes right here and then let it move forward. Now, having default permissions on is. very helpful and useful because if something dangerous is potentially going to occur then you can vet the action before codex is able to do that but there is also a cost to working with codex primarily in this way sort of the magic of agentic coding is when you can actually let it loose and be able to work for long periods of time with your hands totally off.
And so setting it to full access, on the other hand, won't continue asking you for permissions when these stages occur. So now if I proceed in full access, I can say, what do you recommend next? So it's recommending a sweep of what remains on the desktop and then stop the mess from coming back.
So I'll say, sure, do that. The issue with full access is that potentially Codex could delete things that you don't want deleted without you having any mechanism to recover those files, for example.
And so one option is to give Codex very fine, detailed permissions of what it can and can't do. And that is possible in Codex. Let me show you how.
On this documentation page for Codex, there's a pretty... thorough explanation of all the different types of configuration options you have at hand to limit codecs on what it can and can't do so here for example you can decide whether to enable full internet access or just have an allow list of particular domains you can also have a deny list for what is allowed or not allowed for Codex to read or write on your computer.
And all of this occurs in a file called config .toml, which is located in a particular location on your computer, which I'll show you in a little bit. There's also a concept called rules with which you can define particular commands that Codex is allowed to run, which go on outside the sandbox where the sandbox for a given.
project, you can roughly think of as being that folder, like a set of operations that it's allowed to do outside that folder. Now, this rules setup is not trivial. It is a pretty complex format that if I was writing, I wouldn't want to write by hand.
I would probably ask Codex itself to help me write this thing. I'm personally comfortable enough with these tools that I just leave them in full access all the time. So my recommendation is to either just use default permissions or full access one or the other.
The permission system, you can dig into it and I'll send you those links, but it can be a little bit complicated, a little bit finicky. And so. I'm personally comfortable with full access, but there is one additional tool that I use alongside full access in order to.
make certain destructive commands impossible for codex to run the tool i use for that is called destructive command guard so if you just search that on google or you can see in the slides i'll have in my school server or in the description below this link you can find this tool and basically what it does is It prevents Codex or Cloud Code, really any agent, from running certain types of catastrophic commands like git reset hard, which is very bad to do on a git repository, rm rf source.
So you'd want to prevent Codex from accidentally deleting some directory or dropping a table in your database. And so if you want to install this tool, you simply... copy this right here, copy, and come back to Codex.
And as you recall, in order to open a terminal, it's Command J on a Mac, probably similar on Windows. I'm just going to paste that in here and then press Enter. And we'll see that it's now active in Codex with this DCG hook.
Now that begs the question, what is a hook? So hooks are an... extensibility framework for codecs such that after certain points in the agentic life cycle some actions can occur deterministically but as you see here this is an experimental feature so in our case what we want is that before any tool is used meaning before any command is run we have dcg run to check if that command is a safe command and if not it rejects that command now In order to use an experimental feature like this, you have to open up this file that I was referencing called the config .toml file and add this line underneath features in your config .toml.
So how do you do that? Well, you come here to codecs, then go over here, go to settings, then come down to configuration, then over here, choose global so that we go to the user configuration and then click this button. for open config dot toml.
So let me do that. Okay, so if you've set up BS code, it should probably open up like this in VS code. And then I recommend doing a control F for features.
There it is. And you'll see over here that I've already added this line hooks equal true. So if you haven't add that, but if you have leave it and then just save it and now you're codex instance will be set up to prevent certain kinds of destructive commands from ever happening in the first place so for me this is a sufficient level of safety there are more complex types of safety that you can add using things like docker sandboxes or simply working on your stuff on a computer which is totally isolated from anything else that could be damaging.
So it's your own decision of what you prefer. Maybe start off in default permissions, but I think that pretty soon you'll get annoyed and you'll want to move to full permissions. In that case, I recommend setting up destructive command guard.
And you can do that all within the Codex desktop app by opening up the terminal right there in that environment. All right. The next topic I want to discuss is the agents .md file.
Now, if you recall back to a previous section, we were discussing how there are all these different things that use up tokens in Codex. One of those is the system prompt, which includes this thing called agents .md. So what is agents .md?
The possibility or the promise of agents .md is that if there are certain types of things that you always want Codex to know about your project, you just create an agents .md file, put it at the root location of your project folder, and then Codex will always read that first before following any instruction that you give in any Codex thread.
Now, there's not just one agents .md file, but actually multiple of them. So typically at your individual project, you might put agents .md at the root of the project. But additionally, you could have an agents .md inside some folder in your project.
And then when Codex goes inside that folder, anytime it's acting in that folder, it'll always read that agents .md file first. And finally, You can also have an agents .md file, which you put in your home directory in the .codex folder.
And then this will be something that Codex always reads in every single one of your projects. So should you always make agents .md files? Other...
AI influencers will sometimes refer to these as the brains of your project. But my opinion is that you actually should never make agents .md files. The fundamental reason for this is that coding agents like Codex have gotten so good that you don't need to really tell them many things about what your project structure is and how to work inside it.
They can usually just infer that themselves. But what often happens is that if you put some set of instructions in your agents .md file, if you're a beginner, you'll often over -specify things that aren't actually necessary to say. And so you'll just be using up valuable context in that agents .md file.
Additionally, if you have instructions explaining your project structure in the agent .md but then down the road your project's structure changes this inconsistency can end up confusing the coding agent and so you get worse results than you otherwise would to test exactly this some researchers at a very prestigious university in Switzerland and Zurich, did a test to see whether agents .md files actually help.
And they compared across some measure of success rate, LLM -generated agents .mds, human -generated agents .mds, and no agents .mds. And what you see is that for the worst models, like GPT -5 .1 mini and QEN330B, there does seem to be... and improvement, especially from creating this human generated agents .md.
But when you look at GPT 5 .2, which is now a pretty old model or Sonnet 4 .5, which is extremely old, there's basically no difference. at all and so that speaks to the fact that as these models are becoming more intelligent there's just less of a need for these agents .md files and in fact it can even end up hurting you here we have an other view studying the same thing but what we're looking at here is whether on these two benchmarks whether using an agents .md helps you satisfy that benchmark with fewer steps and at a lower cost and what you find uniformly across all these models is that these measures are done worse, like in more steps and at a higher cost when you use an LLM generated agents .md or even a human generated agents .md.
Now, if you do create an agents .md, my recommendation is to put instructions based on what... the agent is getting consistently wrong in your project. So use the agents .md as a corrective.
And so for example, if your project uses one more modern library that may be past the model's memory cutoff, then you want to specify that. So for example, if you're using Tailwind version 4, specify that and not Tailwind version 3. Or if you're using...
python 3 .14 specifically to write your code and you always want to make sure it uses that then specify that but the type of thing that would be bad to include in your agents .md is stuff like the database has 12 tables the project structure is data paper intermediate temp Because all of those things might change. Certain types of things that people put in agents .mds actually belong in what are called skills.
And we're going to be getting to that in just a few sections. But before we get there, I want to introduce the five practical primitives of Codex. Now, when we were going over the interface store, I already gave you a brief introduction to each one of these.
But I want to kind of lay a roadmap. and make a brief comparison of these things right now so that you have a broad picture in your head as we go through each of these in detail. So from your perspective, the way you'll be interacting with Codex is through this desktop app.
And so under the hood, it's talking to your computer, it's using command line interface. programs on a terminal but you don't have to actually touch the terminal you could use codex at the terminal if you wanted to but the desktop app is a much nicer much more comfortable interface for beginners but even for me as an experienced user who really likes a terminal the codex desktop app has so many conveniences and utilities for power users like work trees that we're going to be getting into that really it's kind of the best environment for everybody to do agentic coding.
And so inside Codex, there are these five things that you're going to be able to use to expand Codex's abilities, the types of things that it can do. And so one of these is going to be plugins. Plugins are sort of built -in connections that OpenAI and various companies have made to let you hook up to things like Gmail, Google Drive.
fathom linear figma notion all these different programs that you may already be using and be able to talk to them from the codex desktop app itself by just clicking one button to install the plugin an authentication flow, and then you've got access. Now, one of the plugins that sort of deserves its own category is that of computer use, which allows you on a Mac, but soon to come on Windows as well, to actually control your entire user interface with.
codex so it can go and log in for you look at your emails download attachments analyze them all that kind of thing and all you have to do is enable this from within codex now plugins and computer use set up these connections to these tools but you may have much more particular workflows that you use that build on top of tools like Gmail, Google Drive, or Notion.
And so you may have a lot more particular needs. So for example, you may want to take your emails and classify them every single morning according to some heuristic you like to use. So you want to find newsletters, summarize all of them.
You want to block spam. You want to flag some high priority people like your boss or your coworkers so that they come to the top of your attention and especially clients. And so ideally, you'd like to have some kind of automation very particular to you and your workflows and your business and your needs.
That's what skills enable you to do. And so we'll be going into skills in detail. Now, under the hood, what a plugin is sort of doing is making a wrapper usually around what are called MCPs or model context protocol servers.
MCPs are a communication standard that has been established for different AI systems to be able to communicate with other systems. And so sometimes a plugin may not already be available that connects to a particular system, but you'll still be able to connect to it if it has an MCP. or an API, in which case you can build a skill.
Now, the distinction between skills and MCPs is often something that confuses beginners. And so when I discuss MCPs, we'll be getting into that in detail. And finally, a last topic that we'll be covering of Codex's main capabilities is that of a sub -agent.
And so sometimes you're okay working in a single Codex thread, but Other times, for example, if you're doing summaries of a dozen different PDFs, maybe it would be useful for... Codex to be able to parallelize that task that you're doing.
And there are other kinds of situations that you might imagine wanting to be able to parallelize tasks with Codex. And subagents are the tool that allow you to do that. Just on call, you can basically spin up many different instances of Codex and have them attack some problem that can be broken up that way much more quickly and much more efficiently.
So that's the last sort of final primitive. that we'll be getting into. Now, the one of these five that I personally like the best and which I use the most are skills.
And I think that once we get to that section, you're going to learn why. But the one that's really the easiest to use and will get you value right away. And so which is why I'm going to be showing it to you first are plugins.
So we're going to be starting to talk about plugins first. So to start, what exactly goes inside a plugin? Well.
They're basically combinations of the following three. There's skills, which again, we'll get into later, MCPs, and apps, which are connections made from the ChatGPT app itself. And so you might be saying, Aniket, you haven't even explained to me what skills and MCPs are yet.
How do I use plugins? Well, it's actually quite easy. Let me show you how.
So if we come over here to the desktop app, you'll see on the top left, an icon and a little label for plugins. So let's click on that.
And then immediately scrolling through here, you'll see a large series of plugins. So if you use Outlook, you can connect to your Outlook calendar directly from Codex. You can connect to your Outlook email.
If you want to build iOS apps, then there's a plugin to facilitate certain aspects of building an app. So you can come here, click in on it. And you can see what this plugin includes.
And so as I was saying, there's an MCP server here, which is included, which helps you debug apps on simulators. And then there's a bunch of skills here as well. for certain kinds of things which are useful to do in iOS, adopting modern iOS patterns.
I actually haven't tried this out yet, and I'm building an iOS app, so I'm definitely gonna try it out. Let me show you a few more cool plugins. So this one is for Remotion.
If you haven't heard of Remotion, it's a React library that helps you create videos from code. And so if you just install this plugin, This plugin just consists of a single skill, which for now you can just think of as a set of text instructions on how to apply Remotion for this programmatic video creation.
So there's a few more cool plugins that I'm seeing here. So first there's many for financial research to Morningstar, Moody's, and Dow Jones. And I think this one looks really cool.
There's... A Readwise plugin, where if you're using Readwise to highlight different things in your Kindle or on the internet or whatever, you can use this plugin, which this one is just an app, to search across. all of your highlights, everything in your library, anything that you would want to do in Readwise as possible.
Now, the plugin which I want to show you and demonstrate here is the Notion plugin. So if you're not familiar with Notion, it's a software which people use for a lot of personal knowledge management. So I have all sorts of different databases that I've put together.
This is a... database of local newsletters. I used to do some work in the local media space.
And so if I want to set up this connection to Notion, all I have to do is come here and press add to codecs. So let me do that right now. Okay.
I'm just going to say install. Great. It's installed.
And so let's go here to try and chat. And you can see that when you click that button, this thing is already available, but let me get X out of it. And you can see right here it says at to use plugins.
We already covered that. So I'll go at Notion. And let's say how many newsletters are in my local newsletter database in Notion.
And let me put this reasoning effort on medium so it goes a little bit faster. All right. So we see that it's using Notion.
thinking i found a database titled newsletters database which looks like the target the database has a single data source so this is nice and clean i'm running a count now all right so this count thing didn't work because that's actually not available in Notion. All right, so this one is trying to work.
It found the database, but it seems to be getting stuck and saying that it can't query more than 25 newsletters from the database. And so going back to these five capabilities, this is actually a useful instruction. So these plugins are like connections to external systems.
And this experience that I'm having right now with the Notion plugin is probably something thing that you're likely to have too when you try to use plugins out of the hood because they're not super customized and so they don't have all the cases for your particular workflows built in and so if i instead built a skill using the notion api i'd be able to have something much more specific like an instruction that whenever you interact with a database make sure you pass a pagination parameter to go through all the results or initially it was trying to use some kind of count query to count all the records in the database and so instead i would figure out what the right way is to do things and then just have that in the skill instruction that i created all right interesting so it can't get the exact count can you look uh whether the Catskill crew in Annapolis, Maryland is in the database.
Wow, I spelled database wrong. So let's see if at least it's able to find a record in Notion. Ah, so I actually made a mistake.
This newsletter isn't in Annapolis. It's in the Catskills regions of New York and it found the URL. So it's in there.
Do you find anything from Annapolis? And so let's see if it can do that. All right, so it didn't find anything for Annapolis, Maryland.
So let's see if we can add a record to the database. So I'm going to ask it, can you do a search for newsletters in Annapolis? I think there's one starting with Naptown.
Look up its deets and add it. All right, so it found a newsletter. It even found the owner.
on the internet and now it's going to try to add that to notion so that's pretty cool it found his linkedin his twitter the owner website and it says i verified the new notion row exists here so let's go take a look and yeah we see it over here And if we come back to this database, we see that the last record here now includes this newsletter.
So the plugin is pretty handy. There's maybe some things you can't depend on. But if out of the hood, you're using Notion databases, you want to be able to interact with them with codecs.
And apparently you don't care about counting. You just want to be able to add records and retrieve them. Then this is going to work for you right out of the gate.
And so. As you go through here, I think that a lot of you are going to want to try out, for example, the Gmail, Google Calendar and Google Drive plugins. And I recommend that because it's going to be immediate added value to having those integrated.
And there's a Slack plugin. Now, one question you might have is why don't. I use these, you can see that I'm not using these right now.
And in fact, I wasn't using the notion one either. And that's because I've created my own more specific workflows using the notion API directly with the skills concept. So this is prefacing where we're going to go.
But if I search notion here, we see that in One of my projects for Payslice, where I'm the director of AI and ML, I've created a kind of exhaustive set of SOPs for lots of different things we do for managing support cases, emails that come through and triage that we have to do all inside Notion. So this is a much more specific set of instructions that I've developed.
And I have that for email, Slack and Drive as well. But if you don't want to figure out how to do that. right now you want to get started have something useful to do definitely use plugins now something else worth saying is that you can build your own plugins too i consider this a kind of advanced feature that's outside the scope of this course which i'm making for total beginners but i do want you to be aware of this possibility And additionally, you can install plugins that are created by third parties.
And so if you come in here, you can see that right now all the plugins available say built by OpenAI. And if you want to see plugins that are built by other people, you have to register what is called a marketplace. Now, we're going to be getting to this concept a little bit later because for app development workflows or just.
complex agentic workflows, there's a plugin here, which I really like to use called compound engineering. Now, this plugin used to be primarily for cloud code, but recently, they've made it feasible to use natively within codecs as well. So once we get to the part of the course where we're developing an application live, we're going to be using this plugin for this and That plugin has skills, it has sub -agents, and so all of this is going to come back and sort of congeal into one thing, you know?
All this knowledge will be reinforced throughout the course. All right, the next thing I want to teach you guys is about a particular plugin called Computer Use. Everything Codex has done so far has been inside your files and your terminal.
Computer Use flips that. Codex actually opens up programs, reads what's on the screen, fills out forms, and clicks buttons itself. So instead of setting up a Notion plugin like we just did, you could just use computer use to have...
codecs operate in notion itself now computer use is so important that if you look here in your settings menu it's a plugin which has its own tab over here and so if you want to use it you come here to computer use you can click on it you'll have to go here and install it and then you'll have to go through a set of permissions prompts to be able to let codecs computer use control things on your computer but Once you have it, you'll be able to give commands like this, play a playlist to help me lock in.
Okay, that's kind of trivial. Play a game in chess .app. I guess if you want to play chess with codecs also may be useful.
But more importantly is that you can give it prompts like this. build and run my open Xcode project and test it for bugs. So this is going to be a tool, which once we get to the app development part of this course, you're going to be able to have Codex try out the application you made and make sure it actually works like you think it would.
Now, unfortunately, computer use right now is only available on Mac, but. Open AI has said that this feature will be coming to Windows as well. So if you're on Windows, feel free to skip this, but eventually it's going to be useful to you.
And for Mac users, definitely stick around. This is a very useful feature. Instead of staying at a theoretical level with computer use for a while, I think it's just going to be helpful to show you a practical kind of thing that computer use is able to do.
So I'm going to open this up. Say try in chat. Let's work in my agentic config chat.
We're going to work locally. I'm going to say, can you go on X, look up my list of economists, and give me a summary of things they've tweeted in the last couple days I might find interesting. Yeah, so X has an API.
a little bit expensive to use. And so something I'm curious here is Codex capable of doing a search or summary of content on Twitter without using the API? Because if that is possible, then what I could do is make a set of profiles.
And later, we're going to be getting into this. But I would be able to use this computer use plugin to create an automation, which makes a summary for me of tweets from economists that I find interesting.
And what you can see here is that this tool is able to navigate on Chrome. And you can actually see right there that it's actually looking at chrome itself and it's doing this in the background without blocking the rest of what i'm doing that's something really miraculous here that open ai has been able to figure out and configure with computer use so i can go on and you know i'm working on some other things as well like this project here and i can keep working on this project while in the background Codex is doing an analysis of all these different economists tweets.
So this is pretty incredible here. We got in just a few minutes, a pretty complete set of summaries of all these tweets from all these economists that I follow. And if I like click on one of these, it's going to take me right to that tweet.
So that was actually a repost of something and economists. There's another repost repost. Let's take a look at.
an actual post. Okay, good. So it is going to an actual post.
And this is like a relatively recent post. And then it's got some small fun ones. I'm pretty happy with that.
Now, what else could you use this for? Well, one of the things that I have to do at pay slice is I review session recordings like this one of users actually interacting with our application. And I try to see places where there may be having bugs.
Now, that's a little bit time consuming. It's not something that I always want to be doing. And so something very nice is that I'm able to use computer use to automate that as well.
And then I get bug reports directly that involve very detailed analyses of where certain user flows break down. And so this is a little bit forward thinking, but a lot of you may have aspirations of building applications yourself. And computer use is going to be very useful for that.
I've also used computer use to set up my projects in DaVinci Resolve when I'm trying to move certain files onto my timeline. And so I think that this is a direction that just AI is going to be moving in general, especially as the underlying vision models keep getting better. I put out a video recently on ChatGPT's image model, which is absolutely incredible.
And it's part of the reason why computer use is able to work so well in Codex. Now, most of the time, if there's a plugin available and you're a beginner and you don't want to make your own skill, which is coming up in the next section, then you can just use the plugin. But sometimes there are things that plugins won't enable you to do.
And so computer use can be a way to get around them. But let's say you wanted to have some kind of automated workflow, whether with computer use or with anything else. One of the five primitives that I just told you about that you're going to want to use are skills.
So let's get into that topic. So if you recall this figure, plugins and computer use, which we discussed right now are kind of like one click and they get set up right away.
And that's why I wanted to introduce them first, because you'll be able to get immediate use out of them even without really knowing and understanding how skills work. But once you want to have very specific instructions for your particular workflows, skills are the tool that you're going to want to use. So what are some types of example skills that I use myself?
Let me show you. So if you come here to the plugins tab and then click on skills, you can see a set of skills that you can just install right away. So one new skill which OpenAI has recently come out with is this image gen skill.
So you can generate images inside Codex using the new ChatGPT Images 2 .0 model. A pretty common type of skill that I'll have are writing skills that convert from one format to another. So I've gotten kind of bad about this, but for a lot of my videos, I'll have corresponding tutorials on my site.
And I use this skill to take the transcript of YouTube videos and then turn that into a tutorial that shows up on my website. Now, that's not the kind of thing for which anybody's ever going to create a plugin, but it's something that I can make with code. myself to automate a manual workflow here's an example from payslice we have a support email inbox where users can send in complaints and i have a support email skill that i've developed to handle the different kinds of cases that we have but then also create in our notion database a support ticket to make sure that we're monitoring that and then also link to clarity, which is that tool we can use to see user behavior, to actually try to link the user's issue to something that they're actually experiencing in the application.
And finally, here's a very simple one, I have a skill to interact with my WhatsApp. So I use WhatsApp a lot for family and friends. And I can use this skill to interact with and search through all my WhatsApp messages.
You can do this with iMessage as well, with Telegram, with Discord. I have one for Slack that I use a lot and I find very useful. Now, what a skill is often described as is simply just a text file.
And that is a little bit deceiving because rather than thinking of it as a text file, you should think of it as a folder. What does that folder include? Well, one...
it has to always include this skill .md file. It has to have that name. It has to have the .md extension.
This is the standard that is developed in the agentic coding space. Then along with it, that skill may come with scripts. So for my WhatsApp skill or that YouTube tutorial skill, I have scripts that interact with my WhatsApp, that interact with my database, and the skill .md file.
teaches Codex how to use those scripts. Next, sometimes you may have other outside reference documentation. An example of when you may have this is if you have some kind of front end design skill to describe your design tastes or preferences.
Maybe you would have images as references in the references folder, or actually maybe you'd put them in the assets folder, but these are kind of fungible. You can have whatever folder structure here you want. This is just a pretty common way to put it together.
And then finally, In Codex itself, there's a concept here of an OpenAI .yaml file. This is kind of the least important aspect of skills, but it...
is some codec specific metadata that you can optionally add to a skill, which makes interacting with it in codecs a little bit better, a little bit smoother, as I'll explain in a few slides. Now, the most important part of that structure I told you is the skill .md. And so here's what a skill .md file typically looks like.
So it starts with this mandatory section, which has a front matter. And so that front matter is a name. and a description.
So every skill has a name. I have a WhatsApp description. And then the description tells Codex when this skill should be used and for what it should be used.
Then below that, there's a set of instructions on the skill that Codex should follow. Now, when you look at a skill in this skills view in the Codex desktop, this is basically what the name is. And then this right here is a description.
And then this over here is a beautified version of the markdown body of the skill. And so this is a skill that I use to take all my Fathom recordings and grab the transcripts and put them to a particular location on an external hard drive right here, which I can then use and have to always be able to look over all my Fathom recordings.
If you want to see it raw, you can go over here and click open. And now in this view in VS Code, you can now see the skill in its sort of raw text format. So it's got that name and then it's got this description and then there's a skill file.
And you can see here that it says use the bundled bun CLI. So I have a bundled script that it uses to interact with Fathom. And then here it tells it you need to have these API keys available.
These are the different ways in which you may want to use it. Now, something you might be thinking when you're seeing this is, well, I'm not a programmer, so how will I ever be able to make these skills? Well, I am a programmer, but I didn't program any of these skills by hand.
Any of the scripts that these skills use, I simply tell Codex what I want and natural language instructions, and then it creates the skills for me. And so I'm going to give you a demo of that a little bit later in this section. Now, coming back to this slide, you may ask, like, why does it matter that a skill .md file is structured in this particular way?
And why not just put... all the references, the assets and everything in like one single file. Wouldn't that be simpler?
Well, if you might remember, a big part of getting good results out of agentic coding tools is being very particular about what sort of context you're giving them at particular times. And so you don't want to give the tool information. doesn't need because then your context window will fill up.
You'll hit the compaction point and you won't be able to work as effectively. Or if there's irrelevant information in there, it might get confused and not do what you want it to do. What skills allow you to do is use a concept called progressive disclosure.
So when Codex boots up, it boots up. the system prompt, the agents .md, and it boots up all the skills into its context. But the only parts of the skill that enter into Codex's context before you've done anything is this metadata, so the name and description.
And that only costs about 100 tokens, let's say, on average per skill, which... Let's say you have 50 skills, that's 5 ,000 tokens. And since our context window is like 260, 270 ,000 tokens, that's not that bad.
So like that's not a horrible amount of context usage before you've even started doing anything. But the skill .md body might be 1 ,000 tokens, 2 ,000 tokens, maybe even 5 ,000 tokens. And so if we loaded up every single skills, body into the context we would quickly hit our compaction point even before we hit a single message and so that's really what prompted the ai community to come up with this concept of a skill to have some way to allow agentic coding tools to do these specialized tasks but then also be able to protect the context window while you're doing it Another important aspect of skills is where they actually live.
And so not every skill is going to be available or you may even want available in every project. So, for example, that skill that I use to convert. youtube videos into tutorials i have installed at the level of a particular project or repository and so the place that it needs to be located in the project structure is in this dot agent directory and then at the skills sub directory in that particular project.
Next, there are user skills. And so the user skills are skills that you want to have available across all projects. WhatsApp for me is one of those that, you know, from any project in any directory, I may at some point just want to check in on my WhatsApp messages.
And so you would put that. at your tilde which is your home directory in the same dot agents slash skills directory and then finally There are system skills.
So these are skills that come bundled with Codex and are just always available. You don't manage these, but you should still be aware that they exist because you're going to use them, especially these two skill creator and skill installer. Now, as I'd mentioned before, there's a set of skills that you can install just by clicking a button and then installing a skill.
And then once you've done that, once you have skills available, either. through this Codex UI or by installing them from the internet. I'll show you how to do that.
How do you actually use the skills? First, in this composer, you can just put in a dollar sign and then all the skills that are available to you, either in the particular project that you're in right now or your set of personal skills or system skills. will all show up here.
And so you can see that there's five total system skills here. And we're going to be talking about a fair number of those. And so if I go like this and I type in back test, I've now invoked that skill.
And then like whatever instructions I say are going to be interpreted in the context of that skill. Additionally, as I mentioned, for all of these skills, the name and description are loaded into Codex's context. And so if you simply type something in and Codex is able to infer that like that particular skill is what we should be using in this situation, it will autonomously decide without you needing to specify the skill specifically.
to use that skill if whatever you're doing seems to match that workflow. It's not a guarantee that Codex will act at a particular moment and you can have skills that conflict. or it may not be super obvious when to use one or the other.
And so that's somewhere where iterating on your name and really the description can help out quite a bit. Now, what skills are often doing under the hood is they're just helping Codex understand how to operate some script and make it useful for you. So let me show you an example of doing exactly that.
So this right here is a tool called YTDLP. You can use it to interact programmatically with YouTube and a lot of other websites from which you want to download YouTube videos. And so I like it quite a lot.
I use it for doing research against YouTube. I mean, YouTube does have this. Gemini summarize feature.
But oftentimes, what I want to do is a lot more custom. And so what I want to do now is create a skill that starts with YouTube, but then we'll do something fun. Now, if you want to create a skill, the right tool to use here is the skill creator skill, which comes with codecs.
And so the first thing I'm going to say is that I want to create a skill. in this repo, because as you remember, there are different scopes for skills. And so I want this skill to be available just to this project.
But in order to make this skill, it's going to require access to this tool, YTDLP. And so my recommended way for you to install this is using a tool called Homebrew. If you've never used Homebrew before, I want you to go to brew .sh and then copy this right here.
then come back to Codex and then type in command J. And that's going to open up a terminal like this. Then you simply paste that command that you just copied, press enter.
It might ask you for your password. You put it in and then let it install this tool. So Homebrew is a very handy tool to be able to easily install a lot of useful packages that Codex can then use.
Once it's done, I want you to... Copy this that says brew install YT DLP. And then back here in the terminal, just paste that in, press install, and it'll go through an installation process.
That's basically the only reason why I'm going to need you to use the terminal in this course. In the Cloud Code course, I was a lot more terminal heavy because when I made that course, the Cloud Code desktop app was pretty bad. It's since improved.
So if I was remaking that course, I wouldn't have focused on the terminal so much and just stayed in the desktop app. But lucky you guys, you don't have to about the terminal you can stay pretty much entirely inside the app except when we're just installing a few useful utilities like that one so we're back here i want to create a skill in this repo it should use ytdlp i want it to combine with image gen by downloading the transcript of the video and creating a very detailed infographic of the video, something pedagogical slash expository.
So what I want to see here is can we combine a few things together? I want to make a skill. The purpose of this skill is to create some kind of visualization, which helps me visualize what's in a video.
And so if you've got a codex subscription, you have access to this new utility to do image generation. I made a video here that like nobody cared about about this, but it really was mind blowing to me. I made this thumbnail here with this new feature.
Oh, yeah. And one other thing you might notice here that now the UI looks a little bit different. It says five point five extra high.
That's because just I'm recording this over multiple days. And now the. 5 .5 model is out so that's the one i recommend you guys use so it already decided what it's going to call the skill it's going to call it youtube infographic if you had a specific name that you wanted to give it it would do that so let's just see how this goes all right so it worked for six minutes and it's created the skill so let's take a look at the skill itself if you click on it it's going to open up here and let's make this big so that you can see the whole thing is there any way to do word wrap i guess not yet it's coming along right so we got the name description download youtube videos metadata and transcripts with ytdlp and a handoff to this image gen skill so this is important to know that like skills can kind of chain together and that's what i'm demonstrating here then it's got you know like uh some instructions prefer human subtitles when available etc And it also created a reference like infographic brief, I guess, of how to create infographics.
So let's take a look at that. Use this reference after fetching transcript .md and before invoking image gen. Extract these items from the transcript.
So let's just look for a video that maybe I would want done this way and then just try it out. So we're here on YouTube. The original techno biking video.
that's you know well set i spent my entire life trying to be smart but i'm retarded let's do that that sounds exactly like the kind of thing that i would want to create an infographic about let's try it with this video make it funny all right let's see how it works all right so this is interesting created an infographic brief Can we look at that?
General self -improvement audience. It can handle a loud comic motivational style. Use a comedic operations map poster.
The anti -overthinking field manual. Teaching units. Verbatim labels for image.
Yeah, let's see how it goes. I guess an important note here is that he's kind of edgy. Founder of Andreessen Horowitz tweets about this guy a lot.
I like him too. He's funny. But he does say the R word and you're not supposed to say that.
So GPT will not let you include those kinds of word. Cruelty, I guess. Fake statistics and decorative only imagery.
FYI. All right. It's done.
Check that out. So one thing I'll say is that this. Like it's kind of like funny in a cheesy way, or I don't really think it's that funny, but for the purposes of creating this skill, especially if we were making it on like more serious topics, like a visualization of some machine learning topic, or you could even try it out on my own videos.
Maybe that's what I should have tried out instead. It's pretty good. Like it's pretty fricking good.
Now this is kind of coming up in an unfortunately displayed way. But if you look here in the file viewer, you'll see that there's an agent's directory as well in which there's something called OpenAI .yaml. This is sort of the optional thing that Codex will create when it creates this skill creator skill that goes along with your skill.
So what is this exactly? It's basically a set of instructions to give a little bit of extra UI polish specifically in the Codex app. So if you don't have this and the skill shows as its folder name only.
And so, for example, one of the things here that's included is this thing that says display name Figma. And so when I type in dollar sign, you'll see that these are all showing up in like a regular capital case. Right.
And that's because there's these. OpenAI .yaml files in the skill directly that is teaching how to format things. You can also decide if you want to be really hardcore to have little icons that go along with your skills.
And over here, you can have a sort of default prompt that is initiated whenever you use a particular skill. So this is optional. And it's something that the skill creator skill will make for you itself, but something to be aware of if you see this thing showing up in your directory and you don't really know what it is.
Now, I showed you how to make skills, but what if you just want to use a skill that somebody else has on the internet? And first of all, how do you even find other skills in the first place? Well, unfortunately, but...
Actually, it's not that big of a deal, but unfortunately, there isn't like some central repository of all skills. As you see, like these things are pretty easy to make. You can just kind of tell Codex your intent and then get the skill out.
So when skills first came out, there were people making a racket trying to sell skills. I think that's really stupid. There's very few people from whom I would.
buy their skills most of the people who are trying to sell you skills are just taking advantage of your lack of knowledge about this space so now you know you can pretty much make your own skills for anything you would ever want and so me personally i just make pretty much all of my skills i almost never look For Hyade, is there a skill available to do something I want to do?
I just make my own skills because it really is as easy as what I just described. You can iterate on it and there are more advanced ways to think about the construction of skills. But for most of what you guys want to do, you can make a skill almost exactly just like how I described.
Now, if you do want to find some skills, I would mostly just Google. or perhaps look on Twitter for like skill for Notion or something like that. And then if you find a skill, let's say it's on a GitHub repo or in some web page, which has an index of a lot of skills, here's how you would install it.
So coming back here, if you just type in skill, you'll see that there's skill creator, but there's also skill installer. And so let me... find some skill, and then just show you me installing it and then using it.
So this right here is Anthropic's front -end design skill. It's a skill that you can use, and it consists literally of a single file, nothing else, to create front -end interfaces that don't seem generic. And so in the past, I found Anthropic to be rather clawed to be a lot better at design.
Especially when you combined it with a skill like this. Now I actually find Codex to be my preferred choice for design. A little bit outside the scope of this video, but something you guys can be aware of.
Anyway, part of the types of instructions it gives here is to help Cloud Code or Codex or whatever tool is using these skills to avoid certain kinds of things that AI tools tend to do when they're creating interfaces. And so let's copy that and say, can you install this skill? just in this repo.
Enter. So you found a skill, you want to install it. This is how you would go about installing the skill.
You can ask Codex to either install things in a particular repo or at the user level. I don't want to corrupt my other interfaces. So I'm going to get it installed just in this repo.
And so you can see the installer expects a skill directly. All right. So the skill was installed.
It says restart Codex to pick up new skills. So if I go front end design.
I'm seeing this because it's part of another plugin that I use. All right. So I restarted.
Now let's go front end. Hmm. It's not showing up.
All right. So something to be aware of is that it installed it in the wrong location a few times. So first it put it in this skills directory, didn't show up.
And I was like, why isn't this happening? But then I forgot this has happened before. Then I put it in the dot cloud directory.
And then finally, I told it no, it has to be in dot agents. So I put it there. And now it shows up.
And so I can say, make me a pretty website about that YouTube video, make it in the theme of notion, just a single HTML page, and then boot it up in the browser. So Let's see if we can use this skill now that we installed to make an example website about the same YouTube video and see what comes out.
All right, here it is. So haven't told you guys this yet, I think, but Codex has an in -app web browser, which is very useful to use when developing a video. And you can see here that this is like a pretty...
neat website that it's made it's notion themed even included that image that we just created all in this website so you can really expand the set of possibilities here once you just make a little bit of progress at understanding how these tools work and you can see right now it's actually using computer use so it's sort of combating with me to take a look at this website and see if it looks formatted properly.
And so now it's finding, you know, some mistakes in the formatting here, I guess. And this thing over here is codexes or rather computer uses, I think cursor. So anyway, I'm going to stop it right there, but I'm pretty happy with these results.
One last practical thing. If you come here to plugins and then go to skills, if you decide you want to keep a skill, but. you don't want it to be activated to show up right now for whatever reason you can just go over here click this button and then you can disable the skill for the time being so If you have tons of skills, like you shouldn't have this, but I have a ridiculous number of skills, right?
And so maybe I would actually either be concerned about them eating up the context window, or there could be some situation where like certain skills seem to be interfering with others. So I just want to temporarily shut it off. That's something you can do in the Codex desktop app.
So coming back to this chart, right? We've discussed plugins and computer use, and then we discussed. skills.
And what we described a plugin as sort of being under the hood is a skill plus sometimes an app connection. And then also this third thing called an MCP or the model context protocol. So that begs the question, what are MCPs and what are they useful for?
All right. So we've now installed and built some of our own skills and. My general opinion is that by default, when you want Codex to interact with some external system, skills are going to be your go -to tool, but they're not the only one.
And so we're going to get to the next one now, which are MCPs or model context protocol servers. So as the documentation here specifies, MCPs are an open source standard for connecting AI applications to external systems. the right way and like a common analogy that's used to think of them is to think of them as a usbc port for ai applications so what does that mean it means that in the past every ai application would develop its own standard for how Your AI should connect to it.
And MCP has been established as one official standard that everybody uses so that any time your AI wants to connect to external systems, it knows the general method of doing so, which is MCP. And so under the hood, this MCP specification is this technical specification where The server is defined by a big JSON file in which particular tools are made available to you.
Now, you may not know it, but in this course, you've already been exposed to MCPs. And the reason for that is that most plugins in Codex are actually using MCP under the hood. So let me show that to you.
So here's the Notion plugin. And as you see, the Notion plugin includes this app. And under the hood, this app is just an MCP.
And so this app contains different tools such as Notion Create Comment, Notion Create Database, Notion Create Pages. And then there's a set of instructions for the AI system, Codex in this case, to help it understand how to use this tool. Now, under the hood, Both MCPs and skills are working with some APIs.
So if you make a Notion skill, it has to interact with this API directly. And if you want to use an MCP, under the hood, it's often or pretty much always just sitting on top of an API. And so when the AI is taught how to call these tools, these tools themselves are just formatting.
some kind of request of an API. Generally, my advice is that if you have the option of attaching to the same service, either by an MCP or a skill, if you plan or expect to customize your use of it, what you should do is pretty much always make a skill. Now that skill, you can choose to either hit the API directly, which the MCP is hitting under the hood, or you can have the skill actually have your own particular workflows that are built around these different mcp tools now sometimes an application may not give you direct access to an API.
And so in this case, your only way to interact with the external system, since you're not gonna be able to make your own skill, which uses their API, is going to be using their MCP, if that's what they're making available. And so, for example, here in the AI MBA Pro, every single time we have a call, the call comes up here, but then if you click in on a call, You can go back to the call, but also see the full transcript here.
And what I've chosen to do is make that transcript available to AI MBA Pro members by MCP. And the reason I've done that is because it's easier for me as the application developer to serve a broad audience who may all want to do their own different things with the transcript by just making all. the different resources that I provide to pro members, whether courses, tutorials, or call transcripts available by MCP.
And so you can see here that I give agents access to four different tools where they can list the pro resources, search across them, get some pro resource, and if a pro resource is really long, like a transcript, then they can get it in chunks. And so I actually give detailed instructions here on exactly how to set up an MCP in the Codex desktop app.
So let's try following those instructions and we'll be able to use that to understand what value this gives us. So you go up here to Codex, then to settings, and then over here, you'll see MCP servers. So let me click on that.
And now I already have some MCP servers connected. If I want to enable or disable them, the ones that are already connected, I can use this toggle. But here I'm going to say add MCP server.
And you're going to see that there's two different options, STD IO and streamable HTTP, which are available. So the main difference between these two is that this one, STDIO, the MCP server actually lives and is hosted as a service on a port, typically on your own computer. Whereas with streamable HTTP, some other service like on the external web is hosting the MCP server.
Most places are now going to have you go through this option because it's a lot easier for users. And then you may get instructions to fill out some of these fields, depending on how the authentication process works to be able to use the MCP. So I'm just going to go ahead and register with AI MBA Pro.
And then back here in the instructions, this is the URL for the MCP. So I'm going to copy that. And then I'll just click Save.
So if it's your first time using an MCP, what you might see come up here is a prompt to authenticate. I think since I had already registered this MCP in the past, perhaps it's not giving me that prompt. But if you get that, You'll just have to press authenticate.
It'll open a browser window where you'll log in, perhaps go through some permission systems, and then you'll have access to the MCP. So let's come back here to the app and I'll open up a new chat. All right, so I'm here in the app now.
And if you go backslash MCP, you can see the status of your different MCP servers. So we see here that I'm already authenticated with OAuth to AI MBA Pro. also authenticated to this one for some other ones that says auth unsupported.
And so what I'm going to ask now is use the AI MBA pro MCP to summarize the last AI MBA pro call as if I am a Pikachu. And let's see how it does. So it seems to be aware of the cp using ai mba pro searching pro resources okay it found the latest call i'm grabbing the resource details and a transcript slice so the summary has teeth not just title level sparks and so it's grabbing different chunks of the transcript and now it's got a pretty comprehensive summary of the call and so what i'm going to ask it now is can you give me exact timestamps, and exact quotes from the call for each of these points.
Because what I want to see is if it's just picking up the summary on the site, or if it's able to get exact details in there. Hold on the call transcript. No, it's my own call dummy.
That's pretty interesting. So sometimes, you know, the codex model will just be extremely annoying like that. Yeah.
And so that's pretty cool. It's able to get, you know, like exact timestamps based on this MCP and exact quotes. So all the AI MBA pro members can use this MCP server to access all the tutorials, all the different courses that I'm putting in there.
And then, of course, our weekly call transcripts. Now. If you wanted to have your own personalized summary as a Pokemon trainer or just as a person who owns a particular kind of business of the calls, then what you would want to do is create a skill which builds on top of the MCP with your own particular workflow.
So this is a good example of how skills and MCPs can work together. From your perspective, most of the time, you're going to be good with just plugins and skills, which I've already introduced. And sometimes you will have to work with MCPs, which is why I wanted you to at least be lightly aware of the topic.
Coming back now to these primitive capabilities, we've covered plugins, computer use, skills, and MCPs. And so the last one we have is how you parallelize work. in Codex, and that is subagents.
Subagents are parallel instances of Codex. So typically, when you're here in Codex, you're working in a particular thread. This thread has its own context window, and when you reach your context limit, Codex is going to go through this compaction process.
Now, what a subagent allows you to do is to spin up other independent instances of codecs and send to them different types of work that you may want them to do and simply have them come back and report that work to the main thread. And so ordinarily, for example, all of this work may involve going through one or two compaction events.
But maybe you don't actually care for the main work that you're doing. about all the internals of whatever goes on in a code -based exploration. All you care about is about the final result of a code -based exploration as it applies to you.
And so in this situation, it may be appropriate to invoke a subagent to parallelize your work. Some of you may be familiar with subagents in Cloud Code, and you'll see... in cloud code, cloud code spinning up subagents of its own accord.
Codex doesn't work like that. You have to explicitly tell it when you want subagents to be invoked. And so when should you invoke subagents?
I think generally a good but not perfect heuristic is when whatever it is that you're tackling is a clearly divisible task versus a fuzzy task. And so Things like figure out the strategy, fix the app, improve the workflow.
To be honest, these are just generally bad instructions. But for example, let's say you're doing a code review on a code base, which has many different modules. It's an unfamiliar code base to you.
Something that might make sense is for you to have Codex go and deploy a subagent. to inspect every single module and come back to you with a report of how it works. And so if there are six or seven code modules that you need to understand, you can speed up this process with a divide and conquer with subagents.
Codex does come with some built -in subagents. These are a default general purpose agent. a worker sort of execution focused agent for bounded code docs or test changes, and an explorer agent for read heavy code based type questions.
In practice, when you're working with sub agents, you don't have to remember these distinctions between the built in sub agents because Based on the task to which you are applying subagents, Codex will choose the one of these three or the combination of a couple of them, which makes the most sense for whatever your application is.
Now, when you have some tasks that you repeat often, you can create your own custom subagents to be able to use them in a repeatable way. So for example, here's a... Docs reviewer subagent, which reviews docs for accuracy and missing steps.
And here's a set of developer instructions that are given to it. And so these three fields, name, description, and developer instructions are required when you're working with subagents with Codex. There are also other optional fields such as nickname candidates, model, model reasoning effort.
So you should be familiar with these. Sandbox mode, MCP servers, all. things that you've already learned about and skills config to know what kind of skills for that sub agent to have access to and so again just to kind of emphasize the point if you're working on parallel code base research great place to use sub agents if you have independent documentation updates across many different parts of your documentation another great place to use sub agents And I want to even say while implementation continues, but just for code review in general, a very nice trick is to define sub agents, each of which are dedicated to studying a particular aspect of your code and reviewing it.
So you may want to have one which is focused on security, one which is focused on architecture, and another one which is focused on the efficiency of your database queries. That would be a great place in which to use subagents. Now, just like with skills, if you want to use these custom subagents, you need to put them in your .codex slash agents directory instead of your .codex slash skills directory.
And they have to have a particular format called a TOML format. TOML files look like this. And so here, for example, is a TOML file for a Python code reviewer subagent.
So I can zoom in a bit and you can see it's saying prioritize smallest safe changes that preserve established architecture, quality checks, etc. And so these kinds of things may be useful for you.
Now, as a practical exercise using these subagents, I wanted to try to use subagents to understand a code base, which I find very interesting. And that's the code base of the Pi coding agent. So if you're not familiar with Pi, it's a minimal coding agent, just like Codex and CloudCoder coding agents, which has been created by a fellow named Mario Zechner.
And I've heard lots of great things about it. I want to start exploring. experimenting with it and also build my own agents which build on top of it so it's something I've been interested in understanding in more detail for a long time and as you can see here it consists of about six different packages so if I'm coming to this with no understanding of the repo This is the type of situation for which subagents are really appropriate and are exactly the kind of thing that you want to use.
And so let me show you exactly how I would do this. I'm just going to copy this and I'll come back to Codex. Let me just open a new thread here.
I'll paste this in and I'll say clone this out to temp. Then I want you to invoke subagents, each of whose purpose is to create an educational HTML file, which helps me understand the basic idea of each module in this repo.
I think there's like six or seven packages and how they relate to the other ones. But each sub agent should be primarily focused on its own package.
And I know that there's a limit on how many sub agents you can use at once. So I want you to just choose the six or so most important packages to focus on. And so let's see how this goes.
All right, so we can see here that six agents have been spawned. And when the agents... are spawned they get these like funky names i guess of mathematicians but i see all sorts of other ones so we've got russell bertrand russell pascal wagner euclid galileo ramuna john and They've each been given like a set of instructions.
You are working in this directory. You are not alone in the code base. Other agents may write files.
So only focus on this. And so it says these package agents are now running on these disjoint files. And so if we wait a few minutes, we'll get some response back and we'll be able to see what Codex produced.
Now, one thing to keep in mind is that. When you're using these subagents, it's true that they're not affecting your current context, but they are going to affect your usage. And so one of the reasons why Codex doesn't tend to spawn up subagents on its own is that if it did, that would really eat up your usage really quickly.
And so you want to use subagents when they're appropriate. Don't shy away from them because they can really speed up how quickly you're able to do some things. But it is something to be aware of, that heavy use of subagents.
in general will use up your usage more quickly all right so sometimes some sub agents will finish earlier than others so you can see that like some of these finished earlier and it's still waiting for these other three all right it finished so let's check it out not sure if i showed you guys this feature but you can open up stuff like in browsers directly here in the ui actually i did show it to you when we made that website so we've got a guided index for understanding how they all fit together the one screen mental model.
Okay, it says read these six first. So let's start with this one, pi AI. I mean, this is a pretty cool way to sort of get an overview of some package before you even start reading it.
So you see, it tells me the purpose, gives me like a good mental model for the code base tells me some key files to look at the data and control flow. And that even gives me this like code reading path to understand things in a particular order. And so this is exactly what I'm going to do when I want to understand this package in better detail.
And in fact, if you're studying some unfamiliar code base for the first time, this is a really good way to get up to speed. So we've now been through. all of these five capabilities.
You got plugins, computer use, skills, MCPs, and sub -agents. And if you're anything like me, I would probably feel overwhelmed if this was my first time going through all of this material. It all kind of, you know, sometimes you understand a little bit, but then you forget some things.
So, you know, feel free to go back through the course a few times, like pause, bookmark different sections. But what I want to do now is just give you a final broad overview of all of these tools and when to use one versus the other.
So broadly here, oftentimes what's appropriate to do is just to use a packaged capability. So you can use these plugins. In fact, that's what I recommend to you guys.
If you're getting started with Codex is just come to this plugins page, find something that looks useful, press plus, try to use it and immediately get. really great payoffs by being able to connect codecs directly to external systems now once you've been using codecs for let's say a few days or if you just want to get started earlier The next thing I want you to go to is skills.
And so skills are going to be using APIs, but they're really the most important thing that you could keep focusing on. I have a lot that I could say about skills past what I've said in the course. I probably have.
100 150 200 different skills across all my projects some which i use on every project most of which i only use on particular projects and so in general skills are the one that i would recommend you focus on after plugins now sometimes skills may not be able to do everything or And so, for example, it's going to be very hard to have a skill which connects to your Spotify and then starts a playlist.
That kind of thing, or just anything where you need real browser or app control, you're going to want to use computer use. And so I like using computer use all the time, for example. Like here, I'm working on developing a mobile app and I have computer use come in and actually interact with this mobile app and see if things work properly.
And so for that kind of thing, computer use is quite helpful. Now, this is a little bit of a misleading thing because when you need reliable external access, you can get that via a skill. Sometimes the API isn't available to you, like on the AI MBA Pro, because it's easier for me to just serve an MCP because those can be used immediately by people without really needing any additional setup.
And so they're very similar to plugins. In fact, plugins are often just built on top of MCPs. And finally, when in any of this stuff, like in a skill or sometimes even within plugins, You might package in sub -agents because they help you parallelize things, but most of the time, you yourself, just when you see an opportunity to do things in parallel, it's a good opportunity to use a sub -agent.
Now, an open question which we still haven't answered and which is going to kind of guide the direction of the rest of the course is, when would you want to build a full web application? a mobile application? And when might you best be served by instead just making a skill?
Now, obviously, if you're serving clients, and those clients want you to make a web app, or you need to have a website, something to present to the public, you can't tell people, oh, hey, have my skill, and then you can use this API to connect via cloud to my database, and you'll know all about me. All right, you need a website.
But in some situations, it's not so obvious for a particular automation that you want to create whether you should be creating a skill versus an app. So let me get into that a little bit.
So generally, if you're okay with just getting text output as the deliverable of some kind of automation then a skill is enough now if you want some kind of regular visual review or some sort of visual interface in which to see the status of some application on a regular basis and you need to be able to access this from any location then maybe you might need an app because it needs to live somewhere publicly.
If you just need visual review, then as you saw, we can just spin up HTML locally, look at it like I did for that coding agent review, and that might work for you. So this over here is not totally accurate because you can have state, meaning where you were at with a particular application, like seeing your last email that was reviewed.
You can have that live locally on your computer as well. But if you need to collaborate with non -technical stakeholders, they're not going to be able to work with skills, at least yet, until you train them. And so maybe an app is going to be the best thing for you to create with Codex for whatever it is that you want to do.
And so as an example to sort of think through this, and which is going to be the web app, which I'm going to make with Codex Live here, imagine that you'd... create social media content, and you want it to be able to automate the creation of social media carousels, okay? So these are some sort of web UI in which you're creating a image for social media.
The optimal interface in which to work with this may require some visual judgment, fiddling things around, marking a particular social media asset as being done or not. And you can do that all with a skill, Often you're working on a team where everybody needs to be able to interact with this interface.
And so this might be the kind of thing for which you would want to develop an app, which has a canvas, which lives somewhere on the internet, which can store your brand kit and have drafts. And so this could very well live as a skill if you're working on it on your own. But with non -technical stakeholders, you'll definitely want to have this.
as a web app. Now, another common pattern, which honestly, I think will be the one we end up implementing is to combine skills with apps. And so for example, notion is an app.
And if you build a skill on top of it, now you're combining skills and apps. And so similarly, even with an app you build, you might realize that the optimal workflow for like technical and non technical stakeholders to work together is to create some kind of app with a skill.
So one could imagine that you have some kind of command line interface, which works with your database, and then that results in things changing on your web app, which is publicly available to everybody, allows a human to then review what's happening on the web app, but it's some skill interacting via a command line interface with the database, which is designating what kinds of text.
come up on the social media asset, what sorts of images are included on the social media asset, that kind of thing. Now, it may seem that creating this kind of web app is like mind -blowingly difficult. And I'm going to show you in the rest of this course that it's not.
You have to understand some things architecturally, and I'm going to help you through them. You can kind of backfill knowledge over time and mostly rely on the intelligence of these models and these tools to help you build even quite complex applications. Now, one final thing I want to mention just to preface where we're going is that.
Some sorts of things you may want to set up as automations. They're actually quite simple to set up. For example, you may want some kind of social media asset created in your application on a regular basis using some external data that gets loaded or using some kind of search to find information on the Internet, grab it, and then use that to create different kinds of social media assets, let's say for a news outlet.
And to do that, the appropriate tool that Codex has for us is automations. So I'll show you in a later section how to use these automations. But especially as we move out of doing stuff just by ourselves, building our own little skills, working on our own projects, and having to serve other people, something that you're going to have to get familiar with is how to keep track of your work and keep track of different versions of your work.
in a typical software development lifecycle. And so the tool that we use to do this is called Git and GitHub, which you've already encountered many times. Now, Git and GitHub may seem very complex, especially if you've ever tried to use Git manually on your own.
But coding agents... are able to do a lot of the heavy lifting now. And so using both of these tools is way easier than it was in the past.
But it is still extremely important to understand these tools conceptually, because they're going to be very important for creating any kind of web app, it's impossible to do so otherwise, but also to learn how to start doing not just creating sub -agents to do tasks in parallel, but to work on different aspects of a project in parallel.
So that's what we're going to get to next. So what is Git exactly? Well, typically when somebody new to computer programming or who is just...
typically working on Word documents or whatever project, they'll make a change to a file and then they'll save it. And sometimes those applications will give you a way of going back to previous versions, but it's not perfect. You can't go back to every single previous version.
You often can't see the exact difference in whatever files you made between one save versus another save. is a perfect interface for computers and also for humans to be able to see the exact set of changes made at every point in time to every file. So you're able to see a summary of every change which is created by you.
You decide in this summary what to put in here or In the new era, the coding agent is deciding what to put in the summary, but you can also see line by line for each file what change was made at every stage. And this is really important if you're working on anything involving code because you want to know, for example, if some bug has been introduced and you catch it a fair while on, what exact change in the code it was that introduced this bug.
It also gives coding agents memory. So they're able to see what you were working on, what the most recent files are that you've been working on in our project, which ones are older files, because the date modified of a file, especially if you're copying and pasting things around or moving from one computer to another, is not a reliable indicator of the history of a project.
But the Git repository can be that very reliable history of a project, which is very informative. for coding agents. Now, one of the fundamental terms that you'll have to be familiar with is that of a commit.
Committing is kind of like saving, is what I was describing before. Each of these right here are commits. In a commit, you declare what was done by Git, and then Git tracks under the hood, the set of changes that has been done in a commit.
And so one of the plugins that I keep referencing and which we're going to be talking about is this compound engineering plugin. And you can see here that the compound engineering plugin has had 734 commits. So let's click on that.
And so we see here a set of commits that has been created. And so let's take a look at one of them. And then here we can see.
the commit message, which says restate model override at dispatch point. And we can see in this viewer in GitHub, which I'll explain later, exactly what the exact changes were that were made on particular lines in different files. And so especially when you're working collaboratively you want to see exactly what somebody has done this kind of interface and this technology makes collaborating much easier all right what i want to get started on now is creating this web app in git just the beginnings of it to show you how git works in a practical way inside codex even without having much theoretical understanding and what you're going to see is that you don't need a lot of theoretical understanding to get started with git Now, just as context, I used to do a lot of consulting and product building in the local media space.
If you look at a lot of my old content, I have this video here on how to automate a local newsletter with cloud code, for example. And I was featured in this article from Neiman Labs about this concept of local newsletters where individual entrepreneurs are sort of creating local media outlets in their particular areas. And so here's one from a friend of mine, Jast Singh.
It's very successful. And you'll see that he's got like this kind of social media content, these carousels, like 10 Winnipeg events to add to your calendar this week. And so what I want to do with this web app is see if I can automate the creation of these kinds of carousels.
And so I'm going to go here and I say. create start from scratch, or actually let me have it create an existing folder, I'll come here to projects, I'll say carousel automation app, create open. Okay, great.
Let me remove that one. And now I'm just going to describe this project that I'm going to make to codecs. So let's actually use this voice input, I want to create a readme for a new application which i'm going to get started with for automating the creation of carousels on instagram primarily initially but not exclusively for local newsletters or local media outlets who want to create content of the type top 10 events in city so again this is just a very basic framework And I want you to create the readme.
So let me transcribe that and ascend. Alright, so it's created a readme. Let's take a look at it just so you can see what this is going to be.
Again, we haven't created an application. We're just creating this file at the root of the project directory. That describes an initial idea of what this application may turn out to be.
But now what I'd like to do is save this. Like obviously this file is saved on my file system, but I want to save it inside the Git system. Before we use Git, we need to make sure it's actually installed on our computers.
So let me show you how to do that. First, you should have already installed at a prior step this true. brew if you haven't go to brew .sh and install it then copy this command come over here type in command j paste it in and press enter and that will install git next similarly we'll want to install this tool for the github command line interface which codex will use to communicate with github and so you just come back put the same command in here Press enter.
And then finally, you'll have one last step that you'll have to do, which is type in gh auth login and press enter. It'll ask you where you use GitHub. You say github .com.
You should say https and log in with the web browser. Then you press enter again. You come here.
You say continue. It's going to ask you for this one -time passcode. So I'm just going to copy that.
paste it in, press enter, say authorize, put in your password if it requires it there. And now you're authenticated. And so that's going to be very helpful for codecs to be able to automatically do some kinds of operations against Git.
And so what I'm going to ask now is, can you make an initial commit? And so what codex is going to do now is probably look to see if there's even a git repository there isn't and so it's going to use this command git init to initialize a repository you don't need to know that command codex can do it for you once it's done that it's going to add this file to what's called the staging area the set of potential files that are set to be committed and then it's going to commit them so now If we toggle this side panel and click here, we'll see this thing that says review.
And so if you come here, you can see four different options that pop up. There's unstaged, meaning files that are not designated yet to be committed. There's staged, files that are designated to be committed.
And so there's nothing here because we already moved from staged. to unstaged and then there's this one which is last turn which i find kind of helpful and this helps you see in the very last commit what is the set of changes that was made and so since we started at a completely new repository everything here is new now something to keep in mind is that if this is the extent of everything you ever learn with gits with codex you can get pretty far you can just keep committing and once i introduce to you one last concept which is pushing That may be all you need.
There's going to be more advanced things I talk about, like branches and work trees and pull requests. And those are very helpful for a lot of people. But you can also get pretty far just with this level of knowledge.
And so right now, this repository that we've created exists as a set of hidden files on your file system. So let me show that to you. If you go here to the file explorer, you don't see these git files because they're hidden files.
If you look here in this little tool I have that helps you see all the files, there is this folder here under the hood called .git. And inside it, there's all sorts of fancy computer stuff happening that you don't really need to know about, but which does exist. And so it's that .git file that sort of defines this repository.
Now, what I want to do practically is now get this repository on GitHub. So how do you do that? Just ask it.
Can you create a private GitHub repository for me? That's it. And so what it's going to do now is use this tool, gh.
to create a private repo on GitHub. Now on GitHub, you can have either public or private repositories. And I want to have a private repo because I don't want all of you going and stealing my intellectual property with which I'm going to become a trillionaire, you know, selling this software that nobody else obviously can replicate to every media publication in the world.
Lots of social value being created live right here. now if i click this and go here we see now that on github this repository exists and it's the same text that you saw before on my computer but now it's here on github now there are other fundamental concepts which you should use and be aware of and one of these is branching.
So we're going to do this practically later but I want you to be aware of it. Essentially sometimes you may have an experiment or a new feature something you want to try out but you're not sure yet what the final state of this thing is going to be and in this case instead of working linearly in the same history typically on a main branch, you can start a distinct sort of historical state called another branch, which maybe you'll name something like codex slash app brief.
And the benefit of doing this is if you decide that, look, this thing isn't working out, you can always just scratch this branch and come back right here to your main branch where you left off. If you decide instead, hey, this thing is working. What you're able to do is something called a merge where you take all this history and you basically will just append it onto the main branch's history.
And if you're building some kind of web application, what's typical is that you'll have all sorts of branches for many features, but you have sort of a continuous deployment setup. by which on GitHub, when some change is made to the main branch, that triggers off a deployment of your web application. So for now, I just want you to know that this thing exists and you're going to see it in practice, probably in the next few sections.
And so the typical flow, which again, just prefacing what's to come, is that you create a branch. Then with that branch, you make what's called a pull request. So if we come in here to compound engineering, for example, you'll see that there's this thing here called pull requests.
And so these are all suggestions of new features to add to this compound engineering plugin that various people have come up with. And so here, for example, this fellow has suggested, I don't know, some alteration to the plan feature so that option one actually starts work. I guess right now that thing is broken.
And so you can come here and you can see on this branch that he's created fix CE plan handoff inline routing. That's the name of his branch that he wants to put into the main branch. We can come in here and see the actual changes that he's proposing.
So that would be this stage. of reviewing the diff and the tests and then it's incumbent on whoever owns a repository to then merge it into main one more basic feature of git or rather on github that i want you to be familiar with we're not going to use these now but are coming pretty soon are issues.
So when you're working on a project, you may notice all sorts of bugs, or you may have things that you want to add to the backlog of things to do on a project. And so when that's the case, you can create an issue. And so some of these are submitted by various other people.
So here's a pretty shitty issue this guy has made with very little information. Here's a much more detailed issue, which I guess was made by the same guy who is proposing this pull request. And so for us in our course app, a good first issue might be, I want you to create an issue to decide exactly what should be included and not included in this application.
So if I just say this, now it's going to put on GitHub an issue. for this project. And the way I like to use issues on my projects is that they basically become a backlog of everything that I need to do.
So even if I'm working on some academic project, like writing a paper, there may be all sorts of intermediate ideas, little extensions, changes to code that I know I need to do. But sometimes when I'm working on a project, it might be a week, two weeks, sometimes it's even months that you let it sit and then you forget what your current state is of where you are on a project.
Well, GitHub issues can be a really good way of maintaining that state on a project. So if I go here and click this now, we'll see that there's an issue that's been created for this app. And there's all sorts of things here that are being, you know, proposed as things that we should figure out.
So just as a broad overview of what we've learned, we've got Git. It's kind of like a safety layer for agentic coding, commits or checkpoints or saves. Branches are experiment lines.
And then GitHub is the online home for those lines. Pull requests are how you review branches before they get merged in. And then issues are these units of work.
So at this point, we've done something which is quite small but important. We've initialized a project. But in reality, I have no idea yet what I actually want to build.
And so... When you find yourself in that position, what is the appropriate thing to do? Should you just go off, take a long walk and think about things?
Or is there a way to speed up this process with Codex? And so, in fact, the answer is definitively yes. And so what we're going to talk about now is how to use codecs with skills to decide what and how to build things.
A very natural temptation, which many beginners will find themselves in, is they give vague instructions to codecs and then they're upset when their results don't match their instructions. And sometimes it's because the idea is vague in there. head so part of what i'm going to discuss is how do you use codex to think of a potential set of ideas for whatever it is that you're working on but then even when you have a clear idea ideas will have requirements and so you'll have to iron out and think through what you actually want to include and exclude in this idea that you have.
And then once you have your requirements set, his next step is that you'll want to create a plan for the order of operations that you go through in order to attack that set of requirements. And so right now, this carousel automation app, it could mean a lot of things, right? And so first is like, do we want to tackle all of these things at once?
Like that could be pretty complicated. And then sort of substantively, what sort of technology are we going to be using to be able to create these Instagram carousels? Are we going to do it with HTML and CSS?
Will we use some external technologies? Now, if you don't know anything about coding, that's fine. I'm going to show you how we can basically proceed on developing a satisfying solution to this problem, not really knowing anything technical.
about programming. You'll almost basically just be able to give Codex a set of instructions and follow its recommendations all the way through. So the way that I'm going to proceed here is going to be a little bit more brain dead than the way that I would usually do things in that I'm not going to.
interrogate technical assumptions that codex gives me or technical ideas that codex gives me as much as i would with my expertise because i want to show you how you can use codex to build full web apps without having much technical knowledge and sort of relying on codex to help you along there and so for example right there could be like different slides and so do we want to do all of these slides or just some of them like what exactly should go in an mvp do we want to accommodate any given publication do we want it to be just for instagram or also for other formats like facebook which may have yeah different resolutions do we want to have it for multiple users you know that kind of thing so i don't really know yet what this is going to be and so for this that plugin I was referring to the compound engineering plugin is going to be very useful.
So the compound engineering plugin used to be natively available just for cloud code. But recently, it's also become available for codecs. And so there's a set of three steps that you have to do to install this compound engineering plugin.
First, you've got to register the marketplace with codex so you take this you go to your codex app and then you just paste it in and press enter okay so for me this is already installed for you if you haven't installed it yet it will be installed next you install the compound engineering agents so one difference with plugins in Claude Code versus Codex is that Codex plugins don't include sub -agents yet.
And so if you recall this slide on the plugin specification, a plugin in Codex consists of skills. So I'm going to be showing you skills for ideation, brainstorming, and planning, which are very useful in this app development process. Consists of apps, which under the hood are typically just...
sort of formatted connections to MCPs. And then you can have just direct MCPs as well. But what's not included right now are sub -agents and hooks, which are concepts I've described, which are useful, but they're not part of Codex's plugin specification.
And so I expect this over time to change. Codex often just has a different set of priorities than does Anthropic. And so they've been working on different things.
So for now, this... installation is a little bit convoluted, but you just copy that, come in here, enter there, and it gets installed for you. And then finally, install the plugin through Codex's TUI.
So TUI means Terminal User Interface. So that means you got to come in here, type in Codex, then type in slash plugins, select this one, the compound engineering plugin. and if it's not installed you have to install it so i already have it installed so i'm not going to do that right now this might also possibly work directly through the plugins interface in the desktop app i don't know but i just want to follow these instructions directly because that's what it says here now once you install this probably restart your codex instance and then you should see if you type in ce a bunch of skills over here that are available.
And so I'm going to be walking you through some of these. So the one I'm going to start with here is ideate. And this is something that you work on when you're at an idea stage in a project, which is where I feel I am right now.
And so I'm going to go full powered here because I want to make millions and not going to, not going to be relying on some medium model, no mids here. We're going extra high. Okay.
I know I want to create some kind of carousel creation application. I don't know yet exactly what technology to use, like whether to use HTML and CSS or something else. I know absolutely for sure, super -duper fruitily, that I want to use Next .js, Convex, and Vercel.
I'm doing this as a live demo, and I don't want to be seen as some stupid idiot who shouldn't be showing stuff and teaching people things. So I'd like to have a sort of useful slice that, you know, I'm definitely going to be able to execute on. But you can take a look at some other projects I've worked on.
I'm relatively skilled, so I can make decently big things. I want to make something useful here that is going to be able for me to execute. But your usual estimates of timelines are really stupid, so don't believe yourself in terms of thinking that something can't be done in a short period of time necessarily.
And the basic context in which I'm making this, by the way, is for social media content. That should be obvious from the readme and the issue you've already made, but sometimes you can be really fucking stupid. Not you.
Cloud Code usually is, but Codex is really pretty fucking smart. So I actually take that back. Ignore me.
I'm a dumbass. All right. So now I've got this set of instructions started.
And if you recall, you can just click on a skill here. Let's see if that works. All right.
It'll open up in VS Code. So we can kind of take a look at what this ideation skill is that helps you sort of think through and filter through ideas even before you get to. a brainstorming step and so what it does is help you generate and critically evaluate grounded ideas about a topic now something important here is that this is not just for web app development you could use this skill for anything if you're working on a paper if you're working on a website trying to figure out how to improve the design of some interface You can use this kind of skill or just use coding agents in this way in a lot of situations.
And now they've come up with in the process of writing the skill, all sorts of like very interesting ideas that you can read through on how to most efficiently do this ideation process. And so it may not map perfectly to your domain. That's maybe the downside of compound engineering.
That is a very general plugin, but they. that put a lot of thought into it. So I still recommend using it.
So we come through here and it's like doing all sorts of stuff over here. And one thing I did was I just like gave it access to like some of the, I have a skill here called project catalog. And I use this skill to basically help Codex know about the other projects that I have on my computer.
And I like to reference it sometimes if I want to have Codex steal. some concept or something I did well from one project into another project. So I've created this project catalog skill, which has in a SQLite database, all my different projects cataloged.
All right, so this ideation process finished. Let's take a look at what the suggestions are. So there's an artifact, a file that was saved out here, which we can read.
So the suggestion of what we work on here is to build a paste editable. carousel studio for one high confidence workflow a local publisher pastes a list of events generates an editable instagram carousel draft previews every slide edits the copy and exports ready to post images plus caption notes so i found some existing project i had made that like kind of started doing this locally.
And I'd also like found some other projects I have. So here are the ranked ideas paste to editable. carousel studio the first version will look narrower okay one polished template with brand tokens export first no instagram auth that makes sense okay very good so let's say like i'm a technical dummy okay i have no idea what any of that stuff does well i think that it's an interesting enough idea looks like a good idea and so the next thing i'm going to do is if you recall is Looks good.
Can you commit what you just made? Because we want to keep track of these changes that Codex is making along the way. All right, so we've committed this ideation doc.
And so the next step in this workflow is brainstorming. So let's start now brainstorming the first step. I'm just going to type in brainstorm and it'll know by context what it is exactly that I want to work on.
Let's work on one. So what this brainstorming step will do is it'll ask you to go through a set of questions, basically inquiring from you different things that it thinks it's going to need in order to pin down this idea you're working on in a way that you'll be satisfied with. So let's say.
Me doing a live demo for a solo local newsletter operator who has a set of events for which they want to populate the images and text of the events in a way that, let's say, fits their style in a replicable way. Usually they use Canva and they have to take the images and put them into canva manually they also have to figure out based on the event how to format the text to like fit correctly in the window and so like the text has to scale and they gotta put all the details and position them and often they gotta like do this every time well i guess part of what we could do is have a skill which can Work with the app and populate the app's data from the skill.
Should this thing be a first class? Yeah, I think I should be first class. Let's say it can take both structured JSON and CSV or messy pasted text or markdown.
Yes, that makes sense. But we do need some way, even if we don't have a full drag and drop visual designer. of creating perhaps in code the different templates that people can populate yes this all makes sense so we've gone through this set of questioning basically to narrow down the requirements and i was going through this kind of fast but i can read this sort of thing fast and basically you have this conversation with codex to figure out now that you've decided generally what you want to build how you should go about building it like what kinds of things are included and what kinds of things are not and here's where like you know you can use your brain a little bit because codex can't read your brain and so you got to read your own brain and sort of look through okay like where is it a little bit off like little details in sentences you know can make a big difference and getting intent right and so Um, I really don't think that these coding agents obviate the need for thinking.
Maybe they, I don't know if they make it more important, but you still have to think, or you got to think when you're reading some of their stuff. And part of the skill in using these coding agents well is knowing when you can turn off your brain and then when you really need to get it cranking because you've got limited energy.
You want to rely on these things as much as possible, but you got to know when to do one or the other. And I think that's an intuition that just comes with time. All right.
So we've got this brainstorm created. And we can look through it. But like overall, I was pretty happy with what came in before.
And you can see that the way in which it formats it is to have like R6, R7 for all these like different types of things that we want to include in this application. All sorts of acceptance criteria and success criteria and things that are deferred for later. And so, you know, that's pretty good.
But like if I had just said. a codex make me an instagram carousel app there's no way that it could have just like guessed what i wanted so this step is really quite important and so again if we come over here to this side panel and then open up a review we can see the last turn we can see that this is now unstaged meaning we haven't even staged it so let's just ask codex stage the commit or you can actually even just press this button for commit so let's try that include on stage, you can leave this blank to auto generate a commit message, let's say continue.
And then you can choose to also commit or commit and push, which will be the act of getting it on to GitHub. So I'm going to choose to do that. And then what we should see is that it moves out of this on staged area, and then to the staged area and on to GitHub.
No get remote configured for push. Okay, that's weird. Let's try this or push.
Okay, bizarre is a get remote configured. If not, can you configure it for that remote repo we made?
Okay, for some reason, this push button isn't working. I don't really care to figure out why. Can you push for me?
I'm going to put it on low just because that should be a very quick task. Don't need to think much about how to do it. Great.
And so now these changes have been pushed to GitHub. And so if you come back here, you see that the next stage that was suggested is to move to the plan implementation. So we've brainstormed these requirements for what should go in this application.
And now let's make a plan of how we're going to build it. So I'm going to go here and say CE plan, enter. Now, one thing to note is that Codex has its own plan mode.
And so if I come here and I do shift tab plan, you'll see that there's this option to create a plan. I think I talked about this earlier. You can do that too.
I just find it to be not as good as compound engineering's plan mode. And something important is that this plan mode doesn't write out its plan by default to a markdown file. And I really like having that markdown file for some reasons, which I'll show you.
But like one of those reasons is that I want to like, be able to read the plan evaluate it kind of iterate on it and that's much easier if we write it to a markdown file additionally if you look over here you'll see that the context window is filling up and so in the process of building all of this out right we've done lots of thinking or rather codex has done lots of thinking and searching and directions which are not actually relevant for producing this plan or the work that will follow from the plan.
And so if we write out the plan, then we would be able to start a new fresh context window, just point Codex at this plan and say, hey, make this for me, right? Whereas if we're using codex is default plan mode which doesn't create a plan for us it won't do that as well all right so if i open this up right now it's come up with i guess some sort of plan here or this isn't really the plan this is the original requirement so let me come here stated inferred okay What does single app versus monorepo mean?
What is next Vercel image generation? So I just got a few additional questions about this initial thing that's been suggested here. Sounds good.
Will we be able to be precise about pixels and stuff? fitting stuff into boxes with good padding and good ui ux and iterate with this approach like with how we actually make the social images so i'm asking some questions you may not ask these questions in exactly the same way I would.
That makes sense. Are there many different options of how we can render? So you have this conversation.
If there are technical things you don't understand, you ask Codex to explain them in language that you're going to be able to understand. Sounds good. I definitely don't want five.
But I want the 1 of 1 to 4, which is most likely to help me create stuff like this. Let me go back to Instagram and just take some screenshots of what I want to produce. There.
There. Reliably. Okay, so now that I gave some examples, it kind of narrowed in on this thing as being the best option.
Okay, yeah. let's go with that as the plan ty bro is codex a male or a female that's an interesting question while we're waiting for the plan let's ask what is your gender do you enjoy my mixed russian indian accent i don't have a gender you can think of me as just codex a steady text -shaped collaborator okay if you had one what would it be non -binary makes sense i accept that all right so it's creating this plan and then once it's made we'll be able to read through it but we'll be in a good position then to actually get to building this application so something i should say here is that if you go to the file browser you can see kind of a directory structure that's been created and this kind of gets formatted all sorts of funky i don't like it but you can see here that Each of these documents is in a folder.
So we got this brainstorms folder and ideation folder and now a plans folder, which has been created, but which is empty right now. And I really like this. I find it super helpful to be able to see the previous documents and have.
them as part of the repository. And often when you're building some new plan, referencing the prior plans can be very helpful. All right, so the plan is created.
Let's go take a look at it. So click over here. and says implement the v1 carousel studio as a next js plus convex app again if these technologies are unfamiliar to you i'm going to be introducing them in a future section so don't worry um svg plus sharp png export the origin requirements define a solo local newsletter operator who already has event content but loses time manually populating and fitting recurring canva carousel templates here's the implementation a set of requirements scope boundaries so some things are deferred from later so it's basically just kind of like a cleanup step here that's happened on top of the brainstorming but sometimes there's ambiguity in the types of requirements you want so like this kind of thing the output structure that wasn't something in the requirements this is now sort of thinking through what the actual implementation might look like and then over here it's kind of hard to see but there's this mermaid diagram created which defines the technical structure of the entire project sort of defines the different implementation units now okay look do i always read these things all the way through
No, I just kind of skim them. Sometimes I see things that, you know, look a little bit off. And then the nice thing is that code is cheap.
So if you go through this plan, this implementation, and then something seems off after it's implemented, you can always rewind. But I do find doing this plan step to some extent is still quite helpful. So it's something I wanted to teach.
Now, in general, with Codex, everything we've done right now is happening on our physical computer. But that's not the only way you can use Codex. So if I click over here, for example, you'll see this thing that says send to cloud.
Set up an environment via Codex web to enable sending tasks to the cloud. So is this something that you would ever want to use? That's what I'm going to talk about right now.
Specifically, the term for this is cloud delegation. So in a nutshell, what... cloud delegation does is it takes some task and then it runs it in a cloud environment.
So instead of running on your computer, it's running somewhere on the cloud. You still have to review its work, but it gives you the opportunity to shut off your computer and then come back to some work being done. So it doesn't require you to have your computer on all the time.
Now, how this works in practice is that In the cloud, there'll be a sort of isolated environment and what's called a container that'll check out your repo. Let's say from GitHub, there'll be a setup step that installs what it needs.
Depending on whether it needs internet access, you'll have to configure that. The agent will do its edits, run the checks, and then returns a diff. So the important point here is that you are not going to be able to interact with the agent it's going to take this task whatever you're giving it and then it's going to run that autonomously now my general recommendation for all of you is that you be aware of this I think this is going to become a bigger part of agentic workflows, even for beginners in the future.
But I don't recommend that you mess around with cloud agents. The reason is, or rather one of the reasons is, that it's quite tricky to configure. So locally on your computer, Codex has the ability to open up a web browser and see your app, test things, run tests, etc.
you have to configure that all yourself in the cloud. So for example, if you depend on some API keys, you might just have them stored for local development on your computer. But in the cloud, you have to figure out how to manage those secrets.
And you have to figure out what sort of other just general network requests is your application going to have to make. And you have to have some mechanism for permitting the container in the cloud to be. open to your application to make those network requests.
Now, there is a separate sort of cloud version of Codex by which you can enable in GitHub code review on all your code requests. So if you follow this link, which will be in the docs or actually, let me just go to it right now. You can come here to set up Codex Cloud, then go to your settings.
You'll have to link GitHub, but then you'll be able to enable code review. on your repositories and then in the pull request section if you just type in at codex review you'll get a code review by codex of your code you can also enable this to occur automatically now if you have a codex subscription these cloud tasks that i was referring to don't require you to pay any additional api keys so on net that could be a good and useful thing But there is a big caveat, which is that locally you're able to use GPT 5 .5, which is the most powerful current model.
But in the cloud, the most powerful model available is GPT 5 .3 Codex, which is now two generations old. So if you look here, for example. at this pricing table you'll see that you know for the plus plan which is the weakest plan there's a certain message allotment of 5 .4 and 5 .5 locally per five hours estimated but it's just not available for these cloud tasks or code reviews and so my recommendation is that if you want a nice default automated code review What you can use is a sort of default review skill that already exists in Codex.
So here's how it works. You just type in slash review to run a code review and then your comments will show up in line. So if I type in slash review there, we see that this code review thing shows up.
I also in the compound engineering skill have a separate code review skill that's also available to me. I find that skill useful because compound engineering team. Every's team has designed some useful sub agents to do specific types of code review in parallel.
But my overall recommendation is that you be aware of this idea of cloud delegation. It's something that shows up visibly in the codex application, so you shouldn't be confused by it. But it's not something that any of you are likely to need right now.
Now, just to preface where I think the. industry is going kind of the dream is to be able to just send off tasks to agents and have it done without you needing to manage in a given thread how they are actually working on it and so i think that's a direction in which this is going and there's a few ways in which this is happening so there are other tools like devon which are doing something similar to what this cloud agent features does But if you're paying for them, you got to pay for API pricing right out of pocket.
And so there's one developer I respect, Ryan Carson. I follow him on Twitter. And he's told me he's using Devin to run a one -man startup, but he's paying $2 ,500 to $3 ,000 a month just on API credits.
Alternatively, there's other projects for orchestration like OpenAI Symphony. It's a little bit more... complex i'm looking into this right now myself i think it's a very interesting project but it's not something that's going to be relevant to you guys as beginners and so what we're going to be working on with this creator carousel studio idea that we've planned out is all something that i'm going to do locally on my computer but while we've created this plan we still haven't yet divided it up into distinct units of work to conduct.
And giving your coding agent some way to know what the distinct units of work there are to do can be very helpful for it to work effectively and helpful for you. to be able to remember the context of what exactly is going on in a given project. So the next thing that I'm going to talk about is a tool to facilitate this called GitHub Issues.
So at this point, we've created this fairly extensive plan. And within the plan, there is some division of work that's already been created. But if you leave this project for a couple of weeks and then come back, you may forget that this plan was there.
And so it may be unclear to you, especially if you have multiple plans, what the next thing is that Codex should do. And for this, issues are going to be very useful. This, for example, is the repo of the fintech at which I'm the director of AI and ML.
And if you come here to our issues board, you'll see that we have a bunch of new things we want to work on, a bunch of bugs that have been identified. And so something very nice is that if there's a lack of clarity on what the next most important thing is to work on next, I can simply point Codex at this list of issues using the GitHub command line interface, and it will be able to pick up easily the next unit of work.
And so we've done this step of planning the work. Now what I want to do is divide the work into distinct issues, and then will actually start implementing this application by handing off to Codex.
Having a system like this, you don't have to follow this exactly. Even I don't follow this exactly. I have my own more advanced deviations.
But having a system like this lets you avoid the problem of, oh, Codex or Cloud Code. just forgot something on the plan because you've already sort of divided it up and given codex a way to keep track of everything that needs to be done and is being done so roughly like this is the anatomy of what you would want to put in an issue this is how it would work for a human developer too like if you give somebody a task and you don't tell them how to verify it that's not a very good task and generally when you just give codex the task of breaking up a plan into issues, it will naturally work in this way.
So to demonstrate that, let's go here. And let's say, I want to create a set of GitHub issues from the plan, I want you to outline using github tools the dependency structure between them and if you see any good opportunities for parallelizing work in orc trees let me know and let me even just take a screenshot of this as context for github on how i want things done or rather for codex all right so this is done we have a bunch of issues here which have been created so these are like distinct units of work and one of the things that i asked but i didn't describe was this asking about parallelizing work and work trees so one feature of codex and git in general is a concept of a work tree which allows you to parallelize work and we're going to be talking about that in one of the next sections and so before we even get there i wanted to tell that to codex so it thinks about these issues and documents their dependency structure in a good way so that if there are opportunities to parallelize work i and future codex is aware of them so let's take a look at one of these for example this is the issue to scaffold the application and it marks out which future tickets or issues are blocked by this one and it's been created with this structure that we sort of described
Because not all the details here are in the issue, there is also a reference to the plan. So that'll be useful to future instances of the coding agent after perhaps a compaction event. So I'm pretty happy with this for now.
I think the only thing left for us to do is commit the plan. So I'm going to say commit and push. the plan.
It says right here, the local plan file under docs slash plans is still uncommitted. So now when we get to the work, we're going to be relying on and heavily referencing these issues. But issues also pair well with a Codex desktop app feature.
which I haven't introduced to you yet called automations. So I'm going to get to that next. So in a nutshell, an automation is just a recurring task which exists in Codex.
So you click over here to this automations tab, and we can see some automations that I had put on pause, some that I have going on every single day. And so this one, for example, stand up summary, it takes a look at. one of our git repositories and it sees for different developers what sort of work they did and gives a little bit of a summary of the work that was done so yesterday apparently i was the only one who did any work and so that's what's documented there now you can set up automations for all sorts of things if you go over here to automation and then click on new automation you'll see a user interface that shows up that looks like this where you can have an automation title and then add a prompt and these prompts can basically be you know human prompts you can choose what project they work in what time they should run at you can choose the model to use and the reasoning effort to use when you use that model and then importantly you can choose whether it
runs locally meaning it runs directly in the selected project directory without creating a work tree it runs in a work tree or it runs in chat so again i haven't introduced work trees yet so that might be a little bit of a confusing topic we'll come back to this work tree automation idea when we come to work trees again but if you want to have ideas of what sorts of automations make make sense you come here to feasible and you can see that you know a lot of these automations like this one i picked out came you know straight from this automation template and a lot of them are very developer focused But one which is quite good over here and which is related to what we're doing right now is this one to triage new issues.
So this issues board right now, we generated issues ourselves, but you can also think of either external systems or external stakeholders, non -technical people on your team who are finding issues and putting them on your board. And then you may want to have some way of automating which ones you should be tackling next. And so having an automation like this could be quite helpful.
Now, there are two general automation shapes with that automations menu that I was showing you, we were looking at project automation. So these are sort of standalone, you define them as an automation in that menu, and then they are related to your project. But you can also have automations that get spun up.
for a specific thread. So the situation in which I might do this is, let's say I'm in a thread debugging some persistent error, which has been occurring, and then I make a release. So I release a fix to that bug, then This thread automation can be helpful on two dimensions.
First, it can keep track and watch the deployment of the new version of the web application to make sure, you know, checking every few minutes that it actually deployed. Second, if you have some kind of central location where your errors are being logged, then you can have an automation in that thread, which is just checking that central location to see if users are continuing to experience this error or not.
or if you fixed it. Now, when you make these automations, it's incumbent on you, just like how I was talking about cloud environments previously, to make sure that Codex is going to have access to everything it needs to. execute whatever you're asking it to do with that automation.
And so one of these things that it may need is permissions, for example, to access the external internet. And if you're using Codex with default permissions, for example, then it's not necessarily going to be able to or just won't be able to access the external internet. And so even GitHub issues might be restricted.
Codex has recently run or come out with this new auto review permission setting. And if you set that on, then it uses a tool called auto review to decide whether. something other than the sandboxed permissions are worth giving your codex tasks so it's kind of like codex checking codex i usually leave it on full access that might be a little bit dangerous but as i described earlier i feel comfortable with full access when combined with codex's hooks system and destructive command guard and so when you're on this automations page there's not going to be a separate permissions picker it's just going to inherit the configured access that you currently have in that project.
But even separately of permissions, certain jobs can fail if you don't set up the right environment variables in place. So for example here, this one was meant to check for one of my projects, the production server, and look for errors and report to me any errors that have occurred in the last day. And what we see here is that this failed because some of the credentials it needed were present.
But then there were some other credentials that it needed which were not present. And so something you want to do if this is a mission -critical automation is you actually want to test it out. Can Codex see that project?
Can it use a required plugin or skill? You can reference skills in your automations. Can it access GitHub or the needed network resource?
Does the output match the shape you want? Can it finish without asking for extra permissions? So you can trigger these automations manually and you can make these automations just by talking to Codex.
And so if we come back here, for example, let's make an automation. I want you to make an automation which triggers at... 10 a .m.
every morning and in a new work tree or in a new thread and tells me which GitHub issues to prioritize for today. So with just that verbal instruction, Codex should be able to create an automation. All right.
So this one got created. Let me see if I can click on it. Yeah, right here.
So it says. daily carousel issue priorities review the open github issues for this and tell me which issues use the implemented dependency structure already captured in the tracker issue all right let's click on this for show automation we'll come over here to automations so we see that this is in carousel automation app it runs locally not in a work tree i'm going to explain work trees later it uses gpt 5 .4 and it uses medium so i can modify all of those can you trigger it manually right now let's just see what it would do or actually i can just go here and then i should be able to come back here and just press this button to run it now so let's try that okay so there it opened up a new thread that's what typically happens for an automation and then let's see what happens Alright, so it was able to access this and gave me some of the top issues to work on today.
Nothing here is surprising, but let's say you were working in a collaborative environment where there were many people taking off issues on their own, or you just wanted to have some kind of refresh every morning to know what the status of a project is. an automation like this would be helpful all right so we've made this plan we broke it up into issues and then i introduced you to this new feature of the codex desktop app automations which you can use to interact with your backlog of issues but really do any kind of automation that you imagine so i primarily use it for developer tasks but you could also use it to scrape some website go on twitter with computer use which you know about look at something make your own personal feed or newsletter whatever you want i'll probably have like a more dedicated video on some of these automations in the future what i want to talk about now is the technological stack that we are going to be using to build this application now
Every web app has three layers. There's the front end, so that's what users see and click. There's the back end, which is where the app stores and changes data.
And then there's hosting. It's like how the app gets onto the Internet. So you can have a functioning front end and back end, which you just host on your computer.
But then you have to have some provider or providers who are helping it get on the Internet if you want other people to be able to see the application. And so broadly, the way that we're going to implement this is the following. You're going to be here not writing code with cloud code.
That's an old slide. You're going to push it. to GitHub, which is going to store your code.
That's going to auto -deploy to your hosting, which is going to be on a service called Vercel, which I'll introduce to you. Users will visit their website. What they are going to see is this front end called Next .js, and that front end is going to read and write data to Convex, which is a database which will be hosted on this organization's own servers.
Now, that may all seem like quite a lot to get your head around. And I completely understand and respect that, especially if it's your first time building any kind of application. What I'm going to hopefully show you, though, is that you don't need to understand this at a deep level of detail.
Hopefully, the idea is intuitive that look. There's some data being presented that data needs to live somewhere. And all this like stuff needs to be hosted on some computers, which other computers know that when you go to my website dot com, it's sort of like all referring to this set of servers that you've made.
And so as you get confused on this. type of topic, you can always use the coding agents to explain it in terms that you will understand, use repetition, but you can also push forward quite far with building web applications without having a deep understanding of all these pieces under the hood. So again, to repeat, our front end here will be Next .js, our backend is Convex, and our hosting is Vercel.
So the reasons for this is that this thing, Next .js, is an extremely popular front end framework. Convex is a very nice database, which you can define fully in the same programming language that you're using to define the front end in Next .js TypeScript. And it has a lot of convenience features that make it very nice to work with as a developer, but also very nice to work with for agents.
And finally, Vercel is... one of the biggest sort of cloud hosting providers. It has a pretty generous free tier and so does Convex.
So you're going to be able to host reasonably substantial web applications for free. So again, like when you're using Codex, you could just say, build me a web app and... It's often going to make like Next .js and Vercel as sort of common technological choices.
Convex is one that would pin it down, may not be the default it will go for. It'll usually go for something like Supabase or Firebase. But the point here isn't to master this whole stack, understand all the details of Next .js, Convex or Vercel.
I could do five hour courses on each of those individually and not exhaust everything that there is to know. You just by saying these words are giving Codex some constraints around what it's going to build. And so that's what we did in the creation of this plan.
Now we'll have a good idea of what it's going to be doing. So again, the reason for Next .js is that it's very natural fit with Vercel. common enough that Codex has lots of examples and is just a front -end framework.
There are other ones that are good to use too. Astro, Byte, I've used them. They're all good.
Convex, in addition to what I mentioned of being in the same language as the front -end, is going to have a lot less SQL or migration friction because it's a no -SQL database, meaning it doesn't have a strictly structured schema. And Vercel just makes deployment of your web application super easy. So you just have your local code, you push to GitHub, and then if you set it all up in Vercel, it'll deploy to a public URL where you can test out the application very easily.
Now, in order to even get started with these three, we're going to have to do a few more installation steps, and then we'll be ready to actually start building the application. The first thing you'll have to install is Node, which is the... package manager for all sorts of packages that you'll be importing when you're building this application so you guys are pros with brew now you know the drill you just copy this brew install node come back to codex command j paste it in enter next you'll have to sign up for an account with convex so they have as i mentioned a pretty generous free tier with almost all the features at the pro tier has i'm on the pro tier obviously you don't need this business and enterprise tier but you just come in here to start building click on that again and then if you don't have an account you come here to sign up you can say continue with github or continue with google i've signed up with github so i'll go there to continue with github and then i'll
You'll reach a page that looks like this. I have a bunch of personal projects, some client projects, all in this space. Yours will look empty because you probably don't have any projects yet, but this is what you'll reach at.
Finally, you'll want to come over here to Vercel at vercel .com. Go over here to sign up. You're working on personal projects, so just stay on the hobby plan.
Joe Schmo. Go to continue. Choose your account.
Log in and then you'll reach a page that looks like this. So this is a lot of my projects all located in one place. I'm on the pro plan, but you can be fine on just the hobby plan.
Lastly, you'll want to install the command line interface for Vercel. So this allows you to do everything that you would want to do in Vercel's system programmatically. And what you want to do is come over here where it says PNPM I -G Vercel.
Don't. copy the p just copy the npm because that's what we installed it's a little bit confusing i know but forget it come back here just paste that in press enter and it's going to install this command line interface globally, which you'll now be able to use to do all these Vercel operations.
So this puts us in a good position, we now have everything installed that will need to be able to work on this application. So what I'm going to do next is just have codecs work here on issue three. So I can go here and say start working on issue three on a new branch and so what it's doing right now is scaffolding this stack that i just described to you the front end the back end some necessary directories and My hope and what I want to show you and what I'm going to try to do is to pursue building this application in as minimally a technical way as possible.
Now, while Codex gets started on scaffolding this application, I want to introduce you to this topic that I've been talking about over and over for the last, I don't know, 20 or 30 minutes, work trees. So what are work trees? Typically, when were working like we just did right now you're working in a single repo folder and then you can switch branches inside that repos folder so that's what i just did right to scaffold this application i said hey codex start working on issue 3 check out a new branch and then you know get on it but let's say i had reached a point of my project work where a lot of the work could be done in parallel well If I'm working on physically the same set of files, they're going to be, you know, overriding each other, conflicting with each other.
It could be a big pain. And so work trees let you create just independent workspaces with your exact same repo where you can be working on features side by side simultaneously. And so let's say we had an editor shell, image specs, a brand kit model, some of these things.
depend on other ones, but some of them can be pursued independently. And when we have that opportunity to pursue something independently, that lets us speed up the rate at which we can do our work. And so when you come here, and you make a new chat for this automation app, for example, when you're selecting where to run the task, you can choose to either keep working on it locally so locally right now we're on this branch and you would be fixed to be on this branch or you can check out a new work tree so the place where work trees actually live is in your codex home underneath work trees.
So this is kind of small, but hopefully my editor will make it visible. I'm here using a tool I like for file exploration. So there's my home folder.
And then here's the dot codex, which is in home. And then over here, you can see this thing called work trees. And so if we click in, we'll see that there's all these work trees here that are being created.
There are these like four digit prefix things. And if I kind of scroll through them, we'll see that there's basically entire different projects which have all been copied into these distinct work trees so i have a bunch of different projects i work on and different versions of them like entire copies are all kept in this work tree configuration you can also see all the work trees that you have available in your settings in the work trees navigation and you can see by project like all the different work trees that you have alive right now if you click on this git tab over here you'll see that there's a few configuration options for automatically deleting old work trees and the auto delete limit so the idea here is that if you're creating an entire copy of your project directory, that's going to take up space.
And so if you just let these work trees live forever, then that's going to be taking up a lot of space for quite a while. And so it's a good practice, and I recommend you can tweak around with these settings, but you should just allow Codex to clean up work trees itself. When you create a work tree, it will start in a status called detached head, meaning it's not necessarily associated with any named branch, even your main or your master branch.
And so you can just keep working on it. in that status. Or what I typically do is I'll create a branch for whatever work I intend to do on that work tree as I'm working on it.
Now, as I'm getting into this, like I'm getting kind of technical and there's no way getting around it. Work trees are a little bit of a technical topic. I like using them.
I find them very useful. But if you're a beginner, you don't have to worry too much about this material. However, it's.
a pretty big part of Codex. And as you get advanced, it's absolutely critical to understand this and build even far beyond what I'm describing right now, because work trees are what are going to allow you to get to that next level of more and more autonomous work. Now, something important to point out is that.
Work trees need environments. So when you make this copy of all your files to a work tree, only the files which you're actually committing to your repository are going to be included in that work tree copy. What types of things do people typically not commit to their repository?
Well, if there are any environment variables, secrets, passwords, which need to be in the repository but not actually committed, then those will not get copied over to the work tree. Or if there are packages that you are installing inside the repository, say in a virtual environment, but then... You wouldn't want to commit those to your repository because they're very heavy and bulky.
Well, when you create your new work tree, it's going to have all your code, but it will not have the packages installed in the work tree. So you need to have some kind of boot up process for creating this environment. And so there's a concept in Codex of environments.
And so if you go back to the settings, you'll see this tab here called environments. And you can see that for, you know, pretty much every single one of my applications. applications, I have an environment available.
And so what is this environment .toml file actually look like? Well, I keep mine pretty simple. All this environment .toml file has is a file that's called scripts slash work tree slash bootstrap .sh.
And anytime a new work tree is created, the first thing that happens is that this shell script gets run. And so if I was making one for the creator carousel studio what i would create is in dot codex slash environment slash environment dot toml i would have a file that looks like this and then in a scripts directory i would have this bootstrap script now what this bootstrap script does for me is it basically looks for any dependencies at the root that need to be installed it looks for any secrets at the root folder for like the main work tree and gets them a local version into the individual work tree and it also makes sure that any ports for this application don't conflict across work trees and so the typical workflow which will then occur is you make some changes in a work tree, you create a branch in that work tree, you commit and push, and then open up a PR, a pull request, a request to merge the work in that branch into the main branch.
And so you're able then to be working on multiple features at a time, which may have some light conflicts with each other, but you can sort of worry about resolving them later, but you do have to resolve them. If two work trees are editing the same file, sometimes even when they're working on the same file, the additions they're making to those files could be such that they don't actually conflict.
But sometimes one PR changes the foundation underneath another PR. And so when that occurs, it's sort of incumbent on you to think, okay, which ones of these should I merge in first? And how should I manage the conflicts between these PRs in order to reconcile them?
Now, Before agentic coding, like this is something that people did quite often, not with work trees, but collaborating between different people on big teams of developers. And it was a mental exercise that they had to sort of go through line by line and figure out, OK, how am I going to resolve this?
But now we have access to this super intelligence that can do this thinking for us. And so. It's not as much or it's not a huge cognitive cost to reconcile these inconsistencies with work trees or think about which one should be merged in before another one because the agentic coding tools themselves can help us with that reconciliation.
And so if I was like giving human instructions for how to handle conflicts, you would keep each work tree tied to one issue. Avoid assigning the same files to parallel tracks or like choose your work trees based on the opportunities for parallelization, which is what we tried to set up when we were designating the issues.
Merge lower risks PR first. But then like, again, if you have any confusion about this or you're struggling to get it set up or there's some sort of weird error that's occurring, just ask Codex. It'll solve it.
It's really fucking smart. now if two changes need to be designed together like you're designing i don't know like the editor for this canvas for this application and then you're also want to design like what toggles are on that obviously you can't design those on parallel so you're gonna have to stack those as like separate PRs or like one will have to be built first before you can start work on the other.
And so for the rest of this course, we're getting close to the finish line. Now let's actually see it through and build this application. So it went and did the scaffold of, you know, and OK, and I'll also be actually implementing these work trees where I see the opportunity arise to implement them.
So let's take a look here. So that's running. And so one of the nice things here is that you can actually open up things in this web browser and you can use later this tool called browser use to control the NF browser.
So this is like just a sort of outline, but it looks pretty nice to start. Like it's a pretty good starting point. OK, so I'm just going to say it looks good to me.
Create a pull request. All right. the pull request is opened so we can click this button to take a look at it and we'll see that here i of course i wrote this all by hand i would never use ai to write a pull request copy never do that it's very unethical yeah and so wow built with compound engineering even got they're really sticking out their property here okay so again i'm a dummy i'm not calling you guys dummies but i don't know anything technical So the goal here is to build this with like as little brainpower as possible.
So you come back to Codex and then you say, looks Gucci, please merge. And it's very important that you use these particular words, Gucci and PLZ doesn't work as well. If you say P -L -E -A -S -E, Codex responds well to that.
All right, so we look here and we see that this has been merged in. So if I refresh now, there's no more pull requests. The number of issues has gone down by one.
If you click on this pull request thing, Jesus, GitHub's been having a lot of issues. You can see now that it shows up as closed rather than open. So let's come back here and let's just ask Codex now.
Great. What should we work on next? All right.
So it's suggesting start with four and then the fun split opens up. Five convex persistence in one work tree, six SVG and sharp render spike in other work tree. So we've been working consistently in this one thread.
I'm going to open up here, go and start a new work tree anyway. Let's go high powered. Start.
Working on GitHub issue four on a new branch. Boom. So you can see there's this work tree creation process.
Right now I haven't set up any environmental toggle, so it should occur relatively fast. All right. So the branch got created.
It picked up issue four and it's going straight to working on it. Okay. So this got finished after.
6 minutes and 23 seconds. So again, we're taking a YOLO approach to this. So let's just make sure first, can I start this up?
And can you, let's say, use concurrently to document how to start up convex and Next .js simultaneously? Okay, cool. Can you start?
it up now and let me see it in the in app browser okay so we're able to see it in this work tree now in this in app browser i guess this is going to be like some kind of template that we'll be using later question or actually let's just say do okay and can we make sure those environment variables will be on the main work tree or can we have some sort of environment bootstrap in this repo as part of this pr so i have a skill to basically automate the creation of those bootstrap scripts for prs that i was telling you about so let's make sure that That's going to be the case so that we have this environment created.
All right. So we got these shenanigans made. We got a secrets file created.
And then if you recall this environment .toml concept that I talked to you about and having a bootstrap file that it runs, that's all created. Let's just say this is all good as is. Can you kill local port so we can run it here?
Something that happens when you make a web application is that the web application, when you test it locally, has to be running on some port on your computer. So you boot it up and then you can test it out locally. And what we're...
doing here is clearing the services which are currently running on the port run it for me brother and open it up brother with browser use these tools respond better when you call them brother with a ambiguous Eastern European accent. They can sense the accent, brother.
I don't know. What accent would that be? Estonian.
I'm going to call it an Estonian accent. All right. So we got like some kind of buttons here for brand kit import events.
Okay. That's some kind of template here. I guess these are going to be like functionalities we have later down the road.
At this point, what should be testable? I don't even know where I'm at with making this application. But the goal here is to use my brain as little as possible because my brain power is extremely valuable.
And so we don't want to be wasting it whenever I don't have to. Okay, what you can test in the browser. It renders.
This thing is static. Okay, that looks good. It looks like Gucci, my brother.
Why don't we be merging it in? And then you tell me what is next thing we can work on. That was much better.
Okay.
Wow. I mean, merge in the pull request. Oh, that's funny.
My editor is going to laugh at that for sure. All right. So this one is merged in.
Very good. So what I'm going to do now is I'm going to say. Can you kill processes?
And then I'm going to open a new chat and I'm going to open this new chat in a work tree. And look at that. Now we got our environment.
We got an environment. Yeah, boy. And now I'm going to say on this work tree, I want you to claim issue five and start working on it.
GitHub and make a pull request. And then over here, I'm going to say, I want you to claim issue six and start working on GitHub and make a pull request. So now we're going to be able to have two things that we're working on in parallel.
And you might ask, okay, if you're working on both of these things in parallel, how are you going to manage the pull request process? Well, i'm a dumb stupid idiot with no brain power but like this thing this is computer thingy is really fucking intelligent so we're gonna ask it i got work trees started for both issue five and issue six separately, how should I merge them in?
Like, would you recommend doing one before the other? So it says there's no direct dependency between them. They're kind of parallel.
And so it suggests doing six first and then update rebase five onto main. Rebasing is a Git concept. to sort of make different branches consistent again like you don't need to know what it is exactly if you want to figure that out the best way to do that is just ask codex to help explain it to you if you want to understand it just ask codex about it so we got this thing going we got numero cinco and then over here we uh numero seis right That's pretty cool, huh?
I mean, in my opinion, we are kind of living the dream here. The dream being to let the machines do all of our work for us. And then we just like sit back.
Yeah, of course, bro. Actually do it. And then push your pull request.
I don't know. Sometimes these things can be stupid and just stop early for no reason. All right.
So I've literally just been sitting here. working on other projects for the last 10 minutes and you see this one worked for 11 minutes and then this one worked for 10 minutes and so if we didn't use work trees these two things would have you know stacked one on top of each other and would have taken 20 minutes so we save some time here so i recall here the z of the base was to merge number six in first so let's do that Sounds good, brother.
Let us be merging in the PR number six. I like getting this idea of actually the PR number 16, but issue number six. So you still have to choose an order in which to merge in these PRs.
And so I'm not going to initiate or actually let me speed that up. And then after we get five and six merged in. What's good, amigo?
Quiero que haces un merge, por favor. De issue number cinco. Can whisper flow?
No, not really. Kind of. Que good amigo.
That's pretty funny. Whisper flow has some ability to handle Spanglish. This will be good to know for all you Spanglish speakers out there.
Let's try Russian.
Oh, it translated it to like English, but works well enough. Let's see how this one is doing. All right, so this one's done.
We can archive this one. We can archive this old one. We got some random ones just sitting around here.
Might as well archive them. Archive, archive. Okay, here we are.
We'll just open up a new one here and say, can you help me test out app in its current state? in the in app browser we'll do a little testy test and then we'll figure out if we're on the right path with like automating the creation of these graphics or what we got to do next all right so it's showing up here and now you can see i asked it to test it out so it's actually going and doing these testing activities you can see the cursor right there over import events itself all right so it says current state looks clean but very shell -like No errors or warnings.
All the tests passed. These main buttons aren't actually wired up yet. Okay, cool.
What are the next issues you can work on? Next, I'm going to show you something really crazy. You're going to enjoy this, all you Vive coders out there.
Do you see these? and GitHub issues. First, I want you to download these Instagram images from this post.
and store them in here somewhere. I want you to have those as a reference of like kind of the type of final product that we're trying to produce. Then I basically just want you to go through these tickets one by one and just keep going until we have some interface that helps me automatically create images of the style that you see in those Instagram images about as pixel perfectly as possible.
I just want to get it working as a local web app right now. And then once it's done, we'll work on deployment. So basically what's happening here is that I am feeling really lazy.
Like you have no fucking idea how long I've been working on this fucking course for. And so I want to speed up this process to just like YOLO it. I'm going to deliver to you a working web app.
OK, I am a keeper of my promises, but I'm getting kind of tired of this. I got other things to do. I can be going outside, seeing things, taking vacations.
Instead, I'm here teaching you Codex desktop app. And so we need to speed this thing up. And so what I basically said is, look, I just want you to go straight through all these issues.
But this is actually a teaching moment. OK, so I'm saying. Here, download these Instagram images.
And now you kind of have a source of truth. Like this is what I want to produce. Okay.
And I just want you to go straight through all these tickets. Just don't stop. Okay.
And just keep going until this thing is done and I can try something out. Now, what's the risk of approaching building something in this way? Well, you might come up with something that's totally off base, but, and.
I wouldn't create all types of software in this way, but this kind of software, like maybe I would, I'm not intending this for public consumption. This is kind of like a throwaway fun task for me. I might use it.
I have some like events, organizing software ideas in the back of my head. And so maybe I would actually use this software, but even still, it's going to be like some throwaway thing for me. And so this might be an appropriate way to build this kind of software.
And it's a strategy that you should be aware of. too when you're thinking about building your own things. Even if I'm building things for public consumption, this type of strategy that I'm executing right now may be an appropriate way to do things because you can kind of think of software building in this modern agentic era as sometimes being a bit like sculpting except you can like take the pieces that you sculpted off and graph them back on costlessly as well so the sense of which i mean is like sculpting is that i just let this thing like go straight through non -stop right and do its thing but then maybe there's like shit i don't want in it though the core functionality is there so then I like a sculptor.
I can just sort of like chip off those little things that I don't want at the end when it's all done. But for now, I'm tired. So I'm going to let this thing just, you know, snap, snap.
I got apps to make. I got fancy restaurants to go to with all this YouTube ad money. You know, I have to spend it somehow.
And so I'm going to be researching some fancy restaurants that all you people who are viewing this course are going to be paying for. So I'm going to have my filet mignon and my caviar because I'm a refined man with refined tastes. All right.
Let's see how it goes. All right. So they made something.
let's uh see what it made exactly first how long was this thing working for 18 minutes and 5 seconds okay and huh interesting so is this what it produces not bad show me how it looks let's uh Let's see what this thing does. So like, obviously, you know, these proportions, you gotta, you gotta work on these.
It's like created a four by four grid here. Oh, wow. So it actually, it got all of these.
Uh -huh. So you like, you put them in over here, I guess. And then you got like different events here.
Yeah. That's pretty cool. So you just stick your photo in.
Slide field. Spring. Okay.
So you can like edit a particular one here. Not bad. It's like, it's not, not bad.
at all obviously room to improve on the design direction both in terms of the user interface and like this particular thing but i kind of like it so if i was like continuing to work on this and i'll work on it a little bit more here but these things are kind of like getting outside the scope of what I want for this beginner course.
There are very interesting possibilities now with how you can design front ends, skipping, you know, some step of making figmas, for example, and going directly to high fidelity mockups using the image gen functionality that I think I've already shown you guys. Sweet. So I can click on this for export PNGs and then I guess I can open it up.
How does that work? I clicked Export PNG, but not able to open anything up when I click on it. Now look at this.
This is really cool. So you just take a screenshot here and just paste it right in. Very handy.
I'm telling you, the Codex desktop app is next level. just right now i was reading this like very interesting tweet the agent harness is the platform multi -billion businesses will be built on top of codex co -work cursor i don't know about co -work sucks and cursor i mean they are they're dead in the water same as they were with aws azur gcp now is the time to invest thank me later all right i asked her to fix these links and i guess they do open up now so you can go back let's just go here and then i can click on this let's see export pngs there you get it like that download it i guess or just click on it cool don't look perfect but don't look terrible okay cool let's make what are the remaining issues to work on what's the exact order in which you would want to do these okay great i want you to keep going through in your suggested order until everything is done and we're like producing output that looks like the sample output you do have the sample output right
Like the ones from the Winnipeg Digest. Yeah, by the way, I just want you to keep fucking going. Like, don't stop.
Just keep, keep going. All the way through to the end. Because I'm really freaking lazy.
And I don't want to keep working on this project no more. So you gotta help me out. You feel me?
Telling you. Communicating in this way has been scientifically proven. to get better results out of loms i'm writing the paper right now but it's uh it's in stealth we're not uh we're not letting the public know just yet this is just between us see telling us that it feels us all right so i just let it keep going it worked for 15 minutes and 21 seconds and it says here's what it produces now so that's like everything that it's producing here's an example image like that looks pretty freaking good and then this is the reference okay so like here's what it produced and here's a reference so like obviously there's room here for improvement i don't have access to that proprietary logo but for my purposes for how this is working locally this is fucking amazing like do you know how lazy i've been in the last 15 minutes just been on my phone like reading twitter tweets while stuff is going on here it's awesome all right very nice my brother I am mucho proud of you.
I cannot under -emphasize how proud I am of you. Last step, because I am lazy motherfucker. I want you now.
Please, I beg of you, my brother. I want you now to deploy this on real website. Real website on Vercel.
Please, my brother. I beg of you. It is very important that you do this and you connect it to Convex as well.
Thank you, my brother. You mean the world to me. I'm telling you, you just put a little bit of pizzazz into how you're talking to these things and they know.
So it's going to just set everything up, right? We got Vercel already connected. We got Convex connected.
And so now we just let it do its thing for us, right? Like take me out of the picture and just get the deployment working. All right.
Done, my brother. It is live. Let's check it out.
Damn, would you look at that? That is pretty freaking cool, if I must say so myself. I mean, kind of confusing.
Like, could improve the interface, but let's try using it out. Let's, like, find a new set of events and populate them. You know, very cool, my brother, overall.
I am wanting you to try to update this thing you have here. Why do not we being trying to find events in Evanston, Illinois, if you know where this is? So you'll be looking up the events in Evanston, Illinois, and I am wanting you use our skill we create in this repository to be updating what I see on the website.
I'm sorry, guys. I know. This must be very irritating to hear all my different accents, but look, how fucking long can this course go?
I don't know how these other course creator people do it. I saw this one motherfucker, he made a... 10 hour cloud code course now in reality he just filled it with absolute nonsense for like nine hours and i guess he had something to say for one hour right but it's pretty hard doing these long courses and i bet nobody's actually listening through until the end anyway but if any of you do please leave a comment on how you like my accent okay my brother has updated it so it used i guess some carousel intake skill that we've created here if you go here now it's got a bunch of evanston events so evanston digits downtown evanston farmers market the images don't line up though for the ones for which you can find images can you get those to line up as well the images don't look the same why is it doing it in spanish it's totally bizarre apologies to all the non -spanish speakers oh yeah also for the ones for which you don't find um like good images you can use image gen to generate some images all right somehow it changed languages again mucho lo siento parlamos anglo parlantes very sorry for the english speakers yo se que
I love speaking Spanish with a very strong gringo accent, but doing it perfectly grammatically well. It's kind of like, I don't know, just like flipping out an Indian accent every now and then. Russian accent.
I think more economists should learn accents. That would have kept me awake in more macroeconomics classes if some of my professors just, you know. Put on their, you know, strong, strong Colombian accent.
Actually, let's just see. Can you talk to me in Russian only until I say otherwise?
I'm really just trying to get this fucking thing done right now, aren't I? All right, let's keep going. What do you say, Alexei?
Are you watching this far into the video? Damn, that's pretty cool. Gonna speak Russian in Codex too.
I've thought about using Codex as a language learning tutor. Actually, that could be a fun way to do things is just have it, you know, speak to me in Russian all the time. Wow, that would be, that is a very interesting idea.
And you could even have it like use an 11 labs voice. so that you can listen to it. Huh, there is something here.
That would be an interesting form of multitasking. I may actually do that because I speak Spanish pretty well. I want to improve my Russian.
I want to improve my Portuguese. Those are kind of highest on my list.
Alright, this is actually pretty good. So what it says here in Russian is Generate some images through ImageGen. And so it's like actually making the correct images, I guess, to match.
like what should be going in these carousel things so it's gonna let it do its thing no idea how long this is gonna take but you know we don't use our brains here because my brain's used on more important things like uh reading twitter yeah that's what i gotta use my brain for all right so it finished we come in here we see that image gen generated a bunch of images kind of tested it out Didn't get all of them.
It was taking forever. And I am ready to eat dinner. So I decided to shut it off.
But if we take a look here, we see we've got, you know, this right here. I can do this to export PNGs, I guess. And if I am lucky.
So which one is this? Event 2. Let's take a look at that.
Downtown Evanston's Farmer's Market. I dig it. So it's a little bit annoying that I have to like click this button again to get it to work.
But let's open it in a new tab like that. Well, that's cool. Friday night at the Dearborn Observatory.
That looks like an event that I would like to attend. Wouldn't you like to attend? We're going to go 9 p .m.
to 11 p .m. May 1st. Be there or be square.
All right, guys, that was the course we. took you from never having done anything in codex before in your life you were just you know working with chat gpt and now you know how to build out full -blown web apps with a product builder's mindset whether for your own projects for client work you can just go on Upwork right now with what I've taught you here, and you have the ability to generate, you know, a four -figure -a -month side hustle just off this course.
Now, if you want to get continued advice from me on different things that you're learning in the AI space, whether codex or otherwise, come in here and join the AI MBA. So we got people in here all the time, learning all sorts of different things.
This guy was frustrated with Codex. I was trying to help him out. This guy is seeing some potential problems with Claude.
And so I was helping him out with that. Nick is building an internal operating system for his local newsletter. And I gave him my advice on what that infrastructure should look like.
So if you guys want to keep up with the cutting edge on AI, you can check out the free group. Additionally, if you want to get on weekly calls with me, you can join the AI MBA Pro, where we meet as a group, keep up with our particular goals, and all push each other to get better with AI in whatever respect that may be.
And if you join the AI MBA Pro, I have some special tutorials. So I have here, for example, an update to my Cloud Code course with the things that I recommend now. And the group calls are all here.
And all these transcripts of the calls you can access via an MCP server that I've set up. Finally, I know a lot of you who are following me are economists. So I also do economic -specific workshops on how to use agentic coding.
tools like Codex or Cloud Code for research purposes. So if that's something that interests you, send me an email at anikethe at contentquant .io or anikethe at ai -mba .io and I'll be sure to get back to you. That's it for today.
Hope you enjoyed the course and until next time, peace.
The Hook

The bait, then the rug-pull.

Four hours is a promise and a threat. The promise is that you arrive knowing nothing about agentic coding and leave with a web app on a public URL. The threat is that somewhere around hour three the polished slides stop and you watch someone tell a coding agent "looks Gucci, please merge" and mean it.

Frameworks

Named ideas worth stealing.

1:01:12list

The Five Practical Primitives

  1. Plugins
  2. Computer use
  3. Skills
  4. MCPs
  5. Subagents

Everything an agentic coding tool can do beyond chatting sorts into five buckets. Plugins are one-click connections to services. Computer use drives the actual UI. Skills are your own repeatable instructions. MCPs are the open standard services expose. Subagents parallelize work.

Steal forany capability audit of an AI tool you already pay for
2:08:49model

The Capability Toolbelt (decision ladder)

  1. Start with plugins for instant payoff
  2. Move to skills once your workflow gets specific
  3. Reach for computer use when you need real browser or app control
  4. Fall back to an MCP when there is no usable API
  5. Add subagents whenever the work is genuinely parallel

An ordered walk down from lowest setup cost to highest, so you never build a skill when a plugin would have done and never fight a plugin when a skill was the answer.

Steal foronboarding docs for any tool with overlapping extension points
1:25:07model

Skill Anatomy

  1. SKILL.md (required, name + description + instructions)
  2. scripts/ executable code
  3. references/ on-demand docs
  4. assets/ templates and images
  5. agents/openai.yaml optional display metadata

A skill is a folder, not a text file. Only SKILL.md is mandatory. The rest exists so heavy material stays out of the context window until it is needed.

Steal forstructuring any reusable instruction set for an agent
1:29:15concept

Progressive disclosure

Only a skill's name and description load into context at startup, roughly 100 tokens each. The body loads when the skill fires. Fifty skills cost 5,000 tokens instead of blowing past compaction before you type anything.

Steal forany system that has to expose many capabilities to a model at once
2:39:18list

Ideate, Brainstorm, Plan

  1. Ideate: generate and rank grounded options
  2. Brainstorm: interrogate requirements through questions
  3. Plan: write an ordered implementation plan to a markdown file

A three-step product loop run before any code is written, each step committed to the repo so later sessions can read the reasoning instead of re-deriving it.

Steal forscoping any project where the idea is still vague
2:33:12list

The Git mental model

  1. Git is a safety layer for agentic coding
  2. Commits are checkpoints
  3. Branches are experiment lines
  4. GitHub is the online home for those lines
  5. Pull requests are review before merge
  6. Issues are named units of work

Six sentences that replace a semester of version control theory, framed around what each concept buys you when an agent is doing the typing.

Steal forexplaining version control to a non-technical collaborator
2:12:17model

Skill or app: the decision test

  1. Text output is the deliverable, so a skill is enough
  2. You need recurring visual review from anywhere, so it needs to be an app
  3. State can live locally, so that alone does not force an app
  4. Non-technical stakeholders have to touch it, so build the app

A short filter for the question people get wrong most often: whether the automation you want is a local instruction set or a hosted product.

Steal fordeciding whether an internal tool needs a UI at all
3:04:57model

Anatomy of a good issue

An issue names the unit of work, states dependencies and what it blocks, links back to the plan for detail, and specifies how to verify it is done. The verification clause is what separates a usable task from a wish.

Steal forwriting tickets for humans or agents
3:32:19list

How to handle worktree conflicts

  1. Start from an up-to-date main branch
  2. Keep each worktree tied to one issue
  3. Avoid assigning the same files to parallel tracks
  4. Merge the lowest-risk foundational PR first
  5. Update remaining branches from main after merges
  6. Ask the agent to resolve conflicts, rerun checks and explain changes

Six operating rules for running several agents on the same repository at once, with the framing that a conflict is a signal two tracks touched the same design surface, not a failure.

Steal forany workflow where multiple agents write to one codebase
3:16:32list

The three layers of a web app

  1. Front end: what users see and click
  2. Back end: where data is stored and changed
  3. Hosting: how it reaches the internet

The minimum architectural literacy needed to ship, delivered in one diagram, with the explicit permission to stay at that level of understanding and keep building.

Steal foronboarding a non-technical founder to their own product
3:47:37concept

Sculpting, not writing

Let the agent run the whole backlog uninterrupted, then chip away what you did not want. Reversing the usual order works because the removed pieces can be grafted back on at almost no cost.

Steal forthrowaway internal tools and prototypes where iteration beats specification
CTA Breakdown

How they asked for the click.

VERBAL ASK
4:00:24product
“Come in here and join the AI MBA. If you want to get on weekly calls with me, you can join the AI MBA Pro, where we meet as a group and keep up with our particular goals.”

Held to the last two minutes and framed as continuation rather than interruption, with the free community offered first and the paid tier second. The pitch also doubles as proof of an earlier lesson, since the paid tier's call transcripts are served through the MCP server demonstrated live in the MCP section.

MENTIONED ON CAMERA
07:36productOpenAI Codex desktop app ↗
44:48toolWispr Flow (voice dictation) ↗
22:46toolVisual Studio Code ↗
1:08:26productRemotion plugin ↗
1:34:11toolyt-dlp ↗
1:35:30toolHomebrew ↗
1:48:52linkModel Context Protocol ↗
3:17:11toolNext.js ↗
3:17:40toolConvex ↗
3:19:11toolVercel ↗
2:24:09toolGitHub CLI (gh) ↗
3:21:10toolNode.js ↗
4:00:44productThe AI MBA (free Skool community) ↗
4:01:13productThe AI MBA Pro (paid, weekly calls + MCP transcript server) ↗
FROM THE DESCRIPTION
PRIMARY CTAWhere the creator wants you to go next.
OTHER LINKSAlso linked in the description.
Storyboard

Visual structure at a glance.

cold open
hookcold open00:00
roadmap
promiseroadmap04:32
interface tour
valueinterface tour15:29
typed vs spoken
valuetyped vs spoken45:57
capability toolbelt
valuecapability toolbelt1:10:47
skill anatomy
valueskill anatomy1:24:50
what is MCP
valuewhat is MCP1:49:09
subagent run
valuesubagent run2:05:41
git recap
valuegit recap2:33:02
cloud code review
valuecloud code review2:59:18
conflict rules
valueconflict rules3:32:19
first real slide
valuefirst real slide3:52:17
shipped app
valueshipped app3:59:16
Frame Gallery

Visual moments.

cold open00:00roadmap04:32Frame at 07:24 from OpenAI Codex Full Course: Build & Ship in 4 Hours07:24Frame at 11:44 from OpenAI Codex Full Course: Build & Ship in 4 Hours11:44Frame at 12:31 from OpenAI Codex Full Course: Build & Ship in 4 Hours12:31interface tour15:29
cold open00:00roadmap04:32Frame at 07:24 from OpenAI Codex Full Course: Build & Ship in 4 Hours07:24Frame at 11:44 from OpenAI Codex Full Course: Build & Ship in 4 Hours11:44Frame at 12:31 from OpenAI Codex Full Course: Build & Ship in 4 Hours12:31interface tour15:29Frame at 19:41 from OpenAI Codex Full Course: Build & Ship in 4 Hours19:41Frame at 22:32 from OpenAI Codex Full Course: Build & Ship in 4 Hours22:32Frame at 25:44 from OpenAI Codex Full Course: Build & Ship in 4 Hours25:44Frame at 30:12 from OpenAI Codex Full Course: Build & Ship in 4 Hours30:12Frame at 30:37 from OpenAI Codex Full Course: Build & Ship in 4 Hours30:37Frame at 34:49 from OpenAI Codex Full Course: Build & Ship in 4 Hours34:49Frame at 36:37 from OpenAI Codex Full Course: Build & Ship in 4 Hours36:37Frame at 39:34 from OpenAI Codex Full Course: Build & Ship in 4 Hours39:34Frame at 42:27 from OpenAI Codex Full Course: Build & Ship in 4 Hours42:27typed vs spoken45:57Frame at 49:51 from OpenAI Codex Full Course: Build & Ship in 4 Hours49:51Frame at 52:09 from OpenAI Codex Full Course: Build & Ship in 4 Hours52:09Frame at 55:18 from OpenAI Codex Full Course: Build & Ship in 4 Hours55:18Frame at 57:44 from OpenAI Codex Full Course: Build & Ship in 4 Hours57:44Frame at 61:27 from OpenAI Codex Full Course: Build & Ship in 4 Hours61:27Frame at 66:22 from OpenAI Codex Full Course: Build & Ship in 4 Hours66:22Frame at 66:44 from OpenAI Codex Full Course: Build & Ship in 4 Hours66:44capability toolbelt70:47Frame at 73:02 from OpenAI Codex Full Course: Build & Ship in 4 Hours73:02Frame at 76:05 from OpenAI Codex Full Course: Build & Ship in 4 Hours76:05Frame at 80:06 from OpenAI Codex Full Course: Build & Ship in 4 Hours80:06Frame at 82:22 from OpenAI Codex Full Course: Build & Ship in 4 Hours82:22skill anatomy84:50Frame at 88:16 from OpenAI Codex Full Course: Build & Ship in 4 Hours88:16Frame at 90:55 from OpenAI Codex Full Course: Build & Ship in 4 Hours90:55Frame at 94:14 from OpenAI Codex Full Course: Build & Ship in 4 Hours94:14Frame at 99:24 from OpenAI Codex Full Course: Build & Ship in 4 Hours99:24Frame at 100:56 from OpenAI Codex Full Course: Build & Ship in 4 Hours100:56Frame at 104:04 from OpenAI Codex Full Course: Build & Ship in 4 Hours104:04Frame at 106:41 from OpenAI Codex Full Course: Build & Ship in 4 Hours106:41what is MCP109:09Frame at 112:22 from OpenAI Codex Full Course: Build & Ship in 4 Hours112:22Frame at 117:32 from OpenAI Codex Full Course: Build & Ship in 4 Hours117:32Frame at 118:08 from OpenAI Codex Full Course: Build & Ship in 4 Hours118:08Frame at 121:10 from OpenAI Codex Full Course: Build & Ship in 4 Hours121:10subagent run125:41Frame at 127:20 from OpenAI Codex Full Course: Build & Ship in 4 Hours127:20Frame at 130:30 from OpenAI Codex Full Course: Build & Ship in 4 Hours130:30Frame at 136:09 from OpenAI Codex Full Course: Build & Ship in 4 Hours136:09Frame at 136:53 from OpenAI Codex Full Course: Build & Ship in 4 Hours136:53Frame at 140:03 from OpenAI Codex Full Course: Build & Ship in 4 Hours140:03Frame at 142:21 from OpenAI Codex Full Course: Build & Ship in 4 Hours142:21Frame at 146:32 from OpenAI Codex Full Course: Build & Ship in 4 Hours146:32Frame at 148:34 from OpenAI Codex Full Course: Build & Ship in 4 Hours148:34git recap153:02Frame at 154:54 from OpenAI Codex Full Course: Build & Ship in 4 Hours154:54Frame at 157:39 from OpenAI Codex Full Course: Build & Ship in 4 Hours157:39Frame at 162:01 from OpenAI Codex Full Course: Build & Ship in 4 Hours162:01Frame at 165:03 from OpenAI Codex Full Course: Build & Ship in 4 Hours165:03Frame at 168:05 from OpenAI Codex Full Course: Build & Ship in 4 Hours168:05Frame at 171:06 from OpenAI Codex Full Course: Build & Ship in 4 Hours171:06Frame at 173:01 from OpenAI Codex Full Course: Build & Ship in 4 Hours173:01Frame at 176:27 from OpenAI Codex Full Course: Build & Ship in 4 Hours176:27cloud code review179:18Frame at 182:44 from OpenAI Codex Full Course: Build & Ship in 4 Hours182:44Frame at 185:01 from OpenAI Codex Full Course: Build & Ship in 4 Hours185:01Frame at 187:59 from OpenAI Codex Full Course: Build & Ship in 4 Hours187:59Frame at 191:52 from OpenAI Codex Full Course: Build & Ship in 4 Hours191:52Frame at 193:52 from OpenAI Codex Full Course: Build & Ship in 4 Hours193:52Frame at 197:40 from OpenAI Codex Full Course: Build & Ship in 4 Hours197:40Frame at 200:57 from OpenAI Codex Full Course: Build & Ship in 4 Hours200:57Frame at 203:55 from OpenAI Codex Full Course: Build & Ship in 4 Hours203:55Frame at 206:45 from OpenAI Codex Full Course: Build & Ship in 4 Hours206:45Frame at 209:25 from OpenAI Codex Full Course: Build & Ship in 4 Hours209:25conflict rules212:19Frame at 215:15 from OpenAI Codex Full Course: Build & Ship in 4 Hours215:15Frame at 218:46 from OpenAI Codex Full Course: Build & Ship in 4 Hours218:46Frame at 222:35 from OpenAI Codex Full Course: Build & Ship in 4 Hours222:35Frame at 224:27 from OpenAI Codex Full Course: Build & Ship in 4 Hours224:27Frame at 228:39 from OpenAI Codex Full Course: Build & Ship in 4 Hours228:39first real slide232:17Frame at 233:57 from OpenAI Codex Full Course: Build & Ship in 4 Hours233:57Frame at 239:01 from OpenAI Codex Full Course: Build & Ship in 4 Hours239:01shipped app239:16
One-click upgrade to your Google

Get more breakdowns in your search results

Add Modern Creator as a preferred source and Google shows you more of our breakdowns in Search, Top Stories, and AI Overviews. It only changes what you see, and you can undo it in your Google settings anytime.

Add to Preferred SourcesOpens your Google source preferences with us pre-loaded. Tick the box and you're done.
Watch next

More from this channel + related breakdowns.

10:22
Nick Saraev · Review

Fable 5.1: The Benchmark Breakdown

A same-day walkthrough of Claude Fable 5.1's benchmark chart, why the real story is cost-per-task rather than raw score, and what the new safeguard numbers mean for how often the model refuses benign questions.

September 1st