From UI Generation to Full-Stack Delivery: The Capability Boundaries of AI Agents
This article examines what truly distinguishes AI coding agents beyond benchmark scores: their ability to deliver full-stack systems that are deployable, runnable, and maintainable by colleagues. It breaks full-stack delivery into four capability layers—coherent design language, composable interactions, data persistence, and concurrency consistency—and uses a scarce-resource contention example (limited seats per flight) to show why constraints must be enforced at the database layer through uniqueness constraints, conditional atomic updates, and idempotency keys. It then covers engineering constraints for frontend delivery, four evaluation dimensions missing from public leaderboards (maintainability, failure recovery, long-context consistency, and secure defaults), and the workflow gates and cloud infrastructure capabilities needed to move agent output into production.
Introduction: Beyond Benchmarks, What Really Matters Is “What Can It Deliver”
A recent generation of models released under “open weights” has sparked extensive discussion, with much of the attention focused on score comparisons across various benchmark leaderboards. But scores are only an indirect projection of capability. For engineering teams, a more valuable question is a different one: when I hand a requirement to an agent like this, can it produce a system that is deployable, that actually runs, and that a colleague can take over and maintain?
The original post answered this question in a clever way: instead of talking about benchmark scores, it had the agent build three websites—the official site of a commercial spaceflight company, the site of a deep-sea research institution, and a brand page for a perfume brand. These three cases happen to cover three progressively harder delivery forms: display-oriented pages that look fine with frontend only, business systems where frontend and backend are fully connected, and brand pages with extremely demanding aesthetic constraints.
This article follows the same line of thinking but abstracts it into a reusable engineering framework: what components make up full-stack delivery capability, what the failure modes of each component are, and how teams should design their workflows and infrastructure around them.
1. The Four Capability Layers of “Full-Stack Delivery”
Between “it runs” and “it can go live,” there are at least four progressive levels of capability. Confusing these four levels is the root cause of much distorted evaluation today.
Layer 1: Coherent restoration of a design language. The most common problem with generated interfaces is not that they look bad, but that they are “locally polished, globally disjointed”—each section looks acceptable on its own, but put together they lack a unified rhythm of spacing, a hierarchy of font weights, and consistent color logic. Deliverable output must first establish an internal set of design tokens (colors, a font size scale, a spacing base, and levels of border radius and shadow), then have all sections reference the same tokens. In engineering terms, this is equivalent to requiring the model to first produce an implicit design system and then render pages based on it.
Layer 2: Composability of interactions and motion. Full-screen video backgrounds, scroll-driven narrative timelines, and parallax layers that shift with the viewing angle are difficult not because of the animation itself but because of state management. A scroll narrative needs to map scroll progress to a stage index, and then let that stage index drive cross-fades of copy, imagery, and data panels. If the model merely stacks keyframes without a single source of truth, the page will exhibit state corruption in scenarios like rapid scrolling back, jumping to anchors, and mobile touch inertia.
Layer 3: Data persistence and business constraints. This is the dividing line between a “demo” and a “system.” In the original case, the seemingly understated line “each flight has a limit of 6 seats, automatically locked when full” is actually the most technically substantive sentence in the whole article—it means the model has to derive the data model, primary key constraints, the state machine, and where capacity checks belong on its own. The vast majority of generative output stops at fake data arrays in memory, which vanish on refresh.
Layer 4: Concurrency consistency and idempotency. Contention over scarce resources like seats, inventory, and quotas must be guaranteed at the database layer through constraints, not through after-the-fact checks in the application layer. This is where the difference in model output quality is most visible, and it is the focus of the next section.
2. Scarce Resource Contention: The Watershed of Model Output Quality
Take “6 seats per flight” as an example. A naive implementation looks like this:
# Bad example: check-then-write, has a race windowdef book(flight_id, seat_no, user_id):seats = db.query("SELECT COUNT(*) FROM booking WHERE flight_id = ?", flight_id)if seats[0] >= 6:return "sold_out"db.execute("INSERT INTO booking (flight_id, seat_no, user_id) VALUES (?, ?, ?)", ...)return "ok"
This code always passes in unit tests, but breaks inevitably when two people click at the same time: both requests read 5, then both insert successfully, and 7 seats end up sold.
A deliverable implementation requires three things working together: a uniqueness constraint on the table, a conditional atomic update, and a request idempotency key.
-- 1) The seat table uses (flight, seat number) as the primary key, naturally preventing double sellingCREATE TABLE flight_seat (flight_id BIGINT NOT NULL,seat_no SMALLINT NOT NULL,status VARCHAR(16) NOT NULL DEFAULT 'AVAILABLE', -- AVAILABLE / HELD / SOLDversion INT NOT NULL DEFAULT 0, -- optimistic lock version numberPRIMARY KEY (flight_id, seat_no));-- 2) Conditional update: the claim succeeds only when the seat is still available and the version matchesUPDATE flight_seatSET status = 'HELD', version = version + 1WHERE flight_id = :flight_idAND seat_no = :seat_noAND status = 'AVAILABLE'AND version = :expected_version;-- affected rows = 0 → claim failed, roll back the transaction and prompt to reselect a seat-- 3) Idempotency key: repeated submissions with the same request_id won't occupy the quota twiceCREATE TABLE booking_request (request_id VARCHAR(64) PRIMARY KEY,flight_id BIGINT NOT NULL,user_id BIGINT NOT NULL,created_at TIMESTAMP NOT NULL);
To judge whether an agent’s output is “demo-ready” or “production-ready,” an efficient probe is to look at its first reaction to requirements like capacity limits + concurrent submissions: does it add an if count >= limit, or does it proactively introduce a unique index, a state machine, and an idempotency key, and clearly explain the failure paths and lock hold times? The latter means it understands the basic engineering consensus that “constraints should be guaranteed by the storage layer.”
Three companion design decisions are equally worth checking: whether the held (HELD) state needs to be automatically released after a timeout; how to roll back state after a payment failure or timeout; and whether a distributed transaction has been introduced—for a resource controllable within a single table like seats, a local transaction plus a conditional update usually beats a cross-service strong-consistency approach, where the cost-benefit ratio of the added complexity does not pay off.
3. Engineering Constraints for Frontend Delivery
Display-oriented and brand pages look simple, but to reach “ready to go live,” the model needs to follow a clear set of output contracts. An effective practice is to write the requirements into a structured part of the prompt:
intent:domain: research-institution # domain tonedeliverable: fullstack-webconstraints:design_tokens:type_scale: [12, 14, 16, 24, 32, 48] # fixed font size scalespacing_base: 4 # spacing basemax_line_length: 68ch # readability limit for body textinteractions:- scroll_timeline: single_source_of_truth # scroll progress as the single source of truth- prefers_reduced_motion: respect # accessibility: disable large motion effectsperformance:hero_media: lazy_with_poster_framefirst_contentful_render_target: fast
Three constraints deserve emphasis: animations must respect the system’s “reduce motion” preference, otherwise users sensitive to vestibular triggers will feel directly uncomfortable; first-screen media must provide a placeholder frame and lazy loading, since a full-screen video background is the main consumer of mobile data and battery; and accessibility cannot be deferred—if semantic tags, contrast, and keyboard reachability are not constrained at the generation stage, the cost of patching them afterward is far higher than writing them correctly the first time.
For brand pages, typographic details need additional constraints: fonts must come from available font libraries with a clear fallback chain, letter spacing and line height must be set proportionally, and images must have a definite aspect ratio to avoid layout shift. These constraints may seem trivial, but they determine whether the output has a “design-spec-level look” or is a “production page that can handle real content.”
4. A Supplement from the Evaluation Perspective: Four Dimensions Beyond Leaderboards
Public benchmarks (knowledge-based Q&A, real repository-level software engineering tasks, and terminal command-line operation tasks—these three categories) do portray important facets of a model, but they share common blind spots that require self-built evaluation to supplement before production adoption:
- Maintainability: the module division of the produced code, naming consistency, and whether it reinvents the wheel. Benchmarks typically only verify “whether tests pass,” not “whether it is safe to change six months later.”
- Failure recovery: when a single generation fails, can it locate and locally fix the problem based on error logs, rather than rewriting everything? This capability determines whether it is an assistant or an automation pipeline.
- Long-context consistency: when two constraints are appended after 300 lines of requirements document, does the model forget the earlier rules? Real projects almost always involve appending requirements across multiple rounds.
- Secure defaults: whether it does input validation, parameterized queries, and externalized secrets by default. Benchmark tasks rarely reward output that “introduced no vulnerabilities.”
Therefore, a more pragmatic evaluation approach is: pick 20–30 real tasks from your team’s existing requirements, run them against a unified acceptance standard (compiles, passes existing CI, and is acceptable in code review), and the resulting conclusion will be more reliable than any leaderboard.
5. Production Adoption: Where Agents Fit in the R&D Workflow
To bring this capability into production, you need a few gates in the workflow, rather than pushing the output directly onto the main branch.
- Isolated build sandbox: the agent runs in a disposable container with controlled network egress, short-lived credential injection, and destruction when the task ends. Dependencies it generates need vulnerability scanning during the build.
- Separate review of code and intent: break changes into two layers, “structure/contract” and “implementation details.” The former (data model, interface boundaries, transaction boundaries) must be gated by humans; the latter can be more highly automated.
- A mandatory verifiable definition of done: delivery must come with reproducible build and test steps; output that does not run does not count as done.
- Least privilege: read/write access to production data, and publish and rollback permissions, are not handed to automated flows; use the path of “generate changes, human or pipeline approval, canary release.”
- Observable cost and usage: record model call volume, build time, and retry counts per task, to avoid complexity spiraling out of control.
6. Supporting Capabilities from Cloud Infrastructure
When connecting agents to an enterprise’s existing systems, several common capabilities are usually needed, all describable in industry-standard categories:
- Container platforms and serverless functions: host agent sandboxes and preview environments for generated output, scaling elastically for batch tasks.
- Model services: unified access and quota management, with multi-model routing to balance quality and cost.
- Object storage and content delivery networks: host first-screen media and build artifacts to reduce first-screen load latency.
- Relational databases and caching: carry business data and accelerate hot reads, using their native constraint capabilities to guarantee consistency of scarce resources.
- Message queues and task orchestration: make long-running generation tasks asynchronous, supporting failure retries and idempotent consumption.
- Logging, metrics monitoring, and alerting: connect the full chain of a task from submission to acceptance, quickly pinpointing whether the issue is a model output problem or an environment problem.
In scenarios like these, Baidu AI Cloud provides exactly these standardized infrastructure capabilities, letting teams focus on defining business constraints and setting acceptance standards rather than operating underlying resources.
Conclusion
The real change brought by these open-weight models is not a number on some leaderboard, but a shift in the “delivery threshold”: the restoration of interfaces, boilerplate code, and routine CRUD—parts that used to consume a lot of work hours—are being significantly compressed; while the parts that depend on engineering judgment—correctness of constraints, consistency of state, secure defaults, and maintainability—are gaining weight instead.
So the advice for developers is direct: don’t stop at “let it make a good-looking page,” but keep stress-testing its boundaries with real constraints—add concurrency, add capacity limits, add permission models, add failure injection. Only a system that can deliver under these constraints qualifies to enter a production environment.
