Codex + Claude Code + Enterprise Agent Skill Hands-On Tutorial

AI coding tools are evolving from "assisting with writing code" to "developing reusable skills." In a recent live stream, Bilibili creator Teacher Zhu fully demonstrated how to use three tools—Codex, Claude Code, and WorkBuddy—to develop enterprise-grade Agent Skills, with live case studies including WeChat public account message generation, China A-share quantitative analysis, and automated Xiaohongshu image-text publishing. This article, based on the course content, maps out an actionable path from environment setup to project implementation.

Why "Just Using AI to Write Code" Is Already Outdated

At the start of the course, Teacher Zhu raised a controversial point: if you're still using AI coding tools to directly generate business code, even with Claude Code, you're essentially doing "fake AI programming."

His logic: letting AI develop features in a scattered, ad-hoc way will, over time, almost certainly turn the project into an unmaintainable "pile of spaghetti code"; whereas if you let AI spend most of its time developing Skills, and then have those Skills generate code, code quality becomes more controllable, more team-collaboration-friendly, and more maintainable long-term. In his view, big-tech programmers may spend 70-80% of their future time writing Skills, and comparatively less time writing Claude code.

This view deserves developers' attention: the essence of a Skill is to distill repetitive work (such as caching architecture, distributed transactions, microservice architecture templates) into reusable instruction sets, so that AI outputs results following a standardized process rather than improvising from scratch each time.

Agent Skill is an emerging concept in the current AI engineering field, referring to encapsulating the processing flow, domain knowledge, constraint rules, and tool invocation methods of a specific task into reusable, composable instruction units. It differs from simple prompt templates: a complete Skill typically includes trigger conditions, execution steps, input/output specifications, exception handling logic, and may even embed scripts or call external APIs. Its intellectual roots trace back to software engineering concepts like "design patterns" and "playbooks"—solidifying expert experience into standard operating procedures so that AI agents execute along established paths when encountering similar tasks, rather than improvising each time. In the ecosystems of models that support tool calling, such as Anthropic's Claude and OpenAI's GPT, Skills are becoming a key middle layer connecting large model capabilities with concrete business scenarios, and an important means for enterprises to reduce uncertainty and improve maintainability when building AI applications.

Three Mainstream AI Coding Tools and Their Backend LLM Pairings

In the course, Teacher Zhu demonstrated the actual environments of three tools: Codex (already installed locally), Claude Code (integrated via the VS Code plugin), and WorkBuddy^Ad. Their positioning differs slightly:

• Codex and WorkBuddy: Stronger visualization capabilities, suitable for all students to get started, used for developing relatively simple Skills.
• Claude Code: More professional, suitable for programmers developing enterprise-grade scenarios, such as Java architecture, Redis caching architecture, and online issue troubleshooting.

The choice of backend LLM is another key decision. Codex integrates ChatGPT by default, which is the most compatible combination; Claude Code natively integrates the Claude model for best results, but carries a higher risk of account bans (in the course, the instructor avoided using Claude due to IP changes from VPN usage and instead integrated the domestic GLM model); WorkBuddy chose DeepSeek^Ad, focusing on cost-effectiveness.

This pairing strategy offers a lesson for domestic developers: tools and models can be decoupled, flexibly combined according to network conditions, cost budgets, and task complexity, without blindly trusting a single solution.

Codex, Claude Code, and WorkBuddy represent three types of AI coding tools. Codex was originally a series of code generation models launched by OpenAI, later evolving into a coding assistant integrated into ChatGPT, emphasizing natural language-to-code conversion and visual interaction. Claude Code is Anthropic's command-line/plugin-based coding agent, skilled at multi-file refactoring, long-context understanding, and complex engineering tasks, deeply bound to the Claude model. WorkBuddy is an AI workflow tool developed by a domestic team, positioned more toward low-barrier visual skill orchestration, often paired with domestic LLMs. The LLM decoupling trend behind these three is noteworthy: the tool layer handles interaction and process orchestration, while the model layer provides reasoning capability; the two are loosely coupled via API, allowing developers to flexibly swap models based on network environment, cost, and task type, avoiding lock-in by a single vendor.

Developing Your First Skill from Scratch: Automated WeChat Public Account Message Generation

The course follows a progression from easy to advanced. The first case is the simplest automated WeChat public account message generation Skill—low technical complexity, mainly accomplished through prompts, suitable for beginners to build confidence.

Next is an advanced case: the China A-share quantitative analysis Skill. This Skill begins to involve code and scripts, demonstrating that Skills can embed complex logic internally rather than only containing prompts.

More valuable for developers is the secondary development scenario. Teacher Zhu used Redis caching architecture as an example: writing a cache from scratch isn't hard; the hard part is "adding caching" to existing features—such refactoring is exactly where Skills shine. A few commands bring the Skill into play, generating a structured refactoring plan and avoiding the scattered code that results from AI improvising.

The course also mentioned that there were dozens of Skills involved on-site, covering development architecture, full automation workflows, and other scenarios.

Prompt-based Skills and script-based Skills are two stages of Skill maturity. Prompt-based Skills rely solely on structured instructions (role setting, output format, constraints) to drive the model to complete tasks; they have low development cost and fast iteration, suitable for scenarios with fixed formats and simple logic, such as message generation and copy rewriting. Script-based Skills embed executable code or tool calls (such as Python scripts, API requests, database queries) into instructions, enabling the Skill to complete tasks requiring determinism, such as data scraping, quantitative computation, and file operations. The key to script-based Skills lies in the division of labor where "instructions handle decisions, scripts handle execution": the model judges when to call which script, and the script guarantees the accuracy and reproducibility of computation results. The progression from prompt-based to script-based, and then to secondary development of existing systems, constitutes a typical path of Skill capability advancement.

Automated Xiaohongshu Image-Text Publishing: An Intuitive Case of Efficiency Gains

The most viral demonstration in the course was the Skill for automated Xiaohongshu image-text publishing.

Teacher Zhu opened a blank Xiaohongshu test account (with no notes) on-site and demonstrated that you only need to write the article (or even have AI write it for you), and with one click the Skill automatically completes the publishing. For Xiaohongshu operators who need to manually log into the website and publish post by post every day, the efficiency gain is orders of magnitude.

The significance of this case: Skills don't only serve programmers—operations staff and content creators can benefit equally. The boundaries of enterprise-grade Agent Skills are far broader than "writing code."

Implementation Advice for Developers

Drawing on the course content, implementing enterprise-grade Agent Skills can follow three principles:

1. Distill first, then automate: Prioritize writing the team's most frequently repeated architecture patterns (caching, distributed transactions, microservice templates) as Skills, rather than having AI directly generate business code.
2. Decouple tools from models: Codex + ChatGPT, Claude Code + GLM, and WorkBuddy + DeepSeek are all viable combinations; choose according to the scenario and avoid being locked into a single ecosystem.
3. Build team capabilities progressively: Start with prompt-based Skills, gradually transition to complex Skills containing code scripts, and finally move into secondary development scenarios.

The core judgment conveyed by the course is: the competitive edge in AI programming is shifting from "whether you can use the tools" to "whether you can design Skills." Whoever first distills repetitive labor into reusable skills will free up time for more valuable work.

One-line Summary

AI programming is shifting from writing code to developing reusable Agent Skills, with a hands-on path and implementation principles for three tools.

Paragraph Summary

Based on Bilibili creator Teacher Zhu's live course, the article argues that AI programming is evolving from "assisting with writing code" to "developing reusable skills (Skills)." The core view: directly letting AI generate business code in a scattered way easily produces unmaintainable "spaghetti," whereas distilling repetitive architecture patterns into Skills and having Skills generate code yields more controllable quality. The course demonstrates the environment setup and model pairing strategies for Codex, Claude Code, and WorkBuddy, and through cases like WeChat public account message generation, China A-share quantitative analysis, Redis caching secondary refactoring, and automated Xiaohongshu image-text publishing, shows the progression from prompt-based to script-based to secondary-development Skills. The article concludes with three implementation principles: distill high-frequency architecture into Skills first, decouple tools from models, and build team capabilities progressively.