AI Coding Tool Test: Generating a Complex Frontend Project and Reviewing the Output

    This article reports a hands-on test of an intelligent coding tool that generated a 10-page frontend project in free invocation mode. It covers generation speed and usability, mobile and desktop compatibility, dependency and bundle-size review, TypeScript migration and bug fixing, directory structure, a simulated order flow, and a pre-release checklist. The main takeaway is that such tools can accelerate scaffolding and prototyping, but cross-platform styling, dependency size, complex types, security, and licensing still require human review.

    1. Testing Scope and Boundaries

    This test asked an intelligent coding tool, combined with an underlying large language model, to continuously generate a frontend project containing 10 pages. The test was run in free invocation mode. Model inference was slow, and the entire generation process took noticeably longer than in paid mode. The test did not record the tool version or model version, so the conclusions below apply only to this sample and cannot be directly generalized to other tools or other versions.

    2. Generation Speed and Usability

    The tool was able to complete the overall output of 10 pages. The project could run, and basic navigation between pages worked. For building a prototype from scratch, this ability to generate multiple pages at once can significantly reduce preparation time. The generated code still required a manual adjustment phase, and there were deviations in detailed styling and engineering conventions. Some issues came from context truncation by the tool or misunderstandings of requirements; others were related to the coding habits of the underlying model.

    3. Cross-Platform Compatibility: Mobile vs. Desktop

    In mobile testing, responsive layout and component sizing met expectations, and no obvious layout issues were found. Desktop was different. The generated code did not constrain image aspect ratios, and layouts broke at different resolutions. Some pages lacked footer styles and did not match the design.

    These conclusions need support from a more complete test matrix. At minimum, the following should be covered: mobile width 375px, tablet 768px, desktop 1280px and 1920px, and the latest two major versions of Chrome, Safari, and Edge. Take screenshots of each page and compare them item by item with the design.

    4. Dependency Management and Component Library Size

    When generating static pages, the tool imported a complete mainstream UI component library by default. For pages with only a few forms or display-only content, these dependencies are unnecessary and increase bundle size and slow down initial page load.

    Bundle-size issues should be judged with data. Use bundler analysis tools such as rollup-plugin-visualizer or webpack-bundle-analyzer to inspect the size share of each dependency, then use Lighthouse to record initial-load metrics. Teams can first record a bundle-size baseline for the current version and compare the increment on each code merge. The threshold should be determined by the team based on its own performance budget; this test did not provide a universal number.

    For components that are needed, import only the modules actually used, for example import { Button } from 'ui-lib/es/button', rather than importing the entire library. For display-only pages, native tags plus a small amount of styling are usually sufficient.

    5. Bug Fixing and TypeScript Type Migration

    Midway through the test, the project was converted from JavaScript to TypeScript, and the compiler reported 25 type errors. During the repair process, the tool stopped only once on a complex generic, then automatically added type assertions and interface definitions. Most errors required no manual changes. This test did not save the count for each type of error; the handling approach is described by category below.

    • Layout and style issues: Feed the specific symptoms, such as broken layout or missing styles, plus screenshots back to the tool. The tool can locate the related styles and propose changes.
    • Missing interfaces: The tool adds interface definitions. During review, confirm that field names and types match the backend contract.
    • Type assertions: The tool used as assertions extensively to eliminate errors. Assertions can hide real problems; count the assertions and confirm each one.
    • Complex generics: This was the only part of this test that required manual intervention. Split generics into named types and add unit tests for key functions.

    After repairs are complete, enable strict: true and compile again to confirm there are no hidden errors that pass only under loose configuration.

    6. Directory Structure and Engineering Conventions

    The generated directory structure basically followed mainstream frontend engineering practices. The table below lists the main directories, responsibilities, engineering value, and points requiring manual review.

    Directory Responsibility Engineering value Manual review point
    pages Distinguish public pages from pages requiring authentication, such as the user center Reserve boundaries for route guards and access control Confirm that authentication logic works on the server side, not only by hiding frontend entry points
    components Separate Layout components from business components Improve component reuse Check whether common components have duplicate implementations
    types Centralize Interface and Type definitions Separate type definitions from business code Keep in sync with backend API definitions
    mock Provide independent mock data Enable debugging without the backend Confirm that mock data is not bundled into production before launch

    The directory structure provides a starting point for later maintenance, test integration, and micro-frontend splitting. The structure itself cannot guarantee quality; the internal implementation of each module still needs review.

    7. Business Flow: Order Placement Closed Loop

    The tool generated pages for the shopping cart, order confirmation, and payment simulation, and passed data between pages through state management, forming a complete order placement flow. The personal center was also displayed in modules for basic user information, order status, and asset data.

    This shows that the tool can understand the relationships between business steps. Before launch, however, the following states still need to be verified one by one:

    1. The item count and total amount in the shopping cart remain consistent after additions and removals.
    2. Order status follows the sequence pending payment, paid, completed, and cannot skip steps.
    3. After refreshing the payment page, order status and cart data are still correct.
    4. Unauthenticated users accessing the personal center are redirected to the login page.
    5. The payment step is a simulated flow and does not connect to real payment. Before integrating real payment, a separate design is required.

    8. Actionable Checklist

    Review the following checklist before launch:

    • Component library is imported on demand, with no whole-library import
    • Images use fixed aspect ratios; desktop screenshots at multiple resolutions show no misalignment
    • Responsive breakpoints match the design
    • TypeScript strict mode is enabled, and as assertions have been confirmed one by one
    • Dependency size is compared with the baseline; if the increment exceeds the team budget, explain why
    • Input validation, authentication, and sensitive information handling have been reviewed; secrets are not written into code
    • Licenses of new dependencies have been confirmed

    9. Risks and Rollback

    Generated code may contain unreviewed security vulnerabilities, and dependencies may carry incompatible licenses. Commit each generation to a separate branch and complete review before merging. If problems occur, revert that commit directly without affecting other existing code.

    10. Conclusion

    This test shows that intelligent coding tools are suitable as advanced scaffolding and prototype accelerators. They can quickly generate standard directories and mock data and can handle a relatively large number of type errors. Cross-platform styling, dependency size, and complex types still require human control. Treat generated results as drafts awaiting review and adopt a human-machine collaboration approach to turn the tool’s efficiency advantages into maintainable engineering outcomes.