AI Coding Tool Selection Guide: Practice and Reflection on Building an E-commerce Frontend from Scratch
This article provides a practical guide to evaluating AI coding tools by building an e-commerce frontend site from scratch using React. It explores the capabilities of current AI programming assistants across interaction experience, generation completeness, and code quality. By establishing a five-dimensional evaluation framework, developers can systematically assess and select the right AI coding tools to improve their delivery efficiency.
1. Background: The Selection Dilemma in the Era of AI Coding Tools
With the rapid popularization of AI-assisted coding tools over the past two years, the boundaries of programming tools are being redefined. They have evolved from simple code completion and conversational Q&A to “Agent” modes capable of understanding entire codebases, automatically decomposing tasks, and executing multi-step operations. For developers worldwide, a practical challenge arises: navigating the vast array of available AI coding tools to find the right fit.
However, “usable” is only the baseline. Factors that genuinely impact development efficiency are multidimensional: interaction friendliness, rationality of task decomposition, first-pass success rate of generated code, clarity of engineering structure, and ease of error recovery. This article conducts a systematic capability assessment and methodology summary of such tools through a specific practical task—building an e-commerce frontend site from scratch. Note that this article does not aim to promote any specific product but rather to extract a universal evaluation framework applicable to similar tools.
2. Evaluation Task Design: Building an E-commerce Site from Scratch
To make the evaluation results comparable and reproducible, the task design must be specific. The task is defined as follows:
Build a frontend shopping site using React, comprising 10 pages: Home (Product List), Product Detail, Product Purchase, Purchase Success, User Login, User Registration, User Dashboard, User Orders, User Wallet (Vouchers), and User Settings.
The design considerations for this task include:
1. Moderate page count with broad coverage. 10 pages test the tool’s ability to generate a complete application in one go while covering typical frontend scenarios like lists, details, forms, flows, and user centers. This exposes issues in layout, routing, and state management.
2. Complete business loop. The shopping flow from browsing products to successful ordering, combined with login/registration and user center, forms a complete chain: “Anonymous browsing -> Authentication -> Transaction -> Account management.” This observes the tool’s understanding of business logic continuity.
3. Clear difficulty gradient. Simpler tools might only generate static page stacks, while more capable ones will proactively introduce engineering practices like routing management, state management, form validation, and mock data layering.
Additionally, the prompt intentionally included a subjective requirement: “The interface should be friendly and not as cold as traditional tools.” This tests the tool’s aesthetic capability in visual design—the gap between generating “runnable code” and “visually appealing and usable interfaces” is often larger than expected.
3. Evaluation Dimension 1: Interaction Experience and Task Execution Mode
3.1 “Autopilot” Mode is Not a Silver Bullet
Current mainstream tools generally offer two working modes: an assistant mode, where the AI generates code snippets for developers to manually confirm and apply, and an automated mode, where the AI autonomously plans tasks, continuously modifies multiple files, and attempts to run and verify them.
In practice, the automated mode proved highly unstable. In some tools’ automated modes, although the project could start after a task, pages frequently threw errors, requiring repeated manual intervention to achieve normal results. Other tools caused directory structure chaos during automatic execution—such as nesting same-name folders within an existing project folder, leading to build path errors. Multiple repair attempts failed, ultimately requiring a complete project restart.
This indicates that the “speed” of automated mode comes at a cost. For large tasks involving multi-file collaborative modifications, the AI’s long-chain decision-making is prone to accumulating errors. A more robust approach is to break large tasks into several smaller ones, using the automated mode for each and verifying before proceeding. Alternatively, developers can manually scaffold the critical file structure first, allowing the AI to fill in the implementation within constraints.
3.2 Interaction Warmth: An Underestimated Experience Metric
Traditional developer tools often prioritize feature stacking, resulting in dense interfaces with little guidance. In contrast, new-generation AI coding tools are beginning to focus on interaction experience. Some use anthropomorphic avatars to accompany the development process, while others provide clear explanations alongside code generation. These designs practically lower the psychological barrier for beginners.
It is worth noting that some tools, to showcase concepts like “multi-agent collaboration,” simultaneously present multiple agent options on the interface, which can overwhelm users. More features do not equal a better experience. Tool design should follow the principle of progressive disclosure—defaulting to a clear main path and expanding advanced options as needed.
4. Evaluation Dimension 2: Completeness of Generated Results
4.1 The Distance Between “Runs” and “Usable”
Post-task comparisons of each tool’s outputs revealed a common pattern: most tools could generate a startable project, but a noticeable gap exists between “runs” and “usable.” Typical issues include:
- Visual layer: Monotonous color schemes (e.g., using a single brand color site-wide), product images being entirely placeholders, sparse product detail pages, button display defects like white text on a white background, and lack of mobile responsiveness or layout distortion on mobile login/registration pages.
- Logic layer: Basic form validation was generally present, but the rigor of validation rules varied significantly—some only checked for non-empty fields, while others included format validation, consistency checks (e.g., comparing two password inputs), and error message targeting.
- Flow layer: The completeness of the shopping flow differed significantly. Some tools generated a complete navigation chain from list -> detail -> checkout -> success page, while others omitted critical steps.
4.2 First-Pass Success Rate: The True Watershed of Efficiency
The evaluation showed significant differences in the ability to “complete a task in one go.” Some tools could generate all 10 pages with coherent flows simultaneously, while others required multiple rounds of conversational patching. The underlying reasons are worth analyzing: the model’s ability to maintain long context, its prior knowledge of frontend framework ecosystems (routing, state management solutions), and the tool’s own task planning algorithm collectively determine the first-pass success rate.
A practical tip for developers is to explicitly declare tech stack constraints and expected directory structures in the prompt. For instance, clearly requiring functional components, specifying a routing solution, and separating styles from logic can significantly improve the usability of the first-pass generation.
5. Evaluation Dimension 3: Code Quality and Engineering Structure
Code quality is the core criterion distinguishing a “toy” from a “tool.” During this practice, two typical scenarios were observed:
Positive case: Style files separated from logic files, clear component division, unified color schemes, and generated code styles close to manual development habits. Although the project architecture was relatively simple and mock data was coupled within business code, it was generally at a level “ready for continued development.”
Negative case: The project directory seemingly reserved abstraction spots for custom Hooks, context management, etc., with highly professional directory names, but the actual file contents were empty—“scaffolding without meat.” This formalized engineering structure is more deceptive than a simple flat structure because developers must spend time distinguishing which abstractions are genuinely usable.
From this, an evaluation key point can be extracted: Do not just look at how professional the generated directory tree appears; scrutinize the code on critical paths. It is recommended to focus on three aspects during acceptance: first, whether mock data is independent of components; second, whether routing configuration is centrally managed; third, whether state management has a real implementation rather than being an empty shell.
6. General Selection Evaluation Framework
Synthesizing the above observations, when facing the myriad AI coding tools on the market, developers can establish the following five-dimensional evaluation framework:
1. Usability: Network friendliness, response smoothness, availability of free credits, or reasonable billing methods. Generation speed and server stability directly affect the flow state experience.
2. Generation Completeness: Given a medium-complexity task, can it produce a runnable, flow-complete project in one go, rather than fragments requiring extensive patching.
3. Code Quality: Clear engineering structure, separation of styles and logic, decoupling of data and views, and adherence to mainstream framework best practices.
4. Reparability: When the generated result errors, can the tool understand the error message and accurately locate the fix; is the recovery cost from automated mode errors controllable.
5. Interaction Experience: Friendly interface, clear task modes, and absence of redundant concepts that increase cognitive load.
It is recommended to score each dimension from 1 to 5 and evaluate them separately for typical use cases (frontend page building, backend API development, script writing, etc.), as tool capabilities often have scenario biases.
7. Practical Advice: Bringing AI Generation to Production Standards
Regardless of the tool chosen, for AI-generated code to enter a real project, it must undergo the following polishing process:
1. Data layer decoupling. Extract inline mock data from the generated code into an independent mock layer or service layer interface to reserve a place for future integration with the real backend.
2. Visual asset replacement. Placeholder images must be replaced with real assets. General cloud services like object storage can be used to host static resources, and responsive image solutions should be added.
3. Accessibility and responsive reinforcement. Check contrast issues (e.g., white-on-white text), mobile breakpoints, and form accessibility attributes—these are common shortcomings of AI-generated content.
4. Testing and validation enhancement. Add automated tests for critical flows (login, checkout); align form validation rules with backend conventions.
5. Manual business logic review. AI excels at generating code that “looks correct,” but business rules (inventory validation, amount calculation, exception branches) must be manually verified by developers.
8. Conclusion
The competition among AI coding tools is essentially a comprehensive contest of “Model Capability x Engineering Capability x Interaction Design.” From this e-commerce site building practice, available tools can already meet the needs of rapid 0-to-1 prototyping or even building simple, complete applications. However, there is still general room for improvement in visual aesthetics, engineering structure rigor, and complex task stability.
For developers, the rational attitude is to treat AI as a capable partner rather than a replacement—constrain it with clear prompts, drive it with decomposed tasks, and inspect it with engineering standards. During selection, do not blindly chase a specific “mode” or “agent” concept, but use real tasks as a touchstone and the five-dimensional framework from this article as a measuring stick. Only in this way can the dividends of these tools be truly transformed into personal delivery efficiency.
