Introduction
Over 18 days, I ran 400 tasks in Codex, consuming 71 billion tokens in total. The longest task ran continuously for 16 hours using GPT-5.6. However, I've noticed many users only use Codex at the most basic level — submitting requests directly in the chat box and stopping once a result is generated. This article breaks down Codex usage into 5 distinct levels, and explains why you need to reach Level 3 to turn Codex into a reliable production tool.
Level 1: Direct Task Submission
Level 1 is the simplest way to use Codex: submit tasks directly in the chat box. You can ask Codex to create a webpage, build a small game, or implement a simple feature, and it will usually produce a result that looks good in just a few minutes.
However, this approach has critical limitations. Once tasks become more complex, you'll often run into issues: the functionality doesn't match your expectations, the layout is unreasonable, or a single small change (like modifying one button) can cause the entire page to break. After several rounds of revisions, the work you completed earlier may also stop working. This is why Level 1 outputs are almost always just demos, and rarely evolve into long-term maintainable projects.
Level 2: Document-Driven Workflow
When you realize you need to help Codex remember what the project is supposed to do, you move to Level 2: document-driven development.
The workflow is:
- Create a dedicated project folder before starting work
- Prepare three core documents:
- Product requirements
- Software architecture
- Current progress
- You don't need to write these documents from scratch — ask Codex to ask you clarifying questions, then generate the documents based on your answers
- Before starting each new task, have Codex read these documents first, create a work plan, and confirm the plan with you before execution
- After completing the task, sync the results back to the progress document
This effectively gives your project an "external brain". Even if conversations get very long or you create new tasks, Codex will always understand what the product is supposed to do, where the project stands, and which parts should not be modified. At this level, you're no longer just thinking about prompts — you're thinking about product requirements, feature breakdowns, and software architecture.
However, documents can only prevent Codex from forgetting the project. They can't prevent it from breaking the project.
Level 3: Code Management
That's where Level 3 comes in: code management. This is the step that most Vibe coders overlook.
Many developers wait until the product is almost finished to save stable versions, but by then it's already too late. You should start using Git from the moment your project has its first working version. Think of Git as a game save system:
- Save a version every time you complete a stable feature
- Create a new branch before making major changes
- Merge the branch if changes work, or roll back if they fail
This gives you the confidence to let Codex make large-scale modifications without worrying that one mistake will require another AI to fix the problems created by the first one.
Level 2 solves the problem of "AI forgetting what it's doing". Level 3 solves the problem of "what if the AI breaks the project". With documents and version control in place, Codex can already complete projects reliably.
Level 4: Integrate with the Open Source Ecosystem
But if you have to build every capability from scratch, the efficiency is still too low. That's why Level 4 is about integrating with the open source ecosystem.
At this level, you can:
- Package your own workflows into reusable skills
- Directly use open source skills and complete projects from the community
A great example is ByteDance's Deer Flow, which I use frequently for research tasks. Previously, I would have to manually search for information, filter results, compare different viewpoints, and compile reports. Now, I just submit a research topic, and Deer Flow will call tools and agents to handle the entire research process and deliver the final report.
Deer Flow is just one example. GitHub has thousands of ready-made skills, agent frameworks, and open source tools available. You don't even need to understand how every line of code works. Just send the project URL to Codex and ask it to:
"Download this project, get it running, and tell me how to use it"Codex will read the documentation, set up the environment, resolve errors, and deliver a working version to you.
In my own usage, I've called over 1,000 skills, with "superpowers" being the most frequently used. At this level, Codex is no longer just a code generator — it can integrate existing capabilities directly into your workflow.
Level 5: Multi-Agent Collaboration
At Level 4, you still need to call skills and open source projects one by one. Level 5 is about multi-agent collaboration, where you submit a final goal and let Codex determine what capabilities it needs to use to complete the entire task.
Level 5 integrates all the previous four levels into a single system:
- A main agent first reads the project documents, manages versions with Git, and calls the necessary skills and open source tools
- Then it creates specialized agents for different stages:
- Market research agent
- Requirements organization agent
- Architecture design agent
- Software development agent
- Quality testing agent
- These agents work in parallel toward the same goal
- Finally, the main agent summarizes the results and delivers the complete project to you
Interestingly, the highest level actually brings you back to a simpler operation. You still submit tasks in the chat box, but there's a critical difference:
- Level 1: One AI gets the request and immediately starts generating
- Level 5: A main agent first understands the goal, then organizes an entire team of agents to work for you
The 16-hour continuous task I ran was completed using this multi-agent collaboration approach, covering everything from requirements analysis and market research to product design, development, and final delivery.
The power of Level 5 isn't about how many agents run at the same time — it's about you clearly defining the final goal, and letting the system break it down, organize the work, and complete the entire process.
Conclusion
Level 5 seems to come full circle. You're still submitting tasks in the chat box, but what you submit has changed. In Level 1, you submit a single instruction. In Level 5, you submit a complete, well-defined goal.
This is the journey from demo to production: starting with simple generation, moving through documentation and version control, leveraging the open source ecosystem, and finally orchestrating entire agent teams to deliver complete projects.
常见问题
Why do most users get stuck at Level 1?
Because Level 1 looks deceptively good. You type a task, Codex produces a nice-looking page or demo in minutes, and that feels like success. The problem only appears with complexity: mismatched functionality, broken layouts, and regressions where a tiny change breaks previously working code. Level 1 is fine for throwaway demos, but without documents and version control, those outputs rarely survive into maintainable projects — which is exactly why you need to reach at least Level 3 for real work.
What are the three core documents in Level 2?
Product requirements (what the product should do), software architecture (how the pieces fit together), and current progress (what's done and what's pending). You don't write them from scratch — you ask Codex to interview you with clarifying questions, then generate the documents from your answers. Before each new task, Codex reads these documents, drafts a plan, and confirms it with you. After finishing, it syncs the results back into the progress document.
Why is Git version control the most overlooked step?
Because most vibe coders only think about saving once the product is nearly finished — and by then it's too late. Git should start at the first working version. Treat it like a game save system: commit after every stable feature, branch before major changes, merge on success or roll back on failure. That safety net is what gives you the confidence to let Codex attempt large-scale modifications without fearing that one mistake will cascade into more AI fixes.
What's the real difference between Level 1 and Level 5?
In Level 1 you submit a single instruction and one AI immediately starts generating. In Level 5 you submit a well-defined final goal, and a main agent breaks it down — reading project documents, managing Git versions, calling open source skills — then spawns specialized agents (market research, requirements, architecture, development, testing) that work in parallel. You end up back at the chat box, but what you submit has changed from a prompt to a complete goal.