AI Coding Tool Selection and Evaluation: Building an E-Commerce Site from 0 to 1
A site that boots is not the same as one that is deliverable—and that gap is exactly where AI coding tools struggle at the project level. Using "build an e-commerce site from 0 to 1" as a unified test, this article compares three execution models—cloud task-based, in-editor autonomous, and multi-agent collaboration—across nine pages spanning product browsing, checkout, authentication, and a personal center. It reports what each model actually delivered, traces common defects (invisible button text from CSS specificity, broken mobile layouts, placeholder images, mock data coupled with business logic) back to their technical root causes, and then provides a seven-dimension scoring framework for tool selection, a constraint-driven engineering workflow to move generated output from "runs" to "shippable," and practical guidance on privacy, security, and compliance. The conclusion: there is no single "best" AI coding tool—only the right combination matched to each stage of a task.
1. Introduction: AI Coding Has Reached the “Task-Level Delivery” Stage
Over the past few years, the capability boundary of AI coding tools has advanced through three clear leaps:
- Early stage: single-file, snippet-level code completion that answers “what should I write on the next line.”
- Mid stage: generation and rewriting scoped to a single file or module, able to produce a runnable component or page in one pass.
- Current stage: task-level and project-level delivery. Users describe requirements in natural language, and the tool plans the steps itself, creates directories, writes multiple pages, and attempts to run and debug them.
As capabilities upgrade, evaluation standards must upgrade too. In the “snippet-level” era, developers could easily judge whether a completion was correct. In the “project-level” era, that judgment becomes far harder. A site that boots and pages that open do not necessarily mean deliverable quality. AI-generated code can carry hidden problems such as:
- broken mobile layouts;
- failed button contrast that makes text effectively “invisible”;
- images that are all placeholders;
- mock data deeply coupled with business logic.
These issues don’t stop the code from running, but they surface all at once during real use.
This article does not recommend or review specific products. Instead, it uses “building an e-commerce site from 0 to 1” as a unified test task, analyzes the common problems and capability differences of different types of AI coding tools in project-level delivery, and offers a reusable selection method and engineering productivity practices. This helps developers and enterprise users answer three questions:
- How do you judge whether an AI coding tool is worth adopting into the development workflow?
- At what task granularity, interaction mode, and privacy conditions is it most cost-effective?
- How do you move generated results from “it runs” to “usable, maintainable, and shippable”?
2. Experiment Design: Testing AI Coding Tools with a Complete E-Commerce Task
2.1 Task Scope: Nine Pages Covering a Full Business Loop
The test task: using a mainstream component-based frontend framework, build a shopping site from 0 to 1 that covers the following pages:
| Module | Pages | Core acceptance points |
|---|---|---|
| Product browsing | Product list, product detail | Complete information, visible images, add to cart |
| Transaction conversion | Checkout (order placement and settlement) | Quantity and address editing, amount calculation, form validation |
| Result feedback | Order success page | Correct order info display, clear status feedback |
| Identity authentication | Login, registration | Input validation, error messages, mobile usability |
| Personal center | Dashboard, orders, wallet (coupons/vouchers), settings | Consistent navigation structure, clear data display, timely interaction feedback |
The intent of this design is that e-commerce is a typical long-chain business. From browsing, ordering, and successful payment to after-sales and personal assets (coupons, balance), a break at any point affects the overall experience. At the same time, common components such as forms, lists, detail pages, cards, and navigation are reused heavily, which is enough to test how well-structured the generated code is.
2.2 Technical Constraints: Boundary Conditions Close to Real Projects
- Data conditions: the backend API isn’t available yet, so development must use mock data, and it must be possible to switch smoothly to the real API later.
- Responsive requirements: mobile-first, with basic adaptivity as well.
- Visual requirements: unified design variables (primary color, font size, spacing), with styles separated from logic.
- Verifiability: the project must build and run locally, and key interactions must be demonstrable.
These constraints aren’t harsh; they correspond exactly to common scenarios in real development: the requester provides a clear feature list and acceptance criteria, but resources, APIs, and design specifications still have gaps. Whether an AI coding tool can make reasonable trade-offs under “constrained but with ambiguous areas” conditions is the focus of this test.
2.3 Observation Metrics: Turning Subjective Feelings into Comparable Dimensions
To avoid subjective judgments like “which one looks better,” observations converge on the following dimensions:
- Task completion: whether the required pages and flows are complete;
- First-time success rate: whether the first delivery runs directly, and how many repair rounds are needed;
- Code organization: whether styles are independent, whether mock data is centralized, whether the directory structure is clear;
- Visual and responsive quality: whether color and contrast are compliant, whether mobile works properly;
- Efficiency and stability: generation and repair time, whether responses are smooth, whether tasks complete;
- Interaction experience: interaction mode, prompt language, privacy and permission settings.
3. Mechanism Differences Among Three Task Execution Models
AI coding tools on the market vary in form, but by task execution method they roughly fall into three types. Their underlying mechanisms differ, and so do their applicable scenarios.
3.1 Cloud Task-Based: One Command, Full Build
How it works: the user describes requirements in a browser, the server parses the task, and in a relatively independent, continuous context it completes directory scaffolding, multi-file generation, and preliminary validation, then returns the result and an explanation.
- Advantages: the task context is complete and the build process is stable. The tool doesn’t need to repeatedly infer intent during user editing, so the generated project is often structurally consistent with key files present.
- Limitations: if constraint information isn’t written clearly in the first input, it often can only be redone wholesale; awareness of the local environment and existing codebase is weak.
3.2 In-Editor Autonomous Execution: Write and Fix Incrementally
How it works: it exists as a code editor extension or embedded form, reads the current workspace and open files, and advances through a loop of “generate—run—read errors—fix—run again.”
- Advantages: it fits developers’ existing workflow and is convenient for local changes within existing projects; most products offer privacy-related settings, making it easy for teams to control the code-sharing scope as needed.
- Limitations: behavior is heavily affected by workspace state, and multiple repair rounds can “drift further off.” Experience losses from slow generation and response latency are significantly amplified in long tasks.
3.3 Multi-Agent Collaboration: Role Separation, Division of Labor
How it works: it splits a task among multiple agents with different roles—for example, planning, coding, and testing/review—and each role hands off artifacts according to orchestration logic.
- Advantages: separation of duties can theoretically improve planning quality and code review coverage.
- Limitations: context handoff between roles is prone to distortion, and the same file may be modified by multiple roles in sequence. When the task grows a bit larger, state management cost rises quickly, which actually reduces determinism.
| Comparison | Cloud task-based | In-editor autonomous | Multi-agent collaboration |
|---|---|---|---|
| Interaction surface | Browser task interface | Inside the code editor | Task-orchestration interface |
| Context source | Initial task description | Current workspace and open files | Task decomposition and role handoff |
| Typical strength | One-shot completion, stable responses | Fits existing flow, supports local changes | Clear division of labor, covers review steps |
| Main risk | High cost of adding constraints mid-task | Multiple repair rounds can diverge; speed limited | Context loss, collaboration conflicts |
| Applicable scenario | 0-to-1 builds, rapid prototyping | Modifying existing projects, locating issues | Planning and division of complex requirements |
4. Observed Results: Delivery Profiles of the Three Models
4.1 Cloud Task-Based: Stable Responses, Insufficient Detail Polishing
Task completion: all nine pages were generated. Core flows—login, registration, ordering, payment success—are complete, with basic frontend form validation. Overall it uses a single primary color throughout, in a clean style, enough to support a full shopping demo.
Code organization: styles and logic are already separated and readable; but the project architecture is overly simple, with mock data mixed into business code, making it costly to connect a real API later.
Main shortcomings:
- Inadequate responsive design: the layout leans mobile overall, with only simple adaptivity; the login and registration forms deform, which reflects a lack of unified breakpoints and form layout conventions at generation time;
- Empty asset presentation: all product images are placeholders, so the pages’ information density and credibility are insufficient;
- Thin business detail: the product detail page has too little information, missing key decision information in the product-browsing scenario;
- Monotonous visual expression: a single primary color throughout lacks layering and variation, easily evoking the “cookie-cutter” AI-generated style.
Interaction experience: clear operation paths, simple and direct task actions, friendly prompt language. Generation was stable in the cloud runtime, with no obvious lag or task interruption.
4.2 In-Editor Autonomous Execution: Complete Validation, Hard to Converge After Multiple Repairs
Task completion: the first generated output could start, but there were runtime errors; only after several repair rounds did it display properly. The pages are fairly basic overall and not mobile-responsive.
Code organization: there’s already awareness of separating styles and logic, though not into a separate file—not a big issue; form validation is more complete than the previous group, and the product detail page has richer information.
Main shortcomings:
- Obvious visual defects: the primary button uses a white background with white text, making the text nearly invisible, which indicates no contrast check was done at generation time; the color scheme also lacks overall coherence;
- Missing assets: images are likewise replaced with placeholders;
- Multiple repair rounds didn’t converge: errors decreased gradually, but project maintainability didn’t improve accordingly;
- Limited efficiency: generation and repair are slow, with an obvious sense of waiting in the interaction.
Additional problems with the multi-agent model: when many roles are available, users spent considerable decision cost in “choice paralysis”; after switching and trying multiple roles, the project state became chaotic and ultimately wouldn’t run. Service response speed also dropped noticeably. After multiple attempts failed to fix it, the task had to be terminated.
4.3 Side-by-Side Comparison: Complementary Strengths Rather Than Across-the-Board Leadership
| Observation dimension | Cloud task-based | In-editor autonomous | Multi-agent collaboration |
|---|---|---|---|
| Page and flow coverage | Complete | Basically complete | Not delivered |
| First-run result | Runs directly | Starts but with errors | Won’t run |
| Repair rounds | 0 | Multiple | Multiple (not converged) |
| Form validation | Basic | Fairly complete | — |
| Mobile adaptivity | Partial (login/register forms deform) | Missing | — |
| Visual quality | Consistent but thin | Failed contrast, uncoordinated colors | — |
| Code organization | Styles separated, structure a bit simple | Styles not in a separate file | — |
| Data decoupling | Mock data coupled with code | No obvious advantage | — |
| Response and stability | Stable, smooth | Slow | Noticeably slow |
| Interaction and onboarding | Task-driven, friendly | Fits existing workflow | High role-selection cost |
It’s worth stressing that the conclusions above come from a single task with limited observation rounds and cannot be generalized into a universal judgment about any category of tool. The same category of tool, given a different task or used a different way, may produce completely different results. But a few common issues are worth noting:
- “It runs” and “it’s usable” are separated by a clear gap: both groups of tools produced projects that “run,” but both also had missing assets, mobile-unfriendly layouts, or visual errors.
- Repair convergence speed matters more than first-time generation speed: problems persisting after multiple repair rounds is essentially a lack of a unified acceptance standard, not a lack of single-pass generation capability.
- Task granularity and interaction mode need to match: the value of multi-agent setups lies in requirement decomposition and division of labor, not in replacing stable single-threaded execution.
- Interaction friendliness is a real productivity factor: choice paralysis and slow responses directly drain developers’ attention.
5. Technical Root Causes of the Common Defects
These phenomena look scattered, but most have clear technical causes. Understanding the causes is what lets you avoid them with engineering methods, rather than hoping to “switch to a stronger model.”
5.1 Out-of-Control CSS Selector Specificity
The typical cause of a “white text on white background” button is a selector-specificity conflict:
/* Base button: brand background + white text */.button {background: var(--brand-color);color: #ffffff;border: none;}/* Scene override: white background with border + brand-colored text */.card .button {background: #ffffff;color: var(--brand-color);border: 1px solid var(--brand-color);}/* Insufficient specificity: only changes background, text stays white, becoming invisible */.modal .button {background: #ffffff;}
Here the first two rules have specificities of 0-0-1-0 and 0-0-2-0 respectively. The target element of the third rule only matches 0-0-1-0 and cannot override the text color set in 0-0-2-0.
Mitigation ideas:
- Use design variables to manage colors uniformly; components only reference variables, not hard-coded hex values;
- Introduce clearly named style layers, and handle complex interactions with component state classes (such as active, disabled);
- Add contrast checks in automated validation.
5.2 Missing Responsive Conventions and Input Focus Occlusion
Login and registration pages deforming on mobile usually has three causes:
- Using fixed pixel widths and heights instead of relative units;
- Inconsistent breakpoints, with forms lacking wrapping rules;
- Not accounting for the shrinking visible area when the mobile keyboard pops up.
Improved example:
/* Flexible layout with no fixed width: wraps automatically on narrow screens */.form-row {display: flex;flex-wrap: wrap;gap: 16px;}.form-row > * {flex: 1 1 240px; /* Wrap automatically when the base width isn't enough */min-width: 0; /* Allow shrinking to avoid content breaking out of the container */}/* Use dynamic viewport units to avoid overflow from the mobile address bar shrinking */.auth-layout {min-height: 100vh;min-height: 100dvh;}/* Scroll into view on focus to avoid the soft keyboard covering it */.auth-layout input:focus {scroll-margin-bottom: 120px;}
5.3 Missing Design Variables and Asset-Import Mechanisms
An epidemic of placeholder images often isn’t the tool “not knowing how to place images,” but rather the task description not specifying an asset source or defining a fallback when assets are missing. The deeper cause is a lack of a design-variable mechanism:
- If a button variant hard-codes its colors, each page’s generation will go its own way;
- If an image is a random placeholder URL, neither its style nor its behavior on load failure can be controlled.
Recommended practice:
- Define primary, secondary, danger, and neutral colors, plus variables like font size, corner radius, and spacing, all at once during project initialization;
- Specify an image asset directory and naming convention, and provide a unified placeholder component (with size constraints and descriptive text) when assets are missing, to avoid broken images after a load failure.
5.4 “Flattened” Architecture and Mock-Data Coupling
A simple project architecture often comes from a generation strategy that prioritizes “get it running first, refine later,” stacking single-page components with little layering. Mixing mock data with business logic is an even more typical coupling:
// Anti-pattern: mock data hard-coded inside the componentfunction ProductDetail({ productId }) {// Switching to the real API requires changing code inside the componentconst products = [{ id: 1, name: 'Product A', price: 99, stock: 10, images: ['placeholder-1.png'] },{ id: 2, name: 'Product B', price: 199, stock: 3, images: ['placeholder-2.png'] },];const product = products.find((p) => String(p.id) === String(productId));if (!product) return <p>Product not found</p>;return (<section><h1>{product.name}</h1><p>${product.price}</p></section>);}
Improvement idea: abstract the “data source” into a unified service layer, so components depend only on interfaces and don’t need to know where the data comes from.
// Unified service layer: components don't know whether data comes from an API or mock dataexport async function getProductDetail(id) {return http.get(`/api/products/${id}`);}// Switch implementations by runtime environment; component code needs no changesexport function createProductService() {return isMockEnabled() ? mockProductService : remoteProductService;}// Page component: depends only on the service layerfunction ProductDetail({ productId }) {const [state, setState] = useState({ loading: true, product: null, error: '' });useEffect(() => {let cancelled = false;productService.getProductDetail(productId).then((product) => { if (!cancelled) setState({ loading: false, product, error: '' }); }).catch((error) => { if (!cancelled) setState({ loading: false, product: null, error: error.message }); });return () => { cancelled = true; }; // Cancel updates on unmount to avoid memory leaks}, [productId]);if (state.loading) return <p>Loading…</p>;if (state.error) return <p>Load failed: {state.error}</p>;return (<section><h1>{state.product.name}</h1><p>${state.product.price}</p><p>Stock: {state.product.stock}</p></section>);}
5.5 The Root of “Many Errors, Repeated Fixes”: A Missing Verification Loop
The reason AI coding tools often “need a few fixes before you see results” is usually not a sudden drop in model capability, but a lack of a clear verification loop. Developers judge success by how the page looks; the tool guesses at errors through static inference. Neither side has a reproducible standard to judge against, so fixing becomes “guesswork.”
6. Evaluation Framework: Seven Dimensions to Judge the Real Level of AI Coding Tools
Combining the observations above, you can build a seven-dimension evaluation framework for enterprise tool selection. Each dimension is scored from 1 to 5 (1 worst, 5 best), multiplied by the weights below, and summed into a 100-point composite score:
| Dimension | Core question | Main observation points | Weight |
|---|---|---|---|
| Business completeness | Does it cover a full business loop | Page count, key flows, form validation, exception branches | 20% |
| First-time delivery quality | Can the first run be used directly | First-time success rate, repair rounds, runtime errors | 15% |
| Architecture and maintainability | Can the code evolve | Layering clarity, style separation, component reuse, naming conventions | 20% |
| Data and API decoupling | Can it switch backends smoothly | Whether mock data is centralized, whether the service layer is replaceable | 10% |
| Visual and responsive quality | Does it meet shippable visual standards | Color contrast, asset loading, breakpoint coverage, mobile experience | 15% |
| Efficiency and stability | Is the interaction smooth | Generation and repair time, response stability, task completion rate | 10% |
| Privacy and compliance | Is it controllable and auditable | Privacy settings, permission boundaries, generated-content review mechanisms | 10% |
Scoring method:
- Test candidate tools separately with the same task and the same constraint description;
- Have two or more reviewers score independently, recording the factual basis behind each score (for example, “the login page’s button overflows at 375px width”);
- Adjust weights by business type: tool-type products should raise the “visual and responsive quality” weight; complex back-office systems should raise “architecture and maintainability” and “data and API decoupling” weights; teams handling sensitive data should raise the “privacy and compliance” weight.
7. Engineering Productivity: Moving AI-Generated Results from “Runs” to “Deliverable”
7.1 Constraint-Driven: Write Conventions into the Task Description
Rather than hoping the model will “guess” your team’s conventions, make constraints explicit with a structured requirements file:
project:name: demo-shopstack: component-based frontend frameworktask:pages:- product-list- product-detail- checkout- order-success- auth/login- auth/register- user/dashboard- user/orders- user/wallet- user/settingsdesign:primary-color: "#2F6BFF" # Primary coloron-primary-color: "#FFFFFF" # Text color on the primary colorbackground-color: "#FFFFFF"border-radius: 8pxbreakpoints: [480px, 768px, 1024px]architecture:style: separated # Separate styles from logicmock-data: src/mocks/ # Centralized mock dataapi-layer: src/api/ # Unified data access layerstate: global-store # Global state managementquality:contrast-ratio: ">= 4.5:1" # Contrast ratio between body text and backgroundresponsive: mobile-first # Mobile-firstvalidation: required-fields # Required-field validationimages: src/assets/ # Image asset directory; random placeholder URLs are forbidden
7.2 Layered Design: Build the “Project Skeleton” First, Then Fill in Business Details
If you ask AI to generate all nine pages at once, the context load is too heavy and omissions and inconsistencies easily appear. A two-step approach is recommended:
- Step one (skeleton): have the tool generate only the directory structure, routes, design variables, and shared components, and explicitly instruct it “do not write business logic”;
- Step two (fill-in): generate pages module by module—for example, first “product list + detail,” then “checkout + payment success,” and finally the “user center.”
src/├── assets/ # Static assets (images, fonts)├── components/ # Shared components (buttons, inputs, product cards)├── layouts/ # Page layouts (bottom nav, user-center sidebar)├── pages/ # Page-level components│ ├── product/ # List and detail│ ├── checkout/ # Ordering and success page│ ├── auth/ # Login and registration│ └── user/ # Dashboard, orders, wallet, settings├── api/ # Unified data access layer├── mocks/ # Mock data (dev environment only)├── stores/ # Global state├── styles/ # Design variables, global styles, responsive rules└── utils/ # Shared utilities (currency formatting, validation functions)
7.3 Iterative Acceptance: Turn “Looks Good” into a Verifiable Checklist
After each delivery round, check against the following list item by item, and turn any failures into clear tasks for the next round:
- The project builds and starts normally with no console errors
- All nine pages are accessible with correct route navigation
- Login, registration, and checkout forms have required-field and format validation, with clear error messages
- Primary-button text is visible on white cards, modals, and other scenarios (contrast ≥ 4.5:1)
- No obvious overflow, occlusion, or deformation at 375px, 768px, and 1024px widths
- Assets such as product images and avatars load correctly, with a unified placeholder when missing
- The product detail page includes: name, price, stock, specifications, images, shipping and after-sales information
- Mock data is centralized in a separate directory and not referenced directly by components
- Global state (cart, login state) behaves as expected after a page refresh
7.4 Automated Validation: Let Machines Handle Repetitive Checks
Manual inspection can’t cover every breakpoint and scenario, so you can leverage general static analysis and browser automation capabilities:
// Contrast check illustration (must run in an environment that supports accessibility-snapshot queries)const BG = [255, 255, 255];const FG = [255, 255, 255];function srgbToLinear(c) {const v = c / 255;return v <= 0.03928 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);}function relativeLuminance([r, g, b]) {return 0.2126 * srgbToLinear(r) + 0.7152 * srgbToLinear(g) + 0.0722 * srgbToLinear(b);}function contrastRatio(fg, bg) {const l1 = relativeLuminance(fg), l2 = relativeLuminance(bg);const [light, dark] = l1 >= l2 ? [l1, l2] : [l2, l1];return (light + 0.05) / (dark + 0.05);}const ratio = contrastRatio(FG, BG); // 1.0 for white text on white backgroundif (ratio < 4.5) {console.error(`Contrast below standard: ${ratio.toFixed(2)} (required ≥ 4.5)`);}
7.5 From Cloud to Private Environments: Building a Unified Foundation with Baidu AI Cloud
After prototype validation, the move to formal development often faces three challenges:
- Code and data need a higher degree of control;
- Team collaboration and permission management need unified boundaries;
- Generation and delivery workflows need to connect with the cloud environment.
In such scenarios, you can use general cloud capabilities from providers such as Baidu AI Cloud (for example, code hosting, container platforms, object storage, log services, monitoring and alerting) to build a unified foundation, moving the AI coding tool from a “personal productivity tool” into a “team engineering system”:
- A unified development foundation: provide the team with an isolated cloud development environment and code-hosting space, and control code visibility through permission management, reducing the risk of relying on a single tool’s privacy settings.
- A standardized delivery pipeline: build, test, and release via containers, and set build, static analysis, unit tests, and similar checks as admission gates.
- A complete observability system: use logging and monitoring services to track frontend exceptions and API errors, feeding online issues back as input for the next round of AI-assisted fixes.
8. Privacy, Security, and Compliance: Usage Boundaries Must Be Defined Up Front
8.1 The Meaning and Boundaries of Privacy Mode
Some editor-based tools offer a privacy mode that lets users control whether code is sent to the server or used for model improvement. For e-commerce projects this is especially important: user data, order information, coupon rules, and internal API documentation may all appear in code and comments. Before use, three points should be clarified:
- the sending scope (a single file, workspace context, or the entire repository);
- retention and training policies;
- internal responsibility assignment and audit records.
8.2 Security Review of Generated Code
AI-generated code isn’t guaranteed to have full security awareness. Common risks include:
- frontend validation mistakenly treated as a security boundary (validation must also run on the backend);
- payment and coupon logic vulnerable to privilege escalation and amount tampering;
- authentication credentials and keys hard-coded;
- user input not escaped, leaving cross-site scripting (XSS) injection risk.
It’s recommended to explicitly declare security constraints in the task description and set up a dedicated check during code review.
8.3 Compliance and Supply Chain
- Data minimization: personal-center pages should follow the principle of collecting only the minimum necessary information;
- Dependency trust: dependencies introduced by generated code should be reviewed for source, version, and license;
- Asset licensing: assets such as product images and fonts should have confirmed authorization.
9. Selection Recommendations: Match by Scenario, Not by Chasing an “All-Powerful Tool”
- Prototyping and quick demos: prefer cloud task-based tools, using a structured requirements description to get a complete build in one pass and cut down on back-and-forth waiting.
- Refactoring and defect fixing in existing projects: prefer in-editor tools, using their workspace awareness for local changes, while enabling privacy mode.
- Complex requirement planning: try the multi-agent mode for requirement decomposition and solution comparison, but keep a single main thread for the coding execution stage to avoid context loss.
- Enterprise adoption: no matter which type of tool you choose, pair it with unified design conventions, automated acceptance, and a code-review process.
In one sentence: there is no “best AI coding tool”—only the combination of tools that best matches each task stage.
10. Conclusion
To go from “it runs” to “shippable,” AI coding tools still need to clear four thresholds:
- consistency in visual design and interaction;
- maintainability of architecture and data;
- verifiability of the delivery process;
- compliance with security and privacy requirements.
The mindset for evaluating tools should also shift from “which one generates faster” to “which one is easier to constrain, verify, and maintain.” Only when you state requirements clearly, set standards down, and build the process can AI coding tools move from “impressive in demos” to “reliable in daily work.”
