Building an Agentic SDLC for a Web Launch in Under One Month

The client needed to replace a Webflow site with a React and Next.js platform for a global launch. The new site had to handle complex visual experiences, structured content, localization, and demanding performance targets. The client's engineers were focused on the core product, so Callstack assigned a small team to the website.

Designs changed through much of the 10-week engagement. Once the scope was frozen, the team had under one month to finish the agreed production pages, migrate the existing content, establish the localization workflow, and prepare the site for launch.

Faster code generation alone would not meet that deadline. The delivery process had to give agents tasks with a defined scope and results that could be checked automatically while engineers retained control over architecture, visual quality, scope, and release decisions. It also had to account for ambiguous requirements, subjective design work, context loss in long-running tasks, changing model behavior, and unpredictable token use.

We built an agentic software development lifecycle with two execution modes.

Autonomous execution handled bounded tasks with explicit acceptance criteria and observable results. An orchestrator retrieved work from Linear, created an isolated workspace, launched a Developer agent, ran validation, and prepared a pull request. A separate Reviewer agent inspected the proposed change and reported its decision to Linear before the work reached a person.

Engineer-guided execution covered responsive composition, animation timing, dynamic transitions, and other work that required continuous visual judgment. Engineers broke each change into small tasks, worked iteratively with Codex, and checked the implementation in the browser.

Both paths ended at the same approval gate. Engineers owned the architecture, acceptance criteria, production quality, and final decision.

Agentic SDLC operating model

The first version of the workflow used OpenAI Symphony and connected Codex, an automated reviewer, Linear, GitHub, Figma, browser tooling, and Contentful. Timestamped recordings and implementation pull requests captured the Developer and Reviewer roles, review decisions sent back to Linear, translation automation, and delivery evidence attached to each pull request.

Testing recovery before trusting the workflow

We tested the recovery path with a deliberately invalid commit reference. The Reviewer agent found the error and requested changes. The Developer agent corrected the reference, the Reviewer approved the updated implementation, and the orchestrator moved the task to Human Review in Linear.

The controlled failure confirmed that the workflow could detect a defect, request a correction, verify the new result, and escalate it to a person. This recovery loop made automated review part of delivery rather than a pass-fail check at the end.

Embedding quality checks into delivery

The team built the site from scratch with Next.js App Router and TypeScript, then deployed it through Vercel. The complete Webflow CMS, including existing articles, moved to Contentful.

Contentful and Crowdin formed the multilingual publishing workflow. English remained the source of truth. Crowdin generated translation drafts for several additional locales, followed by automated checks, AI language review, and final human approval before the translations returned to Contentful.

Performance checks ran throughout implementation. Accepted sections were continuously deployed to Vercel previews and inspected with browser tooling. Stakeholders reviewed the current build directly, and feedback from a morning meeting could reach a working preview the same day.

Page-level mobile and desktop Lighthouse audits covered the delivered pages. Desktop performance stayed above 95, while mobile performance stayed above 80. A later like-for-like homepage audit recorded an improvement of approximately 25 points.

Where agents performed well and where engineers stepped in

Agents handled explicit, repeatable work well: data mapping, CMS integration, content models, page structures, and application logic. These tasks needed little manual correction when the requirements and validation criteria were precise.

Visual implementation remained less predictable. Text instructions did not capture animation, responsive behavior, or subjective design detail with enough precision. Engineers improved the results by providing visual references, splitting interfaces into smaller changes, and giving agents direct feedback from the browser.

The engagement exposed a practical limit of agentic delivery. Clear tasks, isolated environments, fast feedback, automated review, and human gates increased throughput. Ambiguous work became faster to generate, while review still depended on engineering judgment.

The small team completed the agreed production scope of under 10 pages within a final production window of under one month. It also migrated the complete CMS, established the multilingual publishing workflow, and met the site's performance requirements.

The delivery team estimated that agents executed 80% of the development effort. Engineers concentrated on task definition, orchestration, architecture, visual judgment, validation, and final review.

For a comparable scope, Callstack estimates that a small team working without agents could require up to three times the engineering effort. This supports an estimated delivery acceleration of up to 3x. It is a retrospective delivery estimate, not an instrumented productivity benchmark.

The internal team continued using the workflow independently after handover. The operating model could continue without Callstack running every agent workflow.