Codex Programming in Practice: Sandbox Isolation and Page Annotation Explained

Why Codex Is Worth Your Attention

In the top tier of AI programming tools, Codex and Claude Code are two names you can't avoid. A Bilibili creator with over a decade of online and offline teaching experience said plainly in a livestream: he has both installed, but Codex delivers a better experience in use. The reason isn't mystical — Codex is backed by the GPT series of models, which understand Chinese requirements more accurately, offer stronger requirement analysis, work across both frontend and backend, have a fast-growing MCP ecosystem, benefit from OpenAI's largest official investment, and come with a handy App — overall user experience wins out.

This judgment carries personal preference, but the direction is worth noting: choose tools not as a matter of faith, but by picking whichever is most convenient right now. The creator also candidly said that foreign models are temporarily a little ahead, but they'll catch up sooner or later — and at that point, the choice comes down to whoever is cheaper.

Agent Tools ≠ Large Models

Many people treat Codex and Claude Code as "just another chat LLM" — that's misconception number one. The creator's analogy is apt: a large model is a brain that can only think; an agent tool is a brain fitted with hands, feet, and tools that can actually get things done for you.

This explains a common confusion — why some people can only look up information with ChatGPT, while others can have it modify code, run commands, and manipulate files. The difference isn't in the model itself but in the agent framework wrapped around it. The creator emphasized that whether or not you can program, this category of tools falls under "everyone must know": not knowing Java, not writing Python, not understanding LLM-related code — none of that stops you from getting started.

An agent is the key architecture that takes large models from "only able to talk" to "able to do things." It typically has four components: the model as the decision core; tools that provide external capabilities like reading/writing files, executing commands, and calling APIs; memory that preserves task context; and planning that breaks goals into multi-step actions. The model is only responsible for reasoning and judgment at each step — the actual hands-on capability comes from tool calls and the execution loop. That's why the same underlying model, wrapped in different agent frameworks, can produce wildly different results for users. Understand this architecture, and you'll see why choosing a tool means looking at both the model and the framework, not just parameters and benchmarks.

The Real Barrier Isn't Technology — It's Configuration

The livestream repeatedly mentioned that what blocks most people isn't a capability problem but the fiddly steps: account login, downloading and installing, model integration. When Codex was at its peak, people on Douyin were making money by helping others get through this whole process — the demand is real, and so is the barrier.

Behind this is the reality of the toolchain: Codex needs to be bound to a model to run, and costs vary noticeably across models. Claude Code pairs with the Claude model, which is on the pricier side; some switch to DeepThink models to cut costs, but the results genuinely don't match the original foreign versions. The creator himself went the route of pairing GPT with Codex. For absolute beginners, solving the "get it configured" problem is more practical than researching which model scores higher.

Sandbox Isolation: The Prerequisite for Letting AI Work Freely

Sandbox isolation, as in the title, is the foundation that lets agent tools execute commands safely. For AI to run scripts, modify files, and install dependencies for you, there must be a controlled execution environment that confines operations to an isolated space — avoiding damage to the system or data leaks.

This design determines the ceiling of the experience: without a sandbox, users don't dare let AI touch real projects; with a sandbox, AI can upgrade from "giving suggestions" to "taking action directly." In his comparison, the creator noted Codex's fast ecosystem growth — the maturity of infrastructure like sandboxes is exactly a reflection of ecosystem maturity.

For ordinary users, the takeaway is: when evaluating an AI programming tool, don't just look at model parameters — look at whether it dares let you hand over real tasks. If it does, the isolation mechanism is in place; if not, even the strongest model stays stuck in the chat box.

A sandbox is a restricted execution environment that, through OS-level isolation mechanisms, confines the files, network, and system resources a process can access to a defined scope. Common implementations include containers, virtual machines, and platform-native permission sandboxes. For AI programming tools, the essence of a sandbox is "least privilege": AI can only modify authorized project directories, and cannot read users' private files or execute dangerous system commands beyond its bounds. If a step exceeds the boundary, the environment simply refuses rather than causing damage. This is also why sandbox maturity is often used to gauge whether an agent tool is mature — it determines the ceiling of what capabilities can be opened up, and the trust baseline when users hand over real tasks.

Page Annotation and Skills Integration

Page annotation solves the "communication precision" problem. Describing UI elements in natural language tends to be vague; circling the target location directly on the page lets AI accurately understand where you want changes. This is especially friendly to non-professional developers — no need to learn precise technical jargon, just point and shoot.

Skills integration, meanwhile, modularizes capabilities. Common operations are packaged into reusable skills that AI calls on demand when handling tasks, rather than reasoning from scratch every time. The creator mentioned Codex's rapidly growing MCP ecosystem; Skills and MCP are essentially the same direction: turning tools from general-purpose assistants into assemblable experts.

These two capabilities combined point to the same trend: the competitive focus of AI programming tools is shifting from "how smart the model is" to "how smooth it is to use." The gap in user experience often hides in these unremarkable integration details.

MCP (Model Context Protocol) is an open protocol proposed by Anthropic to standardize how large models connect to external tools and data sources. Think of it as the "USB port" of the AI world: as long as a tool exposes its capabilities according to the MCP spec, any agent that supports the protocol can call it plug-and-play, with no need to write separate adapter code for each tool. Skills leans more toward the capability encapsulation layer, packaging a set of operation workflows into reusable modules. Both point the same way — MCP solves "how to connect," Skills solves "how to organize well." Ecosystem activity thus becomes an important selection criterion: the more tools that support MCP, the broader the scenarios an agent can reach, and the stronger its long-term extensibility.

Advice for Absolute Beginners

The creator's course positioning is clear: zero foundation, and you'll be fine practicing hands-on after class. Drawing on his views, here are a few pragmatic paths.

First, pick the tool before worrying about optimization. Codex and Claude Code are both top-tier — run a real task through each and use whichever feels smoother; don't agonize over selection for too long.

Second, treat configuration as lesson one. Account setup, installation, and model binding are unavoidable steps; spending time getting them done pays off more than studying advanced tricks.

Third, start with low-risk tasks. With sandbox isolation as a backstop, first let AI handle projects that don't involve core data, and expand the scope once trust is established.

Fourth, focus on the ecosystem rather than single points. Extensibility like MCP and Skills determines how far a tool can go; choose the one with an active ecosystem for greater long-term returns.

Tools will iterate, models will catch up, and the only constant is the hands-on logic of "configure it first, then get it running." That's also the core message the creator — who has taught for over a decade — wants to convey: don't be intimidated by jargon; taking action is the shortest path.