Agent Full-Stack Delivery: From Frontend to a Working Backend
This article examines whether an AI Agent can deliver a complete, runnable application from a single prompt. Using a case study of a space tourism website with seat booking, it breaks down the five capabilities full-stack delivery requires, demonstrates the correct way to handle concurrent seat reservations with row locks and unique constraints, and provides a practical acceptance checklist plus hands-on advice for developers evaluating Agent output.
1. Why Full-Stack Delivery Matters
LLMs writing code is now commonplace, but most usage stays at the function level — completing a snippet of logic or fixing an error. For developers, the more meaningful question is: given a single requirement, can an Agent deliver an application that works the moment you open it?
Leaderboard scores only show how a model performs on specific benchmark tasks. To judge whether it can actually deliver, you need to look at the result of one complete run: does the page render, do the APIs respond, is data truly written to the database, and are business rules enforced? Publicly reported leaderboard figures often lack full benchmark names and test conditions, so this article does not cite specific numbers.
2. Case Study: A Website Generated from One Prompt
The tester gave the Agent a compound instruction: build an official website for a near-Earth-orbit travel company, including space capsule seat selection and flight booking. This requirement demands brand visuals, interaction, frontend, and backend logic all at once — far more complex than single-point generation.
Frontend: Visuals and Interaction
The generated page had several notable features. The hero section used a full-screen background simulating a porthole view; flight data was displayed in a monospace font in the lower-right corner; and the page organized mission phases along a vertical timeline, each node accompanied by a description and an image.
The quality of such a page can be checked item by item: Is the typographic hierarchy clear? Does text-to-background contrast meet readability standards? Does the layout hold up on narrow screens? Can navigation be completed with a keyboard? Judging “premium feel” from screenshots alone is not a valid acceptance criterion.
Backend: From Showcase Page to Real Booking
The site also included a booking flow: pick a date, choose a seat, fill in passenger information, and write the data to a database. On the business-rule side, each flight was capped at 6 seats, and once full, no further bookings were accepted.
This rule is a real domain constraint that only holds with database-level protection. The next section explains how.
Generalization: What Happens with a Different Theme
The same prompt structure was also used to generate sites for a deep-sea exploration organization and a luxury brand, each with a distinct style. The original report only offered qualitative descriptions — no sample sizes, no failure cases, and no complete prompts. These results therefore show that the model can work across themes, but they cannot be used to estimate success rates.
3. Five Capabilities Behind Full-Stack Delivery
A usable delivery typically depends on the following capabilities:
| Capability | What It Looks Like |
|---|---|
| Planning | Breaking a compound requirement into subtasks such as pages, APIs, and data models |
| Code generation | Coordinating multiple files with consistent API names and parameters |
| Design output | Keeping layout, color schemes, and motion stylistically consistent |
| State management | Understanding persistence, constraint validation, and edge cases |
| Self-verification | Producing code that runs, then locating and fixing errors when they occur |
Among these, state management is the most error-prone. A model may produce code that works correctly in a single thread while overlooking data conflicts under concurrency.
4. Seat Booking Example: Writing It Correctly Under Concurrency
First, look at a common approach:
def book_seat(flight_id, seat_no, passenger):booked = db.query("SELECT count(*) FROM bookings WHERE flight_id=%s", flight_id)if booked >= SEAT_LIMIT:raise SeatLockError("This flight is fully booked")db.execute("INSERT INTO bookings (flight_id, seat_no, passenger) VALUES (%s,%s,%s)",flight_id, seat_no, passenger)
In single-user testing, this code works fine. But if two requests simultaneously read “one seat remaining,” both will pass the check and insert — resulting in overselling. It also does nothing to stop two people from selecting the same seat.
An improved version needs two layers of protection:
SEAT_LIMIT = 6def book_seat(flight_id, seat_no, passenger):with db.transaction():# Lock the flight row so bookings for the same flight execute sequentiallydb.query("SELECT id FROM flights WHERE id=%s FOR UPDATE", flight_id)booked = db.query("SELECT count(*) FROM bookings WHERE flight_id=%s", flight_id)if booked >= SEAT_LIMIT:raise SeatLockError("This flight is fully booked")# The bookings table needs UNIQUE(flight_id, seat_no);# a duplicate seat raises an error here and rolls backdb.execute("INSERT INTO bookings (flight_id, seat_no, passenger) VALUES (%s,%s,%s)",flight_id, seat_no, passenger)
A few notes:
- The row lock serializes bookings for the same flight, so the count cannot be changed by other concurrent requests.
- The unique constraint is the last line of defense. Even if the application-level check goes wrong, the database rejects duplicate seats.
- Any exception inside the transaction triggers a rollback, avoiding situations where a slot is consumed without a seat record.
- The actual behavior of row locks and unique constraints depends on the database engine and isolation level — verify with concurrency tests before going live.
This code is illustrative only. Real projects also need to handle connection pooling, timeouts, retries, and logging.
5. An Acceptance Checklist for Evaluating Agent Delivery
To determine whether a generated result is usable, check item by item:
- Routing: Every page URL is accessible, with no dead links.
- APIs: Request and response formats match the frontend, and error codes have clear meanings.
- Database migrations: Running migration scripts against an empty database successfully creates tables consistent with the code.
- Error handling: Invalid input returns clear messages, and server-side exceptions do not leak stack traces.
- Concurrency testing: Use multiple threads or a load-testing tool to book the same flight and the same seat simultaneously, checking for overselling and duplicate seats.
- Data integrity: After a mid-process failure, no half-written records remain in the database.
These checks can be written as automated test cases and re-run after every change.
6. Practical Advice for Developers
- Structure your prompts: Specify the delivery scope (pages, APIs, database, persistence), business constraints (capacity limits, state transitions), and the tech stack. The more specific the constraints, the easier the result is to verify.
- Accept based on runnable results: Scores can be a reference, but acceptance should hinge on whether the app starts and whether a complete business flow can be executed.
- Define the human-machine division of labor: Agents are well suited for rapid prototyping and routine implementation; scaling, compliance, and performance optimization still require engineers.
- Add security measures before deployment: APIs need authentication, inputs need validation, personal and payment-related data must be encrypted at rest, databases need regular backups, and monitoring with alerting should be configured.
- Connect cloud services with least privilege: Container deployment, object storage, and monitoring services can form a generation-to-production pipeline — grant each permission only the minimum necessary scope.
7. Conclusion
The delivery capability of Agents is expanding from coding assistance to complete applications. The most direct way to judge reliability is to give it a real requirement, let it deliver end to end, and then verify the result item by item against the acceptance checklist.
