A Chinese Curriculum for the Agent-Coding Era

The Hype Moment Is a Documentation Crisis

By early 2026, the terminal has become an unlikely cockpit for autonomous software agents. OpenAI’s Codex CLI, launched in April 2025, now claims roughly four million weekly active users. Anthropic’s Claude Code has attracted serious engineering firepower—Boris Cherny, its creator, reportedly wrote one hundred percent of his recent contributions to the tool using the tool itself, while Google Principal Engineer Jaana Dogan used it to prototype in an hour what her team had spent a year pursuing. Cline, an open-source Apache 2.0 alternative, reports more than eight million developers and sixty-four thousand GitHub stars. These are not autocomplete plugins; they are agents that read repositories, edit files, run tests, commit code, and even digest Jira tickets and Slack threads to produce architectural documentation.

The shift is structural. Multiple observers note that software engineering is splitting into two modes: vibe coding, where non-coders describe end products and hope, and AI-assisted coding, where engineers iteratively steer agents through architecture and review. In both cases, the human bottleneck is moving from syntax to systems thinking. Engineers who collaborate effectively with these tools are expected to hold substantial advantages. But there is a catch. Official documentation is fast-moving, English-centric, and assumes deep command-line fluency. Third-party tutorials often recycle screenshots and unverified flags. Into this vacuum, a Chinese-language repository has accumulated attention not because it invents a new runtime, but because it treats the agentic transition as a learnable discipline. It is a field manual, not a README.

Editorial Rigor as a Feature

The repository contains ninety-two polished tutorials—fifty-three for Claude Code, thirty-nine for Codex—structured as a sequential curriculum. What distinguishes it from typical blog posts is an almost stubborn editorial methodology. The author grounds every feature description in official documentation from Anthropic and OpenAI, explicitly rejecting third-party guesswork. Each article follows a three-part pedagogy: scenario introduction, lived analogy, and practical application. The prose is peppered with first-person failure reports—specific token counts, exact error messages, and timing—rather than vague impressionism.

This matters because these tools are deceptive. They look like chatbots but behave like junior developers with sudo access. A tutorial that omits the exact moment an agent hallucinates a dependency or misinterprets a sandbox approval is worse than useless; it is dangerous. The guide also includes original visual assets—sixty-four dark-themed diagrams, styled after the Catppuccin Mocha palette and mimicking the Claude Code CLI session aesthetic—to keep cognitive load low. The site runs on VitePress with Shiki highlighting, mermaid diagrams, and Open Graph cards, but these choices serve readability, not vanity. Most tellingly, the project claims to have undergone four rounds of review, including a pass by sixteen sub-agents. Whether that is a boast or a warning about the current era is left as an exercise for the reader.

The Two Horses: Claude Code and Codex

The curriculum does not pick a winner. It treats Claude Code and Codex as parallel tracks, acknowledging that the two tools share a philosophy—natural language delegation in a terminal context—but diverge in execution. Claude Code is terminal-native, deeply integrated with Anthropic’s model stack, and favored by developers who want tight shell integration with existing utilities. Codex has pushed into graphical interfaces; one comparative review notes an embedded browser and motion-graphics workflows alongside its terminal core. That same review frames Codex as an all-in-one platform, arguing that a graphical interface beats terminal-based interaction for most users.

The guide is pragmatic about the rivalry. It notes that Claude Code has suffered rate-limit regressions and cache bugs that inflated token consumption by an order of magnitude, while Codex has introduced reinforcement-learning-trained subagents that fire dozens of parallel tool calls and slash codebase search times from minutes to seconds. Codex’s skills system, launched in December 2025, lets users define capabilities in markdown files that the agent loads automatically when a task matches. One such skill, WarpGrep, achieves a median codebase search time of five seconds compared to seventy-five seconds for Claude Code’s Explore subagent, and pushes Codex’s SWE-bench Pro score to fifty-nine percent while using fewer tokens. By teaching both, the repository functions as a bilingual dictionary for developers who may need to switch ecosystems mid-project. It even includes a dedicated migration path for users moving from Claude Code to Codex, a recognition that loyalty is expensive in a market where pricing and performance swing monthly.

