Skills are a way to package professional knowledge, such as coding experience and solutions to common problems, into reusable modules. At its core, a skill is a standardized capability consisting of a set of instructions, various scripts, and supporting resources. Structured around a core SKILL.md configuration file and optional bundled assets, it integrates the knowledge and tools required for specific tasks. Huawei Cloud CodeArts Agent can load skills dynamically on demand, enhancing execution capability, operational stability, and overall efficiency across diverse R&D scenarios.

The directory structure of a skill is as follows:

skill-name/
├── SKILL.md (Required)
│   ├── YAML frontmatter metadata (Required)
│   │   ├── name: (Required)
│   │   └── description: (Required)
│   └── Markdown instructions (Required)
└── Bundled Resources/ (Optional)
    ├── scripts/      - Executable code (Python, Bash, etc.)
    ├── references/   - Documents to be loaded into the context
    └── assets/       - Files used in the output (templates, icons, fonts, etc.)

Software development frequently involves complex, repetitive tasks like code refactoring, test case generation, document writing, and deployment configuration. Managing these tasks traditionally requires manually orchestrating multi-tool workflows, consulting documents, and troubleshooting errors. This approach is time-consuming and prone to errors or omissions—especially for developers unfamiliar with specific domain requirements.

As development environments grow more complex, mastering every technology stack or domain best practice becomes impractical. Team knowledge sharing often suffers from information loss and inconsistent standards, while steep learning curves slow the adoption of new tools and methodologies.

CodeArts Agent includes built-in, out-of-the-box skills that streamline development without requiring deep underlying knowledge. For custom requirements, you can easily create skills from scratch or import existing files. Once skills are added, you simply invoke a required skill. The agent automatically plans execution paths, coordinates tools, and performs complex operations in a single call, effectively lowering technical barriers.

• Domain expertise: Skills encapsulate verified, domain-specific best practices to consistently meet quality standards and reduce errors resulting from a lack of experience.

• Dynamic loading: Skills are loaded into context only on demand to minimize context usage, enabling agents to automatically select and call the right skills for each task.

• Reusability: Skills use a standardized structure that lets them be shared seamlessly across teams and projects, reducing duplicate effort, promoting knowledge retention and team collaboration, and improving R&D efficiency.

• Flexible customization: Skills support parameter configuration, custom instructions, and resource bundling. Developers can adjust skill behaviors based on actual requirements to adapt to diverse workflows.

• Standardized governance: Skills feature uniform directory layouts and parameter schemas that simplify versioning, access control, and lifecycle management, facilitating centralized enterprise control and continuous optimization.

Use Case 1: Coding and Refactoring

During daily coding or refactoring, developers handling complex logic, design patterns, or standards adjustments often need extensive documents and rely heavily on trial-and-error. With code development skills, developers simply describe their functional requirements or refactoring goals. The skill automatically analyzes the existing code structure and generates compliant implementations or refactoring suggestions, ensuring quality and consistency while significantly shortening development cycles and reducing technical debt.

Use Case 2: Test Case Generation and Quality Assurance

With large projects or complex logic, manual test case creation involves heavy workloads and often leads to incomplete coverage, leaving edge cases and abnormal scenarios unaddressed. Using testing skills, the system automatically analyzes code structure and logic to generate comprehensive test cases covering edge cases and exceptions, providing coverage analysis to enhance test efficiency, strengthen code quality assurance, and shorten test cycles.

Use Case 3: Document Creation and Knowledge Management

Technical documentation requires specific formats, complete content, and synchronization with code—a tedious, lag-prone task that hinders team knowledge transfer and maintainability. With document skills, the system automatically generates document frameworks and content based on code structure, API definitions, and project information, supporting multiple formats and standards to reduce maintenance burdens, improve quality and timeliness, and promote knowledge accumulation.

Use Case 4: Operations, Deployment, and Environment Management

When managing deployments across multiple environments, configuration management, and troubleshooting, teams need to coordinate multiple tools and execute standardized steps, which is often cumbersome, error-prone, and impacts stability. Using skills, the system automates deployment workflows, configuration checks, and log analysis while providing standardized procedures and troubleshooting recommendations to ensure environment consistency, shorten deployment time, and boost operational efficiency.

Use Case 5: Data Analysis and Report Generation

