Huawei Cloud Equips HarmonyOS Developers with Dedicated AI

Huawei Cloud Takes Its AI Coding Tools One Step Further into the HarmonyOS Ecosystem

On September 21, Huawei Cloud announced that its code agent, CodeArts, had completed a comprehensive upgrade for HarmonyOS developers, officially launching three capabilities: the “HarmonyOS Coding Foundation Model,” the “Madao HarmonyOS Agent,” and the “HarmonyOS Developer Practice Center.”

The focus of this upgrade is not simply to add an ArkTS chat interface to a general-purpose foundation model. Instead, it links the model, code repositories, DevEco CLI, on-device emulators, and development practice environments into a single workflow. Huawei Cloud describes its goal as building an AI coding agent designed specifically for the HarmonyOS ecosystem.

From a developer’s perspective, this goes beyond merely “supporting ArkTS code completion.” It attempts to address the more challenging aspects of HarmonyOS development: API version differences, declarative UI syntax, project directory structures, cross-device adaptation, and whether generated code can actually compile and run.

More Than Just Giving a General-Purpose Model a New Prompt

ArkTS is essentially a TypeScript dialect adapted for the HarmonyOS ecosystem, but what developers truly need to master goes far beyond language syntax.

A deployable HarmonyOS application also involves ArkUI declarative UI, HarmonyOS APIs, application models, distributed capabilities, permission mechanisms, device adaptation, as well as DevEco Studio and the build toolchain. Even if a general-purpose coding model can produce code that “looks like ArkTS,” it may still make mistakes involving component lifecycles, state management, API invocation methods, or project configuration.

This is also the technical focus of Huawei Cloud’s upgrade: through a HarmonyOS-enhanced training system, open-source examples, HarmonyOS APIs, development standards, code repositories, component assets, and UI/UX layout templates have been incorporated into the training and enhancement process. The training data exceeds one million entries, including more than 100,000 high-quality HarmonyOS data points.

Several metrics disclosed by Huawei Cloud include:

• 100% coverage of components for high-frequency HarmonyOS development scenarios;
• More than 80% reduction in the error rate per 1,000 lines of code;
• More than 78% improvement in the first-pass compilation rate;
• More than 20% reduction in token consumption per task.

These metrics need to be considered in the context of specific test sets, task types, and comparison baselines. They cannot be directly interpreted as meaning that every project will achieve improvements of the same magnitude. However, the direction is clear: the evaluation criteria for a HarmonyOS coding model should not be limited to whether the generated code “looks right.” They should also consider whether the output can be incorporated into a real project, pass compilation, and run on a device.

For developers, the “first-pass compilation rate” is more valuable than a longer stretch of code completion. In HarmonyOS development, a significant amount of time is not spent writing business logic, but dealing with type errors, incompatible component properties, changes in API usage, and project configuration issues. If a model can only generate code while shifting the debugging burden to developers, its practical benefits will quickly diminish.

The HarmonyOS Agent Begins to Take Over the Full Development Workflow

The second part of this upgrade is the “Madao HarmonyOS Agent.” It covers everything from requirement analysis, solution design, and code writing to compilation and building, with the goal of reducing the need for developers to switch repeatedly between different tools.

This means developers are no longer limited to entering a prompt such as “Help me write a page” and then copying the code back into an IDE for debugging. A more complete workflow might look like this:

1. Enter product requirements or a page description;
2. Have the agent break down the page, data structures, and interaction logic;
3. Generate ArkTS and ArkUI code according to HarmonyOS development patterns;
4. Use the project code repository and HarmonyOS knowledge base to supplement the context;
5. Invoke DevEco CLI to perform compilation, building, and related checks;
6. Invoke an on-device HarmonyOS emulator to view the actual runtime result;
7. Continue modifying the code based on compilation errors or UI issues.

The integration of DevEco CLI and the on-device emulator is particularly noteworthy. AI coding tools have generally been good at “generation,” but have relied on developers to handle “validation” themselves. Whether generated results need to be modified is ultimately determined by the local compiler and runtime environment.

By integrating the CLI and emulator into the agent, CodeArts can establish a more closed-loop process: generate code, then compile it; if compilation fails, read the error; fix the code and build again; if the runtime result does not meet expectations, continue making adjustments.