Why the Boring Part Is the Value

The least glamorous sections are arguably the most important. The guide includes a basic introduction track for readers who have never used a command line, and it insists on hands-on verification: every tutorial pairs instructions with expected output so readers can confirm the agent is behaving. This is tedious to write and expensive to maintain, but it addresses a real friction point. One Stack Overflow analysis argues that AI agents lack the tacit, vibe-based context that human developers acquire through osmosis. They need explicit standards—naming conventions, indentation rules, and deployment procedures—spelled out with bureaucratic clarity. The piece quotes Heroku’s chief architect noting that agents require explicit prompts for principles like DRY and separation of configuration from code; otherwise they generate unmaintainable applications.

Stormzhang’s guide essentially extends that logic to the learner. If you are going to let an agent rewrite your codebase, you must first understand how to read the diff, how to roll back, and how to verify that the terminal output matches the promise. The repository treats these not as footnotes but as core competencies. In an era where some developers are building bespoke CLI tools in single afternoons using templating engines and HTTP clients, knowing how to verify an agent’s work remains the harder skill.

Position in a Crowded Field

The ai-coding-guide is not the only attempt to corral this chaos. The aicodeguide repository by Vilson Vieira and Eric S. Raymond takes a broader, FAQ-style approach, curating tools like Cursor and protocols like MCP and A2A for a global audience. It contextualizes modern LLM-driven generation within a longer history, noting that automated code generation dates back to the 1950s with Lisp. Cline offers an open-source runtime with deep IDE integration, Plan and Act modes, per-step approval, multi-agent teams, and headless continuous-integration execution. Users can encode coding standards in configuration files, echoing the same need for explicit agent guidelines. Meanwhile, individual developers are assembling personal toolchains like Pinocchio and Geppetto, treating LLM interaction as just another shell script.

Against this backdrop, stormzhang’s project is narrower and more conservative. It is not a tool, a framework, or a protocol spec. It is a textbook—static, editorial, and deliberately scoped to two proprietary products. Its impact is localized: it lowers the activation energy for Chinese-speaking developers to join the agentic coding wave without relying on machine-translated changelogs or Discord rumors. In a landscape where Cline runs headless in pipelines and Codex chases four million weekly users, a well-maintained tutorial series is a deceptively scarce commodity.

Honest Friction

The repository is upfront about its constraints. Both Claude Code and Codex require network conditions that the README euphemistically labels as needing magic internet, a non-trivial barrier for mainland Chinese developers. The tools themselves are not free; the cheapest subscriptions start around twenty dollars monthly. And because both products iterate rapidly—OpenAI’s skills system launched in December 2025, and Anthropic’s session limits were intentionally tightened in March 2026—the guide commits to incremental maintenance tracked via commits rather than claiming permanence.

It also does not cover the wider ecosystem. There is no Cline track, no Cursor deep-dive, no local Ollama workflow. If you are looking for a universal survey of AI coding agents, this is not it. The value is depth, not breadth.

The Pedagogical Gap

The broader significance of ai-coding-guide may be what it portends. Software engineering is splitting into two modes: vibe coding, where non-coders describe end products and hope for the best, and AI-assisted coding, where engineers iteratively steer agents through architecture and review. The latter requires a new literacy—part prompt engineering, part systems administration, part code review. Current computer science curricula do not teach this; bootcamps barely touch it. As agents produce more code, the cognitive burden shifts to design, architecture, and review.

A ninety-two-article manual that treats agentic tools as serious infrastructure, complete with anti-patterns, FAQ, and glossary, is an early draft of what that curriculum could look like. Whether it remains relevant will depend on how quickly the underlying tools mutate. For now, it serves as a reminder that every shift in tooling eventually needs a textbook. Even—perhaps especially—when the tool itself is supposed to write the book for you.