Most people's first encounter with Codex is as a tool for writing code โ you describe what you need, it hands back a chunk of code, and the interaction ends there. But treating it purely as a coding assistant means missing what it's actually being used for by people who've pushed further: turning a task that used to eat hours of manual work, or require hiring someone to handle it, into something you trigger with a single sentence โ and that keeps running even after your computer is off.
This article breaks down the most operationally useful part of a 2.5-hour Chinese-language tutorial video: how to go from "typing a prompt" to gradually turning that work into a "reusable skill," then wiring that skill to a real data source, and finally deploying the whole thing to the cloud so it runs as an unattended, 24/7 system. The two concrete cases the video walks through โ automatically generating business quotes, and repurposing one piece of content into posts for multiple social platforms โ both use logic that transfers directly to other business scenarios.
Codex Isn't Just for Writing Code: What This Walkthrough Actually Covers
Codex is an AI agent tool from OpenAI. Unlike a chat-only tool like ChatGPT, it can work directly inside a folder on your computer โ actually reading files, editing them, opening a browser to interact with web pages, and connecting to software extensions you've installed. It's an assistant that does things, not just one that answers questions.
This piece focuses on a further step: moving Codex from "a one-time favor" to "a workflow that can run repeatedly, and even trigger itself." That progression unfolds in layers โ starting from a prompt, then stacking on a Skill, then local automation, then cloud automation.
Before You Start: Three Settings That Decide Speed and Cost
Before getting into the build, the video flags three settings new users should understand first, because they directly affect both how fast the work runs and how many tokens get burned.
Model: Different tiers of models vary in reasoning ability and how fast they consume tokens โ smarter models are generally more expensive. The video's presenter says they typically use a higher-tier model for serious work, and switch to a lower-tier, cheaper model for simple tasks.
Effort and Speed: A higher effort setting means the model reasons more thoroughly, but burns more tokens doing it; setting speed to "fast" also increases usage. The presenter says their default is medium-to-high effort with standard speed, rather than maxing both out every time โ the reasoning being that while one task is running, they can work on something else in parallel, so there's no need to chase the fastest possible completion on a single task.
Permission mode: These generally fall into three tiers, from conservative to fully open โ requiring your approval at every step, acting autonomously within the working folder but asking before any outside connection, and fully unrestricted with no further prompts. The video specifically warns that while full-permission mode is fastest, it can also delete important files by mistake, and recommends new users start with the approval-required mode until they're comfortable.
There's no single right answer for these three settings, but if you're already paying attention to where your token spend is going, it's worth reading alongside a related breakdown on autoregressive generation and why coding agents burn through tokens the way they do โ it makes it much clearer why "effort" and "speed" settings show up directly on your bill.
From Prompt to Skill: Turning a One-Off Task Into Something Reusable
The first case the video demonstrates is automating business quotes. The presenter's original process was: after a Zoom or Google Meet call with a client, transcribe the recording, pull the client's pain points, proposed solution, and estimated ROI out of that transcript, and put together a logically structured quote to send over.
The build starts by having Codex generate three HTML quote templates in noticeably different styles for three different industries (aesthetic clinics, dental clinics, and air-conditioning repair), then picking the version that fits best and refining it from there. The presenter makes a point worth keeping: if you only generate one version, you have no way to know whether it's actually what you want โ generating several distinctly different versions up front gives you something to actually compare and choose between. Once the template is locked in, the whole pipeline โ take a meeting transcript as input, output a website link containing the quote, an ROI estimate, an e-signature field, and a mock payment page โ gets written up as a "Skill" document.
The point of a Skill is this: from then on, no matter which industry the next client is in, you just feed in a new transcript and give one instruction, and the same logic produces a quote โ without having to redescribe the task from scratch each time. The real difference from a plain prompt is that a Skill locks down the rules to follow, the format to produce, and the lines not to cross, all in a fixed document that becomes a callable capability.
If you want to dig further into the mechanics of instructing a model well, there's a related piece on prompting Claude Opus 5 and Fable 5 based on Anthropic's own guidance โ different vendor, but the underlying logic of stating context first, then rules, then explicit boundaries carries over.
Parallel Sub-agents: Getting Codex to Do Several Things at Once Instead of Queuing
Once the Skill exists, the video demonstrates a technique that meaningfully cuts down waiting time: when generating two, or even six, test cases across different industries at once, don't have Codex process them one after another โ have it split the work into multiple "Sub-agents" running in parallel. On screen, several Sub-agent windows run simultaneously, each handling a different client's data, and report back once done.
The value here is testing efficiency: instead of waiting for the first task to finish before starting the second, running everything at once means you only wait once and still get multiple results to compare. This applies to any workflow where you need to produce several versions and pick the best one โ not just quotes, but content generation, proposal comparisons, and similar tasks.
Wiring the Skill to a Real Data Source: Local Automation
A Skill alone isn't enough, because up to this point every run still required manually pasting in a meeting transcript. The next step is connecting a real data source automatically โ the presenter uses a third-party meeting transcription tool, installed as a browser-based extension that plugs into Codex, so that after every call ends, Codex automatically pulls the new transcript, triggers the quote Skill built earlier, and โ once the result is generated โ reports it back to the presenter for review, only sending it to the client after manual confirmation.
There's a clear security note here: API keys, account passwords, and similarly sensitive information should never be pasted directly into the chat input with an AI. The correct approach is to have Codex point you to a file path and paste the credential into that designated configuration file instead of typing it into the conversation window. That's a basic security habit worth keeping in mind whenever you're operating tools like this.
Once wired together, the full flow becomes: call ends โ transcript is pulled automatically โ the Skill produces a quote page โ it's reported back for your manual sign-off โ you decide whether to send it to the client. This is already a working local automation pipeline, but it has one obvious limit: it only runs while your computer is on.
Moving From Local Automation to Running 24/7 in the Cloud
To solve the "the pipeline stops when the laptop is off" problem, the video's approach is to deploy this automation to the cloud. Concretely, that means connecting to Cloudflare to build a cloud environment that handles signature verification and uses a Queue mechanism to trigger the automation โ moving what used to be a local scheduled check (say, checking every few hours for a new meeting record) over to a cloud service instead. That way, even with the computer turned off, the entire "pull data โ apply the Skill โ produce a quote โ notify you for review" chain keeps running in the background โ which is the literal meaning behind the tutorial's "24/7 unattended" framing.
It's worth flagging that this cloud deployment step involves a fair amount of technical detail (signature verification setup, credential management), and the video itself tells new users they don't need to fully understand every part of it โ you can simply ask Codex "what is this step doing" and have it walk you through the reasoning before continuing. Later in the video, while building the second case (content repurposing), a different approach is shown: connecting a GitHub repository and using a cloud working environment that Codex itself provides to trigger the automation. But the video is explicit on one point โ that cloud working environment is, by design, a temporary container that gets spun up only when a task comes in, not a server that's continuously running in the background. If all you need is a simple recurring scheduled check, using the built-in "Schedule" feature that runs natively in the cloud on the Codex/ChatGPT platform itself is more direct โ you don't necessarily need to route through GitHub at all.
Second Case: Automatically Rewriting One Article Into Posts for Multiple Social Platforms
The second automation the video walks through is content repurposing โ taking a single piece of finished content (a newsletter issue, a long-form article) and rewriting it into formats suited to different platforms, so one piece of writing gets created once and distributed many times, saving the time it would take to reconceive content for each channel separately.
The concrete build: the presenter pastes in an English newsletter they're subscribed to, has Codex translate and rewrite it into Chinese, and โ accounting for the different reading habits on X (formerly Twitter), Instagram, and LinkedIn โ produce a platform-appropriate post for each (a thread of short, punchy statements for X, a mid-length post with an emotional hook for Instagram, a longer professional take for LinkedIn), along with a matching hand-drawn, chalkboard-style illustration generated for each.
After the first pass, the presenter gave two rounds of feedback worth noting for anyone applying the same approach: first, the text was too long and read like a complete summary โ a social post should land one sharp point, not cover every detail; second, the copy sounded "too AI" โ overusing buzzwords like "empower" and "underlying logic" โ and needed to sound more like something an actual person would say. After those fixes, the same logic was turned into a Skill, with instructions for Codex to automatically file each day's copy and images into a folder organized by date, so it's easy to look up later.
Just like the quote case, this content-rewriting pipeline can also be wired to an email extension, so that every morning Codex checks the subscribed inbox for new articles and, if there's one, automatically applies the Skill to produce multi-platform post drafts, ready for review after the presenter wakes up. Notably, the presenter states that even though the "auto-publish" step is technically possible to wire in too, they've deliberately chosen not to โ a social post represents their own point of view, and they'd rather personally look at every single one before it goes out than risk losing control over output quality.
AI Handles Most of the Work, But the Review Step Stays
The video closes with two experience-based takeaways worth remembering alongside everything above.
First, the realistic framing for these automation pipelines is that AI handles roughly 80โ90% of the repetitive work, while the remaining 10โ20% โ review and judgment calls โ still needs a human in the loop. It's not "set it up once and never look at it again."
Second, after adjusting a prompt or a Skill's rules, don't ship based on a gut feeling from running it once or twice and liking the result. The more rigorous approach is to prepare a batch of test cases (say, a hundred-plus different scenarios), run the whole batch, and score the outcomes using another model or some quantitative method โ confirming that the change actually fixed the original problem rather than quietly introducing new errors elsewhere. That's a habit worth building for anyone planning to put an automation pipeline in front of actual clients.
FAQ
Q1: Can someone with no coding background actually learn this workflow? The presenter states they have no programming background and worked out this approach through self-study. Codex's interface is built around natural-language instructions and doesn't require writing code by hand, but the cloud deployment and third-party account integration steps do call for a certain amount of technical understanding. It's worth getting comfortable with the local-only steps first before attempting the more advanced cloud wiring.
Q2: How is a Skill different from a regular prompt? A regular prompt is typically an improvised description of what you need for a single task. A Skill packages up what needs to be done, what format the output should take, and what lines can't be crossed into one fixed document โ so afterward, you just supply new input data and the same logic produces the result, without redescribing the requirement each time.
Q3: What's the difference between local and cloud automation โ do you have to go all the way to the cloud for this to "count"? Local automation means both the scheduling and the trigger run on your own computer โ once it's off or asleep, the pipeline pauses. Cloud automation deploys the same logic to a cloud server, so the pipeline keeps running even with your local machine shut down. Whether you need to go to the cloud depends on your use case โ if it's just for your own occasional use, local automation may be enough; if you're serving clients or a team around the clock, the cloud is the more stable option.
Q4: Does turning a business process into an automation pipeline burn a lot of tokens or get expensive? Whether it ends up burning "a lot" depends on the model tier, effort and speed settings you choose, and how often the pipeline triggers. For a closer look at what actually drives token consumption and how to control the cost, there's a related piece covering five tested ways to reduce token costs in AI coding โ the same cost logic applies directly to tuning these kinds of automation pipelines.
Q5: The presenter mentions their AI agency does "over a million dollars" in revenue and has a "12,000-person" community โ is that verifiable? These figures come from the presenter's own self-introduction and marketing framing at the start of the video. They are the creator's own claims. This site has not independently verified either figure, and citing them here does not constitute an endorsement or recommendation from AI Token King. Readers should focus on the operational value of the tutorial steps themselves rather than treating the presenter's stated personal or business achievements as verified facts.
Source disclosure: This article is adapted from a video published on the YouTube channel "ๆๅๅฉ | AI" (Harry Li) on August 31, 2026, titled (translated) "The Most Complete 2.5-Hour Codex Masterclass: Building a 24/7 Unattended 'One-Person AI Company' From Scratch." The steps and cases described are a restructured summary and retelling of that video's content, not a word-for-word translation. The opening portion of the video, where the presenter describes their own AI agency's revenue and community size, reflects the creator's self-reported claims only, has not been verified by this site, and does not represent an endorsement by or the views of AI Token King. Codex's feature names, interface, and specific behavior should be confirmed against OpenAI's current official documentation, since actual functionality may differ across version updates.
Further reading on this site covers what OpenAI Codex actually is and how it compares to ChatGPT and Claude Code, why AI tokens get expensive once you break down how autoregressive generation burns through them, five tested ways to bring down token costs in AI coding workflows, and how to prompt Claude Opus 5 and Fable 5 based on Anthropic's own guidance.
If you're planning to bring a tool like Codex into your own business workflow, the model tier, effort level, and speed you choose all show up directly on your monthly bill. Try AI Token King free โ (https://aitokenking.com.tw/home), and turn what different models and setting combinations actually burn in tokens into a usage record you can check โ one more piece of hard data to work from when you're picking a model or tuning your settings.