The value of this capability lies not in completely replacing developers, but in delegating a large amount of mechanical trial and error to the agent. For page-level and small-application requirements in particular, developers can first have the agent create a runnable version, then focus their efforts on business logic, performance, and product experience.

Multi-Device Adaptation Is the Real Challenge for HarmonyOS AI Coding

One important characteristic of HarmonyOS application development is the need to support different device form factors, such as phones and tablets. Simply generating a page that runs on a phone does not mean the application is complete.

Different screen sizes, portrait and landscape orientations, window dimensions, and interaction methods all affect layout and component selection. Traditionally, developers have had to repeatedly validate their applications across multiple emulators and physical devices, then manually adjust page structures and styles.

Huawei Cloud says that the HarmonyOS coding agent can directly invoke an on-device HarmonyOS emulator, helping developers view and adjust development results in real time while adapting them to the screen sizes of phones, tablets, and other terminal devices. If this capability can operate reliably in real-world projects, its significance will exceed that of merely improving code completion speed.

That is because cross-device adaptation is fundamentally a “runtime problem” that is difficult to solve through static code generation alone. A model can infer how a particular layout should be written, but only by running it on devices with different screen sizes can developers determine whether it truly meets expectations.

From this perspective, CodeArts is more like an “engineering agent for HarmonyOS” than a standalone ArkTS Copilot. It places model capabilities within the context of compilation tools, emulators, and engineering standards, attempting to make the model responsible for the development workflow rather than merely for the chat window.

Knowledge Bases, Third-Party Library Conversion, and Mini-Program-to-Meta-Service Conversion

In addition to code generation and compilation validation, the HarmonyOS agent also includes skills such as the HarmonyOS knowledge base, third-party library conversion, and mini-program-to-meta-service conversion.

The HarmonyOS knowledge base addresses the problem of fragmented development resources. ArkTS syntax, HarmonyOS APIs, component usage, and best practices are continuously updated. If developers rely entirely on the model’s memorized parameters, they may encounter outdated APIs, incorrect parameters, or development standards that have changed. Connecting up-to-date documentation, APIs, and best practices to the agent can reduce the likelihood of the model writing code “from memory.”

Third-party library conversion is more closely related to migration scenarios. Many existing applications are not developed from scratch, but require capabilities from Android, the Web, or other technology stacks to be migrated to the HarmonyOS environment. Whether a third-party library can be replaced, how its interfaces should be mapped, and which capabilities need to be rewritten are often more complex than creating a new page. If the agent can provide conversion recommendations based on the project context, it may help development teams shorten migration cycles.

Mini-program-to-meta-service conversion targets another category of existing assets. For teams that already operate mini-program businesses, whether to invest in developing a HarmonyOS version usually depends on the cost of migration. If the agent can convert part of the pages, logic, and resources, with developers then making engineering corrections, it can at least reduce the cost of early-stage validation.

However, these capabilities are currently better understood as “accelerators” rather than one-click migration tools. Cross-platform conversion involves numerous platform differences involving payments, login, push notifications, permissions, maps, audio and video, and third-party services. An agent can reduce repetitive work, but it is unlikely to eliminate architecture-level modifications.

Developer Practice Center: Lowering the Entry Barrier Without Lowering Engineering Requirements

Huawei Cloud has also launched the HarmonyOS Developer Practice Center, which provides scenario-based examples ranging from introductory and advanced topics to enterprise-level use cases, while connecting the examples, code repositories, and cloud development environments.

Developers can complete development, compilation, packaging, and testing directly in a browser without first dealing with complex local environment configuration. After viewing an example, they can also enter a cloud environment with one click to practice.

This is clearly valuable for beginners and teams that need to validate solutions quickly. The first barrier to HarmonyOS development is often not the code itself, but the installation and configuration of development tools, SDKs, emulators, and project templates. A cloud-based practice center can reduce these upfront costs and allow developers to move directly into the “view an example—modify the code—run it” phase.

For enterprise teams, the value of the practice center lies in reusing experience. Many teams do not lack people who can write code; rather, their best practices are scattered across personal computers, project repositories, and internal documents. Only by consolidating them through examples and runnable environments can individual experience become a team asset.

