Hands-On Test of Chinese AI Coding Tools: Building an E-commerce Site from Scratch

    This hands-on comparison of Chinese AI coding tools uses one task: building a 10-page React shopping site. It covers selection criteria for developers in mainland China, three common agent workflow modes, recurring problems in generated code such as placeholder images, weak responsive layouts, and hardcoded mock data, and a prompt template for improving first-pass output. The article concludes that AI IDEs are best used as high-quality prototyping accelerators that still need human engineering work.

    1. Background: Why Tool Selection Requires Careful Evaluation Without a Proxy

    As AI-assisted programming has become a mainstream way to work, developer expectations for IDEs have shifted from “can it autocomplete code” to “can it complete a task end to end.” For developers in mainland China, selection also involves several practical constraints:

    • Network reachability: stable access without an additional proxy, with login, model calls, and code sync all working;
    • Response speed: low latency in generation and streaming output, since stutters interrupt focus;
    • Chinese-language understanding: whether the model accurately turns business requirements written in Chinese into technical solutions;
    • Free quotas and cost: China-market versions are often free or low-priced during promotional periods, but generation speed and quota policies vary considerably.

    2. Designing a Unified Evaluation Task

    To compare AI IDEs fairly, every tool must receive the same task and the same prompt. This article uses a task of moderate complexity with broad coverage: building a React front-end shopping site with 10 pages. The pages are the home page (product list), product details, checkout, order success, login, registration, and, under the user center, the dashboard, orders, wallet (cards and coupons), and settings.

    An e-commerce site works well as the benchmark because it tests three dimensions:

    1. Site completeness and consistency: whether all 10 pages are generated, whether routing is connected, and whether the visual style is consistent;
    2. Closed business flow: whether the path from browsing to login, purchase, payment success, and order viewing works end to end;
    3. Engineering quality: form validation, component decomposition, separation of data and views, mobile adaptation, and similar factors.

    3. Differences Among Typical Agent Workflows

    Current AI IDEs fall into three broad task-execution modes. Vendors use different names, but the underlying capabilities are similar:

    • Integrated Craft/Auto mode: the user submits a complete requirement in one go, and the tool plans the file structure and implementation order on its own. Its strength is a high success rate on the first attempt. Its weakness is that the user has little control over intermediate steps.
    • Builder/autopilot mode: the tool executes in steps and verifies as it writes. It offers better control, but the first run often fails in unpredictable ways and usually needs several rounds of fixes.
    • Architect/multi-agent mode: the tool produces an architecture plan first and then implements modules separately. This suits complex tasks in principle. In practice, the output can have a messy structure, such as nested folders with the same name, or slower response times.

    4. Common Problems Observed in Testing

    Regardless of the tool, the outputs shared several weaknesses. Prompt design should account for them in advance:

    1. Placeholder images: none of the tools generated real product images automatically, so a plan for integrating image resources is needed;
    2. Insufficient mobile adaptation: some outputs used layouts designed mainly for phones without responsive handling, and the login and registration pages showed obvious distortion;
    3. Mock data coupled to code: mock data was hardcoded inside components, with no data-layer abstraction;
    4. Simple architecture: most outputs had only a single layer of components and lacked state management, route guards, error boundaries, and other engineering elements;
    5. Uncontrolled styling details: one tool produced a button with white text on a white background, a critical color error. Every generated page needs a manual check.

    5. Prompt Optimization for Engineering Projects

    To address these problems, the prompt should state constraints explicitly. This noticeably improves first-pass quality:

    1. Build a 10-page site with React + React Router. Requirements:
    2. 1. Unified design system: centralize primary color, spacing, and font sizes in a theme configuration;
    3. 2. Place mock data in a mock/ directory, and have components fetch data through a unified data service layer;
    4. 3. Implement mobile-first responsive layouts on all pages, with breakpoints defined as needed;
    5. 4. Login and registration forms include complete validation (required fields, format, password strength) and error messages;
    6. 5. Organize components into pages/, components/, hooks/, and context/ layers. Business logic must not be written inside page components;
    7. 6. After generation, output a route list and page dependency relationships so the completeness of the site is easy to verify manually.

    6. Conclusions and Selection Guidance

    Based on the testing, the following guidance applies:

    • Out-of-the-box usability and a friendly interface: choose tools with an integrated generation mode. They had a high first-pass success rate and fast server responses, which makes them suitable for quick prototype validation.
    • Process control and a familiar traditional editor experience: choose step-by-step Builder-style tools. Allow time for multiple rounds of fixes, and check whether the generated project structure has been broken.
    • Complex, multi-module tasks: try the architecture-first multi-agent mode, and keep human review over the final output.

    The best current positioning for AI IDEs is a high-quality prototyping accelerator, not fully automated development. Generated code is generally below senior-engineer standards for data decoupling, error handling, and maintainability. Engineering work such as extracting a data layer, adding tests, and unifying state management remains a necessary manual step. At this stage, the most practical approach is to treat AI as a capable junior teammate that still needs supervision.