14 Days, 76 Commits, One Production Website: How to Compress Build Cycles with Claude Code

When our client came to us with a deadline and a vision, the scope was ambitious by any measure. A full marketing site for an AI company — one with deeply technical content, a headless CMS, meeting scheduling tied to HubSpot, animated data visualizations, a white paper viewer, a blog engine, a glossary, an FAQ, and a page that reads more like a long-form manifesto than a landing page.

Leveraging Claude code, we shipped it with two engineers in just two weeks.

Here’s what it actually looked like.

The Challenge

Our client is building a new kind of institutional operating system. Their thesis is that the fundamental problem facing modern organizations isn’t a lack of data or intelligence. It’s the absence of architecture that converts ambient organizational awareness into timely, coherent action.

It’s a dense, rigorous idea. The website had to not just do it justice, but make it clear and compelling.

The Stack

Before getting into the process, here’s what we actually built on:

Nothing exotic. But the *volume* of what needed to be wired together — CMS schemas, API routes, SEO configuration, dynamic routing, mobile responsiveness across distinct pages — is where complexity compounded fast.

Our Process: Tickets, Then Claude, Then Ship

Our process was ticket-driven. Linear issues tagged `WEB-XX` mapped to discrete page sections or features. A typical day looked like:

• Product clarifies a section spec in the ticket
• We pull up Claude Code alongside the codebase
• We iterate: sometimes on a component, sometimes on a full page section
• I validate visually in the browser
• Commit, push, PR, merge

The back and forth on tickets was real. Sections got renamed mid-sprint. Copy changed. Section order shifted. CTA buttons appeared and disappeared. In a traditional sprint, each of these is a small tax — find the file, understand the context, make the change, check for side effects. With Claude Code, that tax drops dramatically.

Here’s a concrete example: **WEB-70, the White Paper page**. The requirement was a branded page that renders the PDF inline on desktop, falls back to a download CTA on mobile, and matches the brand system exactly. That’s three distinct rendering paths, responsive logic, and brand polish — work that might take half a day to scope and execute. With Claude Code, I described the intent, it scaffolded the component, I reviewed and adjusted, and we were done in under an hour.

Fast Prototype Validation: The Real Unlock

The most underrated benefit of building with Claude Code wasn’t raw speed on any single task. It was the compression of the validation loop.

Traditional prototype validation goes something like: design → build → review → revise → build again. Each cycle has a handoff cost. With AI-assisted development, the cycle becomes: describe → build → review → describe revision → build again. The handoff cost nearly disappears.

This mattered most on the core page requiring a long-form product narrative and eleven distinct sections.

Each of these had to be both visually coherent and intellectually precise — the white paper’s argument is sophisticated enough that a sloppy visual translation would undermine the credibility of the whole product. Claude Code helped us move through sections rapidly while maintaining stylistic consistency: the dark `#070D1A` background, the accent color system via CSS variables, the fluid typography using `clamp()`, the custom font trio of Inter, DM Sans, and IBM Plex Mono.

When something looked wrong in the browser, I described it. When the copy didn’t match the ticket, I pasted the correct copy. When a section needed restructuring, I explained the new hierarchy. Each correction took far less time than it would in a traditional loop.

What 76 Commits in Two Weeks Actually Means

The work broke into clear phases:

Week 1 — Foundation and homepage:

• Next.js + Sanity configuration
• Typed query layer (no more guessing at CMS response shapes)
• Homepage: Hero with `LiveSignalPanel`, WhyNow, Architecture, UseCases, Testimonial, FinalCTA
• Blog engine: listing page, detail pages with Portable Text rendering
• HubSpot form integration

Week 2 — Depth and polish

• Core narrative page (11 sections, WEB-41 through WEB-49)
• Meeting scheduler with HubSpot API, availability checking, JWT-secured booking
• Glossary, FAQ (CMS-driven with accordion), White Paper page
• SEO: metadata, sitemap, robots.txt, JSON-LD Organization schema
• Mobile responsiveness audit across every page
• Navigation rename, redirects, final copy pass
• Seventy-six commits. Clean, descriptive messages. PRs reviewed and merged. CI passing on every merge.

The Sanity Integration

One area where Claude Code was particularly valuable was the Sanity CMS architecture. We built eleven schema definitions — landing page, core narrative page, blog page, FAQ page, glossary page, essays, block content, site settings — and a typed queries layer that makes every content fetch type-safe.

This isn’t glamorous work. It’s careful, repetitive, and easy to get wrong in ways that bite you later: a misnamed field in a schema that doesn’t match the query, that doesn’t match the component prop, that causes a runtime error in production. Claude Code helped maintain consistency across all of it — schema → query → type → component — without losing the thread between files.

By the Numbers

Here’s a concrete snapshot of what two engineers shipped in two weeks:

• Source files (TS/TSX/JS): 72
• Lines of code: ~9,200
• Commits: 76
• PRs merged: 76
• CMS schemas: 11
• Pages: 12

Nine thousand lines isn’t a vanity metric — it’s context. That’s typed components, CMS schemas, API routes, SEO configuration, a booking system, a PDF viewer, a blog engine, and a glossary, all wired together with no cut corners. What makes that number meaningful isn’t its size, but the fact that every line was reviewed, committed, and CI-verified.

What AI Can’t Do (Yet)

Honesty matters here. Claude Code isn’t a replacement for engineering judgment. A few things still required purely human work:

Visual QA

No AI looked at the browser and noticed that a section’s line height felt slightly too tight, or that the mobile nav needed a z-index fix. That’s still eyes-on-screen work.

Stakeholder Translation.

When a product requirement arrived ambiguous — and they always do — someone had to resolve the ambiguity before Claude Code could execute on it. The AI is only as clear as the spec you give it.

Architectural decisions.

Choosing to use the App Router’s server components for CMS freshness while keeping interactive sections as client components — that tradeoff required understanding Next.js’s rendering model, the data freshness requirements, and the performance implications. Claude Code can implement an architectural decision. It won’t make one for you.

The Broader Lesson

Our client argues that institutions are struggling to focus cognitive resources on what matters, when it matters.

There’s a version of that same failure pattern in software development. Teams have the skills, the tools, and the spec. What they often lack is the bandwidth to move fast enough through routine implementation work to reach the hard decisions that actually require human judgment.

Claude Code shifts that balance. It handles the implementation surface efficiently enough that engineers can focus attention where it belongs: architecture, product decisions, quality judgment, and the parts of the work that are genuinely hard.

Two weeks. One production website. The signal was there. The tools finally let us act on it in time.