Of course, cloud environments also introduce new considerations: whether enterprise code can be uploaded, how permissions are controlled, how development data is isolated, and how build artifacts are managed all need to be verified in actual use. Huawei Cloud’s Madao previously emphasized security capabilities such as local code-file storage and encrypted transmission, but enterprises still need to evaluate these aspects against their own compliance requirements before officially adopting the service.

What Does This Upgrade Mean for the HarmonyOS Ecosystem?

Huawei Cloud’s move reflects an issue that the HarmonyOS ecosystem will inevitably encounter as it enters large-scale application development: the number of developers is growing, but the number of people familiar with ArkTS, ArkUI, and the HarmonyOS engineering system is not increasing at the same pace.

If every team has to start by learning APIs, understanding project structures, and dealing with adaptation issues, the pace of ecosystem expansion will be constrained by development costs. The role of dedicated coding models and agents is to encapsulate some platform knowledge, best practices, and engineering experience, thereby lowering the cost for development teams to enter the HarmonyOS ecosystem.

However, the approach also faces several practical challenges.

First, whether a dedicated model is actually more stable than a general-purpose model requires more public and reproducible evaluations. Data such as the error rate per 1,000 lines of code and the compilation pass rate are useful references, but they are not sufficient to determine how the model performs on large projects, complex state management, and multi-module engineering.

Second, as HarmonyOS APIs and development tools continue to evolve, the model needs to stay up to date. Code that compiles successfully today may still encounter compatibility issues several months later if it relies on outdated APIs. Therefore, knowledge-base updates, version identification, and project-level context capabilities will be more important than the scale of a single training dataset.

Finally, whether an agent can truly reduce human intervention depends on its ability to understand errors. An agent that merely modifies code mechanically based on compiler errors can easily fall into a cycle of “fixing one problem while introducing another.” A genuinely useful agent needs to understand project architecture, test results, and runtime behavior—not just handle syntax errors.

Assessment: Huawei Cloud Is Betting on an “Engineering Closed Loop,” Not Another Chatbot

Overall, the direction of this CodeArts HarmonyOS upgrade is sound, and it offers more practical value than simply releasing another “HarmonyOS-specific foundation model.”

What HarmonyOS developers truly lack is not a chatbot that can answer questions about ArkTS syntax, but an engineering system that can understand projects, generate code, invoke tools, complete compilation, and assist with validation. By embedding the HarmonyOS Coding Foundation Model into the CodeArts agent and connecting it to DevEco CLI, emulators, and the practice center, Huawei Cloud is essentially filling the gap between AI Coding and delivery.

In the short term, it is better suited to scenarios such as page development, functional prototyping, component generation, code migration, and fixing common problems. For large commercial projects, developers will still need to master architecture design, performance optimization, permission security, and release processes. Passing compilation should not be equated with meeting code-quality standards.

However, if the improvements in error rates and compilation pass rates disclosed by Huawei Cloud can be reproduced across more real-world projects, CodeArts may become a development tool with greater platform significance in the HarmonyOS ecosystem, rather than merely a model plugin.

For teams already using Huawei Cloud’s Madao, the HarmonyOS-specific capabilities are worth testing directly. For teams still evaluating the cost of migrating to HarmonyOS, the practice center and on-device emulator are better suited for an initial round of validation. For more complex enterprise-level projects, it is advisable to begin with a small-scale pilot using an existing code repository, focusing on how the model handles project context, version differences, and multi-device adaptation.

From the perspective of industry competition, AI coding tools are shifting from “whose model writes code faster” to “whose model can be embedded into real development workflows.” By entering through ArkTS, the HarmonyOS toolchain, and its own engineering experience, Huawei Cloud has at least identified a vertical scenario that general-purpose tools may not be able to cover completely.

The winner of this competition will ultimately not be determined by the names of the models announced at product launches, but by a more straightforward metric: whether developers are willing to entrust real projects to them.

References

• ITHome: Huawei Cloud Madao Launches HarmonyOS Coding Foundation Model, Reducing Error Rate per 1,000 Lines of Code by More Than 80% — Introduces the three major capabilities, technical metrics, on-device emulator, and other features of the Huawei Cloud CodeArts HarmonyOS upgrade.
• ITHome: Huawei Cloud Opens Free Trial of Its AI Programming Tool and Releases the Public Beta of the Madao Code Agent — References the previous product positioning of Huawei Cloud Madao, its engineering capabilities, and its support for HarmonyOS ArkTS.