☆ Overview
Nate B Jones makes the case that Codex isn't just a coding tool — it's the beginning of a new computing paradigm where humans delegate work to agents instead of manually navigating apps. Drawing from his own experience of burning 500+ million tokens per day, he walks through the practical patterns that make Codex transformative: chief-of-staff threads, goal-based delegation, computer use, skills, and building custom live dashboards. This isn't a hype video — it's a detailed operational guide for anyone doing knowledge work.
1 Codex Makes the Computer Feel Different
Nate opens with raw enthusiasm: he's obsessed with Codex "in the way a kid is obsessed with a new PlayStation." But the obsession isn't about better AI answers — it's about a fundamental shift in what a computer feels like.
Before Codex, most AI work still looked like chat — "draft this, summarize this, clean this up." Useful, but still the human asking for help. With Codex, Nate started giving his computer jobs:
- Find the transcript, read the folder, compare the versions
- Render the Word file, check that it opens
- Open the browser, use the site, keep going until there's something real to inspect
The key insight: Codex doesn't just write code — it makes the computer feel like something you can hand work to. Files, browser sessions, documents, terminal output — everything is now in range for an agent.
The Name Problem
Nate acknowledges the name "Codex" is misleading. It sounds like a developer tool, and developers are seeing it first because coding has a clean working environment (tests, files, diffs, logs). But the habit Codex teaches is much bigger than code. If you write, research, make documents, run a business, organize projects, or spend your day switching between apps — Codex can help with all of it.
2 The Token Dashboard — A Receipt for Changed Work
On May 20th, Nate's local Codex log showed 510 million tokens in a single day — all under his Codex Max account, no surprise billing. He's routinely hitting 300–500 million tokens daily.
But the number isn't the point. The token count is a receipt that reflects how work has changed. If 510 million tokens just meant he was typing more prompts, that would be embarrassing. The number went up because the unit of work fundamentally changed in scale.
Nate mapped his token burn over a year and found the biggest behavioral shift happened in the last month, as computer use + GPT-5.5 in Codex unlocked a huge number of workflows simultaneously.
3 The Unit of Work Gets Bigger
When Nate says Codex has 10x'd parts of his workflow, he doesn't mean he became 10x smarter. He means the size of the job he's willing to hand to the machine changed. Instead of asking for answers, he now issues compound instructions:
- Go find the source files
- Go read the transcript
- Go make the artifact
- Go render the document
- Go check the package
- Go inspect the browser
- Go keep working till the goal gets done
The shift from "help me with this" to "go do this job" is what drives the exponential token growth — and the exponential productivity gain.
4 A New Computing Paradigm
Nate frames this as the first change in the computing paradigm in ~40 years. The progression:
- DOS era — command-line, no visual apps
- App era (1990s–2020s) — humans moved between apps, remembered why each app was open. The human was the center of computing
- Agent era (now) — humans sit above the computing paradigm and delegate to agents who run the compute
Codex is essentially a state machine — an agent in a loop that remembers what it's doing and can work the whole computer. Files, source notes, templates, applications — they're all underneath Codex. Tokens are simply the cost of letting the agent compute for you.
Nate is clear this isn't an OpenAI vs. Anthropic argument: "I am not saying Anthropic won't get here. I know that they will." Codex is just the first tool that makes this paradigm accessible today.
5 Chief of Staff Threads
The first pattern that made Codex click: stop treating every thread like a random chat. Most people use AI as a pile of separate conversations — one chat for a draft, one for a bug, one for a note. The problem: the human becomes the router, remembering where everything is, what matters, what version is current, and what standard the work should meet.
The Pattern
Create one thread — the "chief of staff" thread — that stays pointed at the work. This thread knows:
- The goal — what you're trying to accomplish
- The folders — where the work lives
- Current artifacts — what exists now
- The standard — what quality the work needs to meet
From this home base, the chief of staff can spin out smaller jobs without you re-explaining the entire project each time. It's not magic memory — you still have to give it sources, correct it, and make it show receipts. But it stops feeling like a chatbot and starts feeling like a home base for the work.
6 Threads, Goals, and Subagents
Nate distinguishes between threads and subagents. A thread is the run that owns the job. A subagent is a smaller helper inside that job, used for narrow pieces of work so the main thread doesn't get buried in noise.
The Two-Phase Architecture
- Planning thread — owns the goal, uses subagents for discovery, source checking, scouting, reading messy material
- Execution thread — owns the deliverable once the goal is clear, uses subagents for site scouting, source checking, output inspection, and noisy folder summarization
The key shift: give Codex the actual objective, not just "help me with this." Instead: "Read these sources, produce this artifact, check it against this standard, and do not stop at the first plausible draft. Keep going."
The set a goal feature is critical — it zeros Codex in on a defined objective and makes it run through walls until the goal is done. No more early stopping.
7 Computer Use, Plugins, and Skills
What makes Codex powerful isn't one magic prompt — it's the setup around the model:
- Computer use — Codex can literally see a screen, click, type, and use apps
- Tools — call real systems programmatically
- Plugins & connectors — reach the places where your work already lives
- Skills — teach Codex a reusable way to do a job instead of explaining the same process every time
The Compounding Effect
This is where Nate sees the real leverage. If you correct Codex once, that's just a chat. If you turn the correction into a skill, a checklist, a reusable instruction — the work begins to compound. Every repeated correction is a signal that should become a standing workflow, an automation, or a memory.
The "code" label is misleading — developers understand skills first because they live in a world of tools, files, tests, and workflows. But the same pattern applies to documents, reports, research, invoices, dashboards, meeting prep, family logistics, and customer support. You don't need to know code to use code patterns in Codex.
8 Building a Heads-Up Dashboard for Your Workday
Nate's flagship workflow example: a custom heads-up display (HUD) that gives live alerts of what matters in your workplace, custom-tuned to your tools. Not a generic SaaS product — a dashboard you build just for you.
How to Build It
- Define your sources — email, Slack, WhatsApp, whatever you use for work
- Define what matters — have an honest discussion with Codex about how you move the needle in your job, what's salient across sources
- Ask Codex to design the dashboard — a live-updatable display that pulls from sources via computer use or MCP servers (e.g., Slack has an MCP server)
The Result
A personal dashboard where at any given point you can see:
- What matters in Slack right now
- What matters in email
- Your prioritized to-do list
- Saliency analysis of what really matters
You can automate updates — every 15 minutes, every half hour — and the system runs saliency analysis, reprioritizes, and highlights what's truly important. This is Nate's example of a powerful open loop that simply wasn't possible even 2–3 months ago because computer use availability wasn't there.
9 Your First Useful Codex Loop
For beginners, Nate's advice is clear: don't try to automate your whole life. Pick one loop that is annoying and valuable. Examples:
- Turn this transcript into a brief
- Organize this source folder
- Build me a simple dashboard to track inbound email subscriptions
- Prepare my day from calendar, email, and Slack
- Draft three versions of this document and explain the differences
- Check this package — tell me what's missing
The Five Ingredients of a Loop
- A goal — what the loop should accomplish
- Sources — where the data comes from
- A standard — what quality the output should meet
- A permission boundary — what the agent can and cannot do
- Proof that it's done — how you verify the results
For experienced users: look for loops you keep repeating. Every repeated correction, setup note, or output check should become a skill, a standing workflow, an automation, or a memory for Codex. That's when it stops being one-off help and starts compounding.
10 Boundaries, Receipts, and Responsible Delegation
Nate is explicit: the more powerful the tool, the more important the boundaries. Practical rules:
- Don't paste API keys or passwords into chat — use a
.envfile instead - Don't give write access just because read access would be useful
- Don't let it send, publish, delete, or spend money unless you fully understand the workflow
- Make it show receipts — files, logs, tests, renders, command output
Codex's advantage here: it's very easy to inspect the work. The tool shows you everything it did — files created, logs generated, tests run, renders produced. Building a habit of demanding proof from your agent is what keeps this from turning into hype.
11 The New Computer Literacy
Nate's closing argument: Codex represents a new kind of computer literacy — not typing, not prompting, but handing work to agents that can truly use the computer and then learning how to check what came back.
This applies to anyone who does knowledge work: writing, research, project management, document creation, support, or life planning. Codex is one of the first tools that lets you practice this literacy, and the people who adopt it early will have a massive advantage.
He emphasizes this is still early — "the real playbook is still being written by the people who push the tool hard" — and invites the community to share what they're building.
🎯 Key Takeaways
🔑 Key Takeaways
- Codex is not a coding tool — it's a computing paradigm shift where you delegate real computer jobs to an agent in plain English, regardless of your technical background
- The unit of work has changed — from asking for answers to assigning compound jobs: "find, read, make, render, check, keep going until done"
- 500 million tokens/day is a receipt, not a flex — the token count reflects how much of your computing now runs through agents instead of manual app-switching
- Chief of Staff threads beat random chats — one persistent thread that knows the goal, folders, artifacts, and standards eliminates the human-as-router problem
- Goals + subagents = real delegation — the "set a goal" feature prevents early stopping; subagents handle narrow tasks so the main thread stays clean
- Skills are the compounding mechanism — every repeated correction should become a reusable skill, workflow, or memory that makes Codex better over time
- Computer use is the unlock — Codex can see screens, click, type, and use apps, which makes browser tasks, dashboards, and multi-app workflows possible
- Build a personal HUD — a custom live dashboard pulling from email, Slack, and other sources replaces generic SaaS tools with something built exactly for your needs
- Start with one annoying-but-valuable loop — don't automate your whole life; give Codex a goal, sources, standard, permission boundary, and proof of completion
- Boundaries scale with power — use .env files for secrets, limit write access, demand receipts (files, logs, tests), and never let agents send/publish/spend without understanding the workflow
- The new computer literacy is delegation — not typing, not prompting, but handing work to agents and learning to check what came back
🔗 Resources & Links
- Nate's Ultimate Codex Guide (Substack) — complete checklist, examples, and setup notes for getting started with Codex