Full-Stack Website Delivery with AI Agents: Methods and Limits

    AI agents can now take a structured requirement and deliver a complete, runnable website—pages, styles, interactions, APIs, and data persistence included. This article walks through how to write verifiable specifications, key frontend and backend implementation points (including concurrency control for seat bookings), a pre-delivery validation checklist, and the boundaries where human review remains essential.

    Why This Capability Matters

    Early code generation tools mostly stopped at function-level completion. Over the past couple of years, agents have begun to accept a complete requirement, then plan page structure, write styles and interactions, build APIs, and persist data on their own. For developers, the evaluation criteria have shifted accordingly. The question is no longer “can it write code,” but “does the deliverable run as-is and pass acceptance testing.”

    This article does not compare performance across tools. It focuses on a single question: using one structured requirement description, have an agent deliver a complete website. Which steps are reliable, and which require human oversight—that is the core of what follows.

    1. Write Requirements as Verifiable Specifications

    Prompt quality sets the floor for delivery quality. A usable requirement description typically contains four parts:

    1. Business goal: who the site serves and what users need to accomplish.
    2. Page structure: the order of the hero section, content blocks, and interactive areas.
    3. Functional constraints: data fields, validation rules, quantity limits, and so on.
    4. Visual guidelines: acceptable ranges for color palettes, type hierarchy, and motion pacing.

    For a flight-booking site, a specification fragment might look like this:

    • The page consists of five parts: hero section, itinerary timeline, cabin selection, booking form, and confirmation page.
    • The timeline shows six stages in chronological order; each stage contains one key metric and one image.
    • The booking flow is: select a date, select a seat, fill in passenger information, submit.
    • Constraints: each flight has a maximum of 6 seats; once full, seats can no longer be selected.

    The more specific the specification, the easier it is to write acceptance cases from it. “Make it feel premium” cannot be verified, while “the hero video loops, and automatically freezes when the user has enabled reduced-motion preferences” can be checked item by item.

    2. Key Frontend Implementation Points

    2.1 Immersive Backgrounds and Fallback Strategy

    Full-screen video backgrounds are visually striking but add bandwidth and rendering pressure. In practice, you should:

    • Provide a static poster image as the first frame and as the fallback for low-performance devices.
    • Detect the system’s reduced-motion preference and disable autoplay when it is set.
    • Compress the video to an appropriate bitrate and control above-the-fold payload size through preloading strategy.

    2.2 Scroll-Driven Timeline

    Timeline-style narratives usually highlight the current stage based on scroll position. Use viewport intersection detection rather than repeatedly reading layout information inside scroll handlers—the latter easily causes frame drops.

    The structure looks like this:

    1. <section class="timeline">
    2. <article class="stage" data-time="T+03:00">
    3. <h3>Propulsion Stage</h3>
    4. <span class="key-metric">[key metric]</span>
    5. <img src="stage-03.webp" alt="Illustration of the propulsion stage" loading="lazy">
    6. </article>
    7. <!-- remaining stages follow the same structure -->
    8. </section>
    1. const stages = document.querySelectorAll('.stage');
    2. const observer = new IntersectionObserver((entries) => {
    3. entries.forEach((entry) => {
    4. entry.target.classList.toggle('is-active', entry.isIntersecting);
    5. });
    6. }, { threshold: 0.6 });
    7. stages.forEach((el) => observer.observe(el));

    Images use lazy loading so that resources outside the viewport don’t consume bandwidth.

    2.3 Data Panels and Readability

    Dashboard-style panels typically use monospace fonts so digits align vertically and readings are easier to scan. Text-to-background contrast should meet accessibility requirements—4.5:1 or higher is recommended for normal text. Decorative elements (such as a pulsing status indicator) should only convey status and must not carry critical information.

    2.4 Interactive Seat Maps

    Seat maps are best described in a vector format, where each seat is an element with a unique identifier and a state. There are four common states: available, selected, occupied, and unavailable. State should be determined by server-side data; the frontend is only responsible for rendering and submitting selections.

    3. Backend: Concurrency Control Is the Core of Booking Logic

    Seat-type resources carry a classic risk: two users selecting the same seat at the same time. If validation only happens on the frontend, overselling is nearly impossible to avoid. The correct approach is to enforce uniqueness at the data layer, which involves four points:

    1. Data modeling: the bookings table has a unique constraint on (flight, seat number), so a seat has at most one valid record.
    2. Atomic operations: inventory deduction and record insertion happen in the same transaction; if either step fails, everything rolls back.
    3. Capacity control: the flight record tracks remaining seats, and the deduction carries a “remaining count greater than 0” condition, so new requests are automatically rejected once the flight is full.
    4. Idempotency: each submission carries a unique request identifier, so repeated clicks or network retries take effect only once.

    Illustrative pseudocode:

    1. BEGIN;
    2. -- Deduct inventory: zero affected rows means the flight is full
    3. UPDATE flights
    4. SET remaining_seats = remaining_seats - 1
    5. WHERE flight_id = :flight_id
    6. AND remaining_seats > 0;
    7. -- Insert booking: a unique constraint violation means the seat is taken
    8. INSERT INTO bookings (flight_id, seat_no, passenger_name, request_id, status)
    9. VALUES (:flight_id, :seat_no, :passenger_name, :request_id, 'confirmed');
    10. COMMIT;

    If any statement fails, the transaction should roll back and return a clear error type to the frontend (flight full, seat taken, duplicate request) so the UI can show the corresponding message.

    Data Persistence

    Booking data must be written to persistent storage and must survive service restarts. Production environments also need regular backups and restore drills to verify that backup files can actually be restored.

    4. Pre-Delivery Validation Checklist

    Whether agent-generated code can ship depends on how thorough the validation is. At minimum, cover the following:

    • Functionality: required-field and format validation for every form field; whether the happy path completes end to end.
    • Edge cases: full flights, duplicate submissions, cross-date selections, empty passenger information.
    • Concurrency: fire multiple concurrent requests at the same seat and verify that exactly one succeeds.
    • Security: escape and validate all external input to prevent injection; APIs require authentication; logs must not contain personal information or credentials.
    • Compatibility: layout and interaction across major browsers and common mobile screen sizes.
    • Performance: above-the-fold payload size, loading strategy for video and images, API response times.
    • Accessibility: all operations completable via keyboard, text contrast meeting standards, images providing alternative text.

    Concurrency testing delivers the highest value, because agent-generated code is most likely to hide subtle defects here—and those defects are the hardest to spot during manual review.

    5. Applicability Boundaries and Risks

    Agent delivery can significantly shorten prototype and first-version cycles, but it does not replace engineering responsibility. Keep the following in mind:

    • Code review: code touching payments, personal information, or permissions must be reviewed by a human and must not be merged directly.
    • Dependency audit: third-party dependencies introduced by generated code need checks on licenses, maintenance status, and known vulnerabilities.
    • Asset licensing: confirm the source and licensing scope of images, videos, and fonts.
    • Business rule confirmation: the model may make unstated assumptions about edge conditions—such as refund rules or seat-lock duration—which the business owner should confirm item by item.
    • Pre-deployment checks: before going live in production, complete independent security scanning and load testing.

    6. Practical Recommendations

    • Have the agent generate the overall skeleton first, then iterate module by module—change one module at a time and verify immediately.
    • Keep the requirement specification under version control, and update acceptance cases in sync when requirements change.
    • Prioritize writing persistence and concurrency logic by hand, or at least give it focused human review.
    • Record the prompt used for each generation along with the differences between outputs, so issues can be traced back to their source.