When processing data files such as Excel or CSV, data analysts must write queries, perform statistical analysis, and generate visual reports. These tasks are repetitive and require high SQL proficiency. With data analysis skills, the system can learn analysis requirements via natural language, automatically generate SQL queries, process data, and output results. This lowers technical barriers, accelerates data analysis, and enables non-technical personnel to quickly gain data insights. 

Skill execution begins when triggered by a user request or automatically detected by the agent. Users can invoke a skill explicitly by selecting it from the / command menu or typing its name, or implicitly by describing their task in natural language for automatic matching. The agent automatically matches the appropriate skill based on the task description, loads its definition, and executes the corresponding operations.

 Figure1 How skills work

Step 1: Skill Identification and Matching

The agent analyzes user task descriptions or explicit call commands to identify the target skill. For explicit calls, the agent directly locates the skill. For implicit calls, it performs semantic matching based on skill descriptions and applicable scenarios to select the best fit. Once matched, the agent prepares to load the skill.

Step 2: Skill Loading and Parsing

The execution engine loads the skill definition file (SKILL.md) and required resource files from local or cloud storage based on the skill's scope and path. The engine parses the YAML metadata for the skill name and description, evaluates Markdown instructions for execution steps and parameter requirements, and loads documents from the references directory into context for execution.

Step 3: Command Execution and Tool Scheduling

The execution engine executes operations step by step according to the skill instructions. Each step may involve file I/O, code analysis, script execution, or API calls, which the engine completes by scheduling the appropriate tools via the tool integration layer. During execution, the engine dynamically adjusts subsequent steps based on intermediate results, handling conditional branches and loops to ensure workflow adaptability.

Step 4: Resource Invocation and Result Integration

During execution, skills can invoke executable scripts in the scripts directory for deterministic tasks, and utilize files in the assets directory as templates or resources. The engine accumulates output across steps, synthesizes all intermediate results, and generates the final results according to defined output specifications. Final deliverables may include generated code, documents, reports, or configuration files.

Step 5: Result Delivery and Resource Release

Upon completion, the engine returns the final results to the user or agent and displays the execution process and key details in the chat interface. Loaded reference documents and intermediate states are cleared from the context to optimize memory usage. Execution logs and status updates are recorded in the backend for traceability and performance optimization.

A skill is a reusable capability module encapsulated with instructions, scripts, or assets. A rule is a custom constraint configuration designed to govern agent behavior, ensuring precise alignment with and strict adherence to relevant specifications. Both of them can be used by CodeArts Agent to enhance agent capabilities, shaping and standardizing AI behavior through empowerment and constraints to refine outputs and boost development efficiency.

Key differences between the two are outlined below. 

CodeArts Agent skills can be created locally or on the cloud, and can be enterprise-level, team-level, project-level, and user-level, depending on the application scope. You can select skills based on specific development scenarios and collaboration needs, achieving flexible and efficient code management.

If there are skills with the same name, the agent invokes the skills in the following priority: cloud enterprise skills > cloud team skills > local project skills > local user skills > cloud user skills > built-in system skills.

Huawei Cloud launched CodeArts Agent, which provides a comprehensive skill lifecycle management system, covering skill creation, management, and use. Both local and cloud skills are supported, and there are four application scopes: enterprise-level, team-level, project-level, and user-level. Each type encapsulates professional capabilities for different scenarios. Users can refine control over and continuously optimize existing skills based on their business requirements.

CodeArts Agent includes built-in system skills that provide out-of-the-box utilities to accelerate development. It offers multiple methods to add skills for flexible capability expansion. For details, see Skills.

By leveraging skills with CodeArts Agent, developers can rapidly adopt domain-specific best practices without having to learn from scratch or configure environments, significantly accelerating onboarding. Enterprises can standardize coding guidelines and best practices via enterprise skills to ensure code quality and team consistency. Teams and projects can encapsulate specific workflows through team and project skills to reduce redundant effort and improve collaboration efficiency. Developers can customize personal configurations via user skills to build tailored development environments. The agent dynamically loads skills on demand to enhance task execution capabilities and efficiency.

Quick Start for Skills

• To learn how to prepare skills, see Writing a Good Skill.
• To quickly generate a PDF-splitting skill using the skill-creator available in the skill marketplace, see Using Skill Creator to Generate a Skill for Splitting PDF Documents by Chapter.