Enterprise Agent Skills Development in Practice: Upgrading AI Coding from Writing Code to Writing Skills

From "Writing Code" to "Writing Skills": AI Coding Is Shifting Gears

In this Bilibili hands-on course, the instructor opens with a provocative point: if you're still using AI coding tools in the most basic CRUD (Coding) way — just asking it to "write me a feature" — you're essentially using "fake AI coding" and are already falling behind.

What's actually being adopted at leading tech companies is a shift in focus: from writing code directly to developing Skills. According to the instructor, engineers at major tech firms spend roughly 70–80% of their AI-assisted programming time writing Skills, with relatively little time spent on raw business logic. The reasoning behind this is worth every developer's attention.

Why Skills Beat Writing Code Directly

You've probably heard the warning: let AI write too much code directly, and your project will eventually turn into a "spaghetti mess" — hard to maintain and impossible to scale. The instructor's explanation is straightforward: if you let AI tools natively generate raw feature code from scratch, your project will likely spiral out of control over time.

But flip the script: have AI spend most of its time developing Skills, then let those Skills generate the business code, and code quality improves dramatically. The reason is that Skills make the code generation process more controllable, easier to collaborate on, and sustainably maintainable.

The Essence of a Skill: Crystallizing Repetitive Work

A "Skill" is exactly what it sounds like — a reusable capability. Its core value lies in hardening the repetitive, everyday tasks you perform into a fixed, callable form. For Java developers, things like caching architecture, distributed transaction patterns, and microservice scaffolding — all the stuff you reach for constantly — can be packaged as Skills. This frees you from repeating the same work over and over, leaving time for higher-value tasks.

A simple Skill might be nothing more than a few well-crafted prompts. A more complex one can include code, scripts, and even compose into a full automated workflow.

From a software engineering perspective, a Skill is essentially a "parameterizable code generation template" paired with contextual constraints. It typically has three layers: the first is a Prompt that describes what to generate and what standards to follow; the second is example code or scaffolding snippets that give the model a style reference; the third is an optional automation script that writes generated output to the right directory and triggers compilation or tests. This concept is closely related to traditional "Code Generators" — the key difference is that conventional generators have hard-coded rules, while Skills leverage LLMs for semantic understanding, enabling them to handle fuzzier, more complex requirement descriptions. Once Skills are version-controlled, every team member calling the same Skill produces code with consistent style and architecture decisions, fundamentally solving the pain point of "AI-generated code being stylistically inconsistent and hard to review."

Choosing Between Three Mainstream Agent Tools

The course demonstrates three Agent coding tools and clearly defines where each fits:

• Codex: Backed by the latest version of ChatGPT by default, with strong visualization capabilities. Suitable for all skill levels and ideal for developing relatively simple Skills. The instructor advises against swapping out the backend model — Codex is optimized for ChatGPT.
• Claude Code: Currently one of the most capable AI coding tools in the world. More specialized, better suited for experienced developers handling complex enterprise scenarios like Java architecture, Redis caching, and production incident debugging. In this course, Claude Code is configured to use Zhipu GLM (latest version) on the backend, to avoid the risk of Claude account bans.
• Work Body (Tencent): Similar in usage to the other two, with strong visual tooling. A good fit for developers who can't access overseas networks. In the course, it's configured with DeepSeek^Ad on the backend for cost efficiency.

The instructor also notes that the mainstream domestic tools include CodeBuddy (Tencent), Trae (ByteDance), Alibaba Tongyi Qianwen, and Xiaomi MiMo. All of these are fundamentally "Agent-class tools" — they enable LLMs to complete complex, multi-step tasks and are applicable to both development workflows and general productivity tasks.

The core distinction between Agent-class tools and ordinary AI chat assistants is this: Agents have the ability to autonomously plan and execute multi-step tasks, calling tools like the file system, terminal commands, and external APIs — not just generating text. In coding contexts, an Agent tool can independently read project code, run tests, iterate on fixes based on error messages, and see the task through to completion — all without requiring the developer to manually confirm each step. These tools are typically built on the "ReAct (Reasoning + Acting)" framework, where the model cycles between reasoning and taking action until the goal is achieved. It's precisely this ability to autonomously complete complex tasks that allows Agent tools to actually execute the multi-step workflows defined by Skills, rather than merely generating a code snippet for the developer to paste manually.

Practical Cases: From WeChat Official Accounts to Xiaohongshu Automation

The course follows a progressive teaching structure, walking through seven, eight, or even dozens of Skill examples with full live coding demonstrations.

Beginner Case: Auto-Generating WeChat Official Account Articles

The first demo has Codex and Work Body each write an introductory article titled "Getting Started with Codex." The result confirms a well-known pain point: if you just throw in "write me an article," AI tends to go off in its own direction, producing content that feels completely disconnected from the author's voice.

The instructor's key fix: thoroughly summarize and codify your writing style and pass it to the AI. This is exactly where Skills shine — packaging "my style requirements" into a reusable capability rather than describing them ad hoc every time. This also explains why most viewers in the live session reported that AI-generated articles straight out of the box "didn't meet their expectations."

Intermediate Case: Automated Xiaohongshu Post Publishing

For creators managing Xiaohongshu (RedNote), the instructor demonstrated an automated publishing Skill: what used to require manually logging into a site and posting piece by piece can now be done by writing the content (or having AI draft it) and executing the Skill to publish everything automatically — multiplying efficiency.

Advanced Case: Incremental Refactoring with Skills

The scenario that best demonstrates the power of Skills is "incremental refactoring." The instructor uses Redis caching as an example: building a cache from scratch isn't particularly hard, but adding a cache layer to an existing feature that doesn't have one is. This kind of incremental improvement to existing codebases is where Skills truly excel — ensuring that changes are made consistently and according to spec.

Redis caching refactoring is such a canonical test of Skill capability because it involves multiple cross-cutting concerns that must be handled simultaneously: read/write-through, cache penetration, and data consistency. When done manually, developers often miss an update path, leading to stale data between cache and database. By packaging this refactoring pattern into a Skill, every execution automatically enforces and generates complete cache invalidation, update, and warm-up logic — essentially crystallizing the expertise of a senior engineer into a repeatable, automatable process. This mirrors the "Infrastructure as Code" philosophy from the DevOps world: transforming operations that previously depended on individual tribal knowledge into auditable, version-controlled, automatable standard procedures. The result is reduced team dependency on specific individuals and a safer path for junior developers to make incremental changes to production codebases.

Practical Advice for Developers

The takeaway from this course isn't about any particular tool — it's about a shift in engineering mindset. Here are a few actionable paths to draw from:

1. Stop "hand-crafting everything" and pure manual CRUD, but also don't stay stuck at the beginner level of "one-liner prompts to write a feature."
2. Crystallize your team's frequently reused architecture patterns and standards into Skills — caching, distributed transactions, microservice templates, and so on.
3. Choose tools by use case: use Codex or Work Body for simple visual tasks; use Claude Code for complex enterprise scenarios.
4. Swap LLM backends flexibly: Claude Code can use GLM; Work Body can use DeepSeek — balance cost and availability.

Skills move AI coding from "one-off generation" to an engineering system that is maintainable, collaborative, and cumulative — and that's what fundamentally sets it apart from simply having AI write code.

Note: This article is based on a live hands-on course streamed on Bilibili. Specific demo results and tool versions reflect the live session at the time of recording.