Claude Code Skills in Practice: A Progressive Guide to AI Programming from Writing Code to Writing Skills

Why Enterprise AI Programming Is Shifting from "Writing Code" to "Writing Skills"

In an era where AI programming tools are already widespread, many developers still stick to the most primitive usage: telling AI tools like Cursor, Claude Code, or Codex to "build feature X for me." This approach seems efficient but harbors hidden risks.

According to hands-on experience shared by a tech instructor on Bilibili, if you simply let AI programming tools natively develop features one by one, your project will most likely devolve into "spaghetti code" over time—difficult to maintain and impossible to collaborate on. The approach actually used in major tech companies is to spend more AI programming time developing Skills (capability packages), then let those Skills generate the actual code.

The instructor offered a striking insight: in some mature enterprises, when programmers use AI programming tools, roughly 70%-80% of their time is spent writing Skills, while the time actually spent writing business code is comparatively small. The core logic of this workflow is to distill frequently repeated, commonly used development patterns (such as caching architectures, distributed transactions, and microservice architectures) into Skills, letting AI produce code through Skills for more controllable quality, easier team collaboration, and long-term maintainability.

The concept of Skills didn't emerge from thin air—it's essentially an extension of "design patterns" and "best practices" thinking from software engineering into the AI era. In traditional development, knowledge systems like GoF design patterns and enterprise application architecture patterns helped teams establish unified code organization approaches. But these patterns relied on individual developers' experience and learning, with significant deviation at the execution level. Skills make this tacit knowledge explicit and structured, so that when AI generates code, it no longer relies on the "average level" found in general training data, but executes according to team-predefined specifications and architectures, dramatically reducing the uncertainty of AI output.

Developing Skills

What Are Skills (Capability Packages)

Skill literally translates to "ability" or "technique." Its essence is encapsulating a category of repetitive work into reusable capability units. A simple Skill might just be a carefully crafted prompt; a complex Skill can embed code, scripts, and more to handle enterprise-level development scenarios.

In other words, a Skill is an intermediate layer between a "one-sentence instruction" and "complete code." It carries the knowledge of "how to do it," giving AI a clear playbook to follow during execution rather than improvising from scratch every time. From a software engineering perspective, Skills are similar to a combination of executable "Architecture Decision Records (ADRs)" and "code templates"—they not only document "why we do it this way" but also contain the executable logic of "exactly how to do it," achieving a closed loop from documentation to execution.

Selection Strategy for Three Mainstream Agentic Programming Tools

The instructor demonstrated three tools simultaneously in practice and made clear distinctions based on use cases.

So-called Agentic programming (agent-based programming) is one of the most important paradigm shifts in AI development during 2024-2025. Unlike traditional Copilot-style "auto-completion," Agentic programming tools possess capabilities for autonomous planning, tool invocation, environment interaction, and self-correction. They no longer passively respond to developers' line-by-line instructions but can autonomously decompose tasks and execute multi-step operations after receiving high-level goals. Devin, Codex Agent, Claude Code, and similar tools all belong to this paradigm. Gartner predicts that by 2028, 75% of enterprise software engineers will use AI coding assistants, with Agentic architectures becoming the mainstream form.

Codex and Claude Code: The Two Most Capable AI Programming Tools Globally

From a global perspective, Codex and Claude Code are currently the two most capable AI programming tools.

OpenAI Codex was originally released in 2021 as the underlying engine for GitHub Copilot. In 2025, OpenAI launched the entirely new Codex agent, which runs in a cloud sandbox environment, can process multiple programming tasks in parallel, and supports the complete development workflow including code writing, debugging, and testing. Unlike earlier versions, the new Codex is based on the codex-mini model (a customized version of o3-mini), specifically optimized for programming tasks. Its core advantage lies in being able to read the entire code repository's context, understanding the project structure before generating code, rather than processing individual files in isolation. Codex's default backend integrates the latest GPT version—this is its most compatible combination, and switching to other LLMs is generally not recommended.

Selection Considerations

Claude Code is a command-line AI programming tool released by Anthropic, based on the Claude series of LLMs. Its unique advantage is the ultra-long context window (supporting up to 200K tokens), meaning it can understand a large project's complete codebase in one pass. Claude Code adopts an Agentic architecture, capable of autonomously planning tasks, editing files, running tests, operating Git, and more. However, Anthropic imposes strict geographic and rate limits on API usage—accessing through VPNs causes frequent IP address changes, which easily triggers risk control mechanisms and leads to account bans.

Therefore, the instructor chose a compromise in practice: installing the Claude Code plugin in VS Code with Zhipu GLM as the backend LLM. Zhipu AI is an artificial intelligence company incubated by Tsinghua University's technical team. Its GLM (General Language Model) series is based on a proprietary GLM pre-training architecture, using autoregressive blank-filling training, excelling in bilingual Chinese-English tasks. The latest GLM-4 series approaches GPT-4 levels in code generation and mathematical reasoning, with natural advantages in Chinese-language scenarios. Since servers are deployed domestically in China, response latency is low and compliance risk is minimal, making it an important alternative to overseas models. This setup lets you enjoy Claude Code's engineering capabilities while avoiding the risk of account bans caused by IP changes from VPN usage.

WorkBuddy: An Alternative for Everyone

For developers who cannot or prefer not to use foreign networks, the instructor also demonstrated Tencent's WorkBuddy with DeepSeek integrated as the backend (offering the best cost-performance ratio). These tools have stronger visualization capabilities and are suitable for everyone to get started with.

The logic of tool selection is clear:

Simple Skills (e.g., WeChat Official Account formatting, automated image-text publishing) → Use Codex or WorkBuddy—visualization-friendly, low barrier to entry
Enterprise-level Skills (e.g., Java architecture, Redis caching architecture, production issue troubleshooting) → Use Claude Code—more professional, better suited for deep developer use

You might not have noticed, but beyond the tools themselves, the choice of backend LLM is equally critical. The instructor mentioned that domestic options like Zhipu GLM, Alibaba Qwen, Xiaomi MiMo, and DeepSeek are all excellent choices currently, with DeepSeek being known for its cost-effectiveness.

From Beginner to Advanced: Three Levels of Skill Development

The instructor's course follows a "shallow to deep" approach, covering the complete path from zero-foundation to enterprise-level.

Level 1: Content Automation Skills

The most basic is the WeChat Official Account formatting Skill, which involves virtually no complex technology—it's essentially about writing good prompts. During the live demonstration, the instructor used both Codex and WorkBuddy to generate an article titled "Getting Started with Codex," showcasing basic content generation capabilities.

More practical is the Xiaohongshu (RED) automated image-text publishing Skill. For content operators who need to publish multiple Xiaohongshu posts daily, the original workflow required manually logging into the website and publishing posts one by one. After mastering this Skill, you only need to write the article (or even have AI write it), then execute the Skill with one click for fully automated publishing—multiplying efficiency. These Skills typically combine browser automation tools (like Playwright or Selenium) to automate web operations, encapsulating login, content filling, image uploading, clicking publish, and other manual operations into a one-click executable script workflow.

Feature Development

Level 2: Quantitative Analysis Skills

Moving up, we reach Skills involving code, such as the "A-Share Quantitative Analysis Skill." These Skills need embedded analytical logic and scripts, graduating from pure prompts to a combination of code and prompts. Quantitative analysis in technical implementation typically involves data collection (obtaining market data through financial data APIs), indicator calculation (technical indicators like MACD, RSI, Bollinger Bands), and strategy backtesting (validating trading strategy effectiveness on historical data). Once these steps are encapsulated as Skills, developers only need to describe their analysis objectives, and AI can invoke the predefined analytical framework to generate complete quantitative analysis reports or trading signals.

Level 3: Enterprise-Grade Secondary Development Skills

The most complex are enterprise-level Skills, which also demonstrate the greatest value. The instructor specifically emphasized the concept of secondary development:

Writing a Redis caching architecture from scratch isn't actually that difficult—the real challenge is adding caching on top of a feature that originally didn't have it. This is a typical secondary development scenario. Redis (Remote Dictionary Server) is an open-source in-memory data structure store, widely used for caching, message queues, session management, and other scenarios. In enterprise applications, introducing Redis caching involves far more than simple read/write operations—it requires solving a series of architectural challenges including cache penetration (massive requests bypassing cache and hitting the database directly), cache avalanche (large volumes of cache expiring simultaneously causing sudden database pressure spikes), cache breakdown (hot keys being hit by high-concurrency requests at the moment of expiration), and data consistency (synchronization strategies between cache and database).

Secondary development is more challenging than building from scratch because it requires precisely inserting caching logic at the data access layer without breaking existing business logic, while properly handling transaction boundaries, exception rollbacks, cache update strategies, and more. With just a few sentences invoking the corresponding Skill, you can systematically layer caching, distributed transactions, microservices, and other architectural capabilities onto existing code.

The distributed transactions mentioned here represent one of the thorniest technical challenges in microservice architecture. When a business operation needs to span multiple services and multiple databases, traditional ACID transactions cannot be directly applied. Common industry solutions include Two-Phase Commit (2PC), TCC compensation pattern (Try-Confirm-Cancel), Saga pattern, and eventual consistency based on message queues. Each solution has its applicable scenarios and trade-offs. Encapsulating such complex architectural capabilities as Skills means teams can standardize validated transaction handling strategies, avoiding architectural chaos caused by different developers choosing different approaches.

This is precisely the value of "letting Skills drive code generation": code quality is more controllable, team collaboration is easier, and long-term maintenance is sustainable—rather than gradually deteriorating into spaghetti code as the project grows.

AI Engineering: From Piling Up Code to Building Skill Systems

The core message conveyed in this hands-on session actually transcends the operation of specific tools: The advanced form of AI programming isn't having AI pile up code directly, but building reusable Skill systems to achieve engineered, systematic AI programming.

From an industry trend perspective, this paradigm shift is in line with several major evolutions in software engineering history. From assembly to high-level languages, developers said goodbye to directly manipulating hardware registers; from procedural to object-oriented, code reusability and maintainability improved dramatically; from monolithic to microservices, system resilience and scalability were liberated. Now the shift from "writing code directly" to "writing Skills for AI to generate code" is essentially another leap in abstraction level—developers' core work elevates from "writing implementation details" to "defining engineering standards and architectural patterns," while delegating the actual code implementation to AI executing according to predefined Skills.

For developers still "hand-coding the old-fashioned way" or merely at the stage of "having AI write features for me," transitioning to a Skill-driven development paradigm means delegating repetitive labor to standardized capability packages and freeing up precious time for more valuable work. This represents both an efficiency gain and a guarantee of team collaboration and engineering quality.

It's worth noting that building a Skill system is itself an accumulation of organizational capability. When senior engineers on a team encapsulate years of accumulated architectural experience, best practices, and hard-learned lessons into Skills, this knowledge is no longer locked inside individuals' minds—it becomes shared, iterable digital assets for the team. When new members join, by using the team's accumulated Skill library, they can quickly produce high-quality code that meets team standards, dramatically shortening the cycle of knowledge transfer and training.