AI Engineering in Practice: The Complete Workflow of Claude Code and Agent Skill Development

AI programming tools have evolved from "writing code for you" to "building tools for you." In a hands-on course on Bilibili, instructor Zhuge makes a noteworthy claim: if you're still using AI to directly write business code, you may only be using "fake AI programming." The truly engineered approach is to have AI develop Agent Skills, then use those Skills to drive code generation.

From "Writing Code" to "Writing Skills": The Paradigm Shift in AI Programming

The course opens with a sharp assertion: if you simply let AI programming tools generate business feature code directly, over time the project will most likely turn into an unmaintainable "pile of garbage code." But if you spend most of your time developing Skills and let Skills generate the code, code quality and maintainability improve significantly.

The logic behind this judgment isn't complicated. A Skill essentially encapsulates repetitive work into reusable capability units—caching architecture, distributed transactions, microservice templates—all the problems developers encounter repeatedly can be distilled into Skills. According to the course, among programmers at big tech companies, the proportion of time spent directing AI to write Skills far exceeds that spent writing code directly.

This also explains why the course emphasizes "enterprise-grade Agent Skills" rather than personal toy scripts: the value of a Skill lies in team collaboration and long-term maintenance, not one-off generation.

Agent Skill refers to a reusable capability encapsulation designed for AI Agents: it typically consists of prompts, tool-call descriptions, examples, and necessary scripts, enabling the Agent to exhibit stable, professional behavior on specific tasks. Unlike ordinary prompts, Skills emphasize reusability, composability, and version management—like installing a "skill pack" onto AI. In engineering practice, Skills can cover code generation standards, architecture templates, troubleshooting workflows, and more, making AI output more controllable and consistent.

Garbage code (屎山代码) is developers' colloquial term for a codebase that has long lacked design, been piled up layer upon layer, and is difficult to maintain. Its typical characteristics are duplicated logic, severe coupling, and changes in one place affecting everything. AI directly generating business code tends to breed garbage code because each generation lacks unified constraints, resulting in inconsistent style and structure that, once accumulated over time, sharply drives up maintenance costs.

Three Mainstream Agent Tools and Backend Model Choices

The course demonstrates three Agent tools: Codex, Claude Code, and WorkBuddy^Ad (Tencent). Codex integrates ChatGPT by default; Claude Code typically works best with Claude models, but due to account-ban risks, the course author connected Zhipu GLM in Claude Code instead. WorkBuddy uses DeepSeek^Ad, chosen for its high cost-effectiveness.

On tool selection, the course offers practical advice: use Codex or WorkBuddy for simple Skill development, as they offer stronger visualization and a lower barrier to entry; for complex enterprise-grade architecture Skills (such as Java architecture patterns, Redis caching architecture, online troubleshooting), hand them to Claude Code. For domestic developers who have trouble accessing overseas networks, WorkBuddy paired with DeepSeek is a viable alternative.

At the model level, the course notes that GLM ranks among the top in China and DeepSeek stands out for cost-effectiveness; Doubao, Tongyi Qianwen, and Xiaomi MiMo are also viable options. The key conclusion: tools and backend models must match. Codex is best suited to ChatGPT; forcing a model swap isn't impossible, but effectiveness suffers.

Codex, Claude Code, and WorkBuddy represent three product forms of AI programming Agents. Codex is OpenAI's code generation and Agent capability, deeply integrated with the ChatGPT ecosystem; Claude Code is Anthropic's terminal-based programming Agent, skilled at multi-step tasks and operations on large codebases; WorkBuddy is Tencent's AI programming assistant aimed at domestic developers, supporting integration with various domestic large models. What the three share is the ability to plan autonomously, call tools, and execute multi-step tasks; they differ in ecosystem lock-in, degree of visualization, and network accessibility.

GLM and DeepSeek are mainstream domestic large model series. GLM, launched by Zhipu AI, performs strongly on Chinese understanding and code tasks; DeepSeek is known for high cost-effectiveness, with low API prices and solid coding ability. They are often used as domestic alternatives to overseas models, integrated into Agent tools via OpenAI-compatible interfaces to circumvent network and account restrictions.

Skill Development in Practice: From WeChat Article Drafts to Automated Xiaohongshu Posting

The course prepares seven or eight Skill cases, progressing from easy to advanced. The most basic case is automatic generation of WeChat official account article drafts—requiring only prompts, with no complex code involved. Advanced cases include a China A-share quantitative analysis Skill (involving code and scripts) and a Skill for automated publishing of Xiaohongshu image-text posts.

The Xiaohongshu case demo is quite intuitive: log into a test account, write the article content, and with one click execute the Skill to automatically publish the note—no need to manually log into the website and post one by one. The course author emphasizes the efficiency gain is "many times higher than before."

For the developer audience, the course focuses on secondary development scenarios. Take the Redis caching architecture as an example: adding caching capability on top of existing features is a typical secondary development. A few simple sentences asking AI to add caching may produce a huge pile of code—this is where Skills come in. This is far more complex than writing Redis caching from scratch, and much closer to real enterprise development scenarios.

Secondary development refers to incremental modification on top of an existing system or feature rather than building from scratch. In enterprise development, secondary development accounts for a large proportion, and the difficulty lies in both understanding the existing logic and ensuring new features don't break existing behavior. In such scenarios, AI tends to "over-generate," so using Skills to constrain the scope of changes and implementation patterns is especially important—which is why the course regards this as the scenario where Skill value is most prominent.

The Core Logic of Enterprise-Grade AI Engineering

The course repeatedly emphasizes a distinction: native development versus Skill-driven development. The former has AI directly produce feature code; the latter has AI produce reusable capability encapsulations, which then generate code. The course argues the latter is superior across three dimensions: controllability of code quality, team collaboration, and long-term maintenance.

This essentially corresponds to the core proposition of AI engineering: not to have AI replace developers in writing more code, but to have developers distill repetitive labor into assets. High-frequency scenarios like caching architecture, distributed transactions, and microservice architecture are exactly where Skills should cover most.

The course also notes that Java, Python, JavaScript, and other languages can all be used to write Skills, with no language restriction—lowering the barrier for teams with different tech stacks to adopt them.

Editor's Observations

The information density of this lesson centers on the "Skill-first" methodology. But as a text record of a livestream class, some demo details (such as specific Skill directory structures, debugging processes, and failure handling) are not fully presented in the material. Readers who want to reproduce the results should combine this with the course video for hands-on practice. In addition, the claim about "the proportion of time big-tech programmers spend writing Skills" is the instructor's personal experience-based judgment and lacks public data support; readers should treat it as a reference rather than a definitive conclusion.

One-line Summary

The AI programming paradigm is shifting from writing code directly to developing reusable Agent Skills to improve code quality and team collaboration efficiency.

Paragraph Summary

Based on instructor Zhuge's hands-on course on Bilibili, this article proposes that AI programming is undergoing a paradigm shift from "having AI directly write business code" to "having AI develop Agent Skills, which then drive code generation." Direct code generation easily leads to unmaintainable garbage code, whereas Skills encapsulate recurring problems like caching architecture and distributed transactions into reusable capabilities, performing better in quality, collaboration, and maintenance. The course compares three tools—Codex, Claude Code, and WorkBuddy—along with model pairings such as ChatGPT, GLM, and DeepSeek, recommending Codex or WorkBuddy for simple Skills and Claude Code for complex enterprise-grade architecture. The hands-on cases progress from easy to advanced, covering WeChat article draft generation, quantitative analysis, and automated Xiaohongshu posting, and emphasize that secondary development is the scenario where Skill value is most prominent.