Vibe Coding in Practice: Why Senior Engineers Write Skills, Not Code

From "AI Writing Code" to "AI Writing Skills": A Cognitive Upgrade Most People Miss

As more developers adopt AI programming tools like Claude Code, Codex, and Cursor, a critical question emerges: are we actually using AI programming effectively?

In this practical sharing session on enterprise-level Vibe Coding project development, the instructor presents a subversive viewpoint: If you're still just telling AI programming tools to "build this feature for me," you're essentially doing "fake AI programming" — and you're already falling behind.

First, let's clarify the concept of Vibe Coding. It was first coined by OpenAI co-founder Andrej Karpathy in early 2025, describing a fundamentally new programming paradigm: developers no longer write code line by line, but instead describe requirements in natural language, let AI generate the code, and simply "feel the vibe" to judge whether the results are correct before iterating. This approach dramatically lowers the barrier to programming, enabling even non-professional programmers to build applications. However, Karpathy himself acknowledged that Vibe Coding is better suited for personal projects and prototype validation — for enterprise projects requiring long-term maintenance, code quality and controllability remain paramount. The Skill-driven development discussed in this article is precisely an engineering refinement of Vibe Coding for enterprise scenarios — retaining AI-driven efficiency while using the Skill mechanism to fill the gap in quality controllability.

The correct way to leverage AI programming in large companies and mature enterprises is to abstract commonly used, repetitive development patterns into Skills. According to the speaker's observations, when senior engineers at major tech companies use AI, they likely spend 70%–80% of their time writing Skills, with relatively little time spent writing code directly.

The concept of Skills didn't appear out of thin air — it's essentially the natural evolution of "code templates" and "design patterns" from software engineering into the AI era. Long before AI programming tools became popular, enterprise development already extensively used code generators (like MyBatis Generator, JHipster), scaffolding tools (like Yeoman), and IDE code templates to reduce repetitive work. Skills take this concept one step further: they're not just static templates, but a set of "intelligent templates" that incorporate contextual understanding, specification constraints, and dynamic adaptation capabilities, generating highly customized code based on specific business scenarios and tech stacks. At its core, Skills can be compared to Infrastructure as Code in the DevOps domain — except what they implement is Best Practice as Code.

The core logic behind this shift: common development patterns like caching architectures, distributed transactions, and microservice architectures are things teams use repeatedly. Distilling these into Skills and letting Skills drive code generation frees engineers from repetitive labor.

Why Directly Asking AI to Write Code Leads to "Code Disasters"

Many developers habitually tell AI programming tools to "build this feature, build that feature." This raw, casual development approach may seem efficient, but after a project runs long enough, the code will almost certainly degrade into unmaintainable "spaghetti code" — or as developers more colorfully put it, a "code disaster."

"Code disaster" is the developer community's colloquial expression for extreme cases of Technical Debt. According to a 2018 survey by Stripe, developers worldwide spend an average of 42% of their work time dealing with technical debt and maintaining low-quality code, resulting in annual economic losses as high as $85 billion. AI programming tools were supposed to alleviate this problem, but without engineering constraints, AI can actually accelerate technical debt accumulation — because AI generates code far faster than humans, and high-speed generation without specification constraints equals high-speed chaos production. This is precisely the real-world context behind the Skill mechanism: using engineering approaches to put quality reins on AI's efficient output.

The root cause: lack of consistency and controllability. Every time AI generates code without unified specification constraints, it produces implementations with varying styles and uneven quality, making team collaboration and long-term maintenance increasingly difficult.

Skills provide exactly this layer of "specification constraints." The speaker emphasizes: "If you have AI spend the majority of its time developing Skills, and let Skills develop the code, the code quality of your project will absolutely be much better than before."

In other words, Skills serve as an engineered middle layer — they codify best practices, architectural patterns, and coding standards, allowing AI to generate code within a controllable framework, achieving controllable code quality, smooth team collaboration, and long-term maintainability.

Two Forms of Skills: From Prompts to Code Scripts

Based on the sharing, Skills can range from simple to complex:

• Simple Skills: Essentially well-crafted prompts, such as a "WeChat public account article auto-generation Skill."
• Complex Skills: Can embed code and scripts to achieve more sophisticated capabilities, such as a "Stock Quantitative Analysis Skill" or an "Automated Xiaohongshu Post Publishing Skill."

Take the Xiaohongshu automation example: previously, content operators needed to manually log in to the website daily and publish posts one by one. After learning the corresponding Skill, they only need to write the article (or even have AI write it), execute the Skill with one click, and the entire publishing process completes automatically — multiplying efficiency.

AI Programming Tool Selection: Claude Code, Codex, and WorkBuddy Each Serve Their Purpose

One practical aspect of this sharing is that it doesn't promote a "single best tool" but instead provides clear tool allocation based on scenarios.

The Two Leading Global AI Programming Tools

From a global perspective, Claude Code and Codex are currently the two most capable AI programming tools. Domestically in China, tools like ByteDance's Trae and Tencent's CodeBuddy (WorkBuddy^Ad) are widely used.

Claude Code is a command-line AI programming tool from Anthropic, based on their Claude series of large language models. It excels at context understanding across large codebases and complex architectural tasks, with its Agentic programming capability (AI autonomously planning and executing multi-step programming tasks) standing out in industry benchmarks. Codex is OpenAI's programming agent, initially famous for GPT model-driven code completion capabilities (early integration in GitHub Copilot), later evolving into a standalone product that can autonomously execute complete development tasks in sandboxed environments. The core difference lies in interaction paradigms: Claude Code leans toward deep terminal command-line interaction, suitable for experienced engineers handling complex architectural problems; Codex provides a more user-friendly visual interface and async task management, suitable for a broader audience.

You might not have noticed, but the underlying large model behind these tools is equally critical. The speaker's actual configuration:

Tool	Backend Model	Use Case
Codex	Latest GPT version (best compatible)	Simple Skills, strong visualization
Claude Code	Zhipu GLM (avoiding Claude account ban risks)	Enterprise-level complex architecture
WorkBuddy	DeepSeekAd (best cost-performance ratio)	Alternative requiring no VPN

Interestingly, the speaker chose to connect the domestic GLM model in Claude Code rather than the officially optimal Claude model — for a very practical reason: "Claude accounts get banned from time to time," especially in scenarios involving VPN use and frequently changing IPs.

This detail reflects the real dilemma Chinese developers face when using overseas AI tools, and explains why domestic models like GLM, DeepSeek, Tongyi Qianwen, and Xiaomi MiMo are becoming reliable alternatives. The Zhipu GLM-4 series mentioned has approached international top-tier levels in benchmarks for code generation and logical reasoning, while providing stable domestic API services with zero ban risk. DeepSeek is renowned for its exceptional cost-performance ratio — its DeepSeek-V3 and DeepSeek-R1 models perform comparably to GPT-4-level models on programming tasks, but API call costs are only a fraction (sometimes one-tenth to one-hundredth) of the latter. These domestic models, through OpenAI API-compatible interface designs, allow developers to seamlessly switch backend models within overseas tool frameworks like Claude Code and Cursor, achieving a "overseas tool framework + domestic model engine" hybrid approach. This flexibility is a defining characteristic of China's current AI development ecosystem.

Practical Advice for Environment Setup

In practical implementation, Claude Code integrates as a VS Code plugin — installed within Microsoft's VS Code IDE, where instructions are written. Of course, using Cursor or other domestic IDEs works perfectly fine too.

For developers who have difficulty accessing overseas networks, WorkBuddy paired with DeepSeek offers a lower-barrier solution with stronger visualization capabilities, suitable for users at all levels.

Scenario-Based Tool Allocation Strategy

The tool allocation logic presented is essentially "using the right tool for the right job":

• Simple tasks (WeChat article generation, content writing) → Use Codex or WorkBuddy, with strong visualization, accessible to everyone;
• Enterprise-level complex tasks (Java architecture, Python architecture, Redis caching architecture, production issue troubleshooting) → Use Claude Code, more professional, suited for experienced programmers.

This allocation strategy avoids the "when all you have is a hammer, everything looks like a nail" trap. The speaker also mentioned running multiple tools simultaneously as backup — after all, during live demonstrations, tools occasionally slow down or malfunction, and parallel tools ensure tasks complete smoothly.

Skill Secondary Development: Advanced Plays for Enterprise Scenarios

Beyond writing Skills from scratch, the sharing also introduced a concept closer to enterprise practice — secondary development of Skills.

A typical scenario: you have an existing functional module that originally lacks caching, and now you need to add Redis caching architecture on top of it. You don't need to start from zero — just invoke the corresponding Skill with a few simple sentences, and it automatically generates a complete, specification-compliant caching implementation.

It's worth elaborating on why Redis caching architecture is a quintessential Skill use case. Redis (Remote Dictionary Server) is the world's most widely used in-memory database and caching middleware — virtually every internet company's backend architecture relies on it to solve performance bottlenecks in high-concurrency scenarios. But implementing Redis caching architecture is far from simply "adding a cache layer" — it involves cache penetration (queries for non-existent data bypassing cache and hitting the database directly), cache avalanche (mass cache expiration causing sudden database pressure spikes), cache breakdown (concurrent impact at the moment hot data expires), cache-database consistency (the classic dilemma of whether to update cache or database first), and a series of other engineering challenges, each with mature solutions and code patterns. Encapsulating this entire set of best practices into a Skill means any team member can generate production-grade caching implementation with a single instruction, without needing to reason through these complex edge cases from scratch every time.

This embodies the reuse value of Skills — distilling architectural capability into repeatedly callable assets.

AI Programming Is Moving Toward Engineering

The core message of this sharing is clear: AI programming is evolving from "individuals casually writing code" to "systematic, engineered Skill-driven development."

For developers still "hand-coding the old-fashioned way" or only asking AI to generate features directly, understanding and mastering Skill development and reuse may be the most important capability upgrade ahead. It's not just about efficiency — it's about controllable code quality, smooth team collaboration, and long-term project maintainability.

Tools will continue to iterate, and large models will keep updating, but the engineering mindset of "abstracting repetitive patterns into reusable capabilities" is the true moat that transcends technology cycles.