We left no-code. AI made writing code the easy choice again.

The core idea: No-code existed because code was too slow for marketing to touch. Claude Code flipped that math. Building a page is now faster in code than in a no-code tool, and we keep control, flexibility, and no platform lock-in.

About two years ago, we tried building our marketing site in Next.js.

This was before AI coding tools became part of our normal workflow. Every change needed an engineer. Marketing couldn't move without pulling someone away from product work.

It became unmanageable, so we abandoned it.

We moved to Webflow for a simple reason: marketing should've been able to update the website without disturbing engineering.

That was the whole promise of no-code.

It didn't work out that way.

We still needed a separate design and development consultant to manage a lot of the site.

Marketing could handle small updates. The team could duplicate an existing page and change some content.

Anything more involved needed help.

The dependency hadn't disappeared. It had moved from our engineers to consultants.

Because the site ran through a block editor, people occasionally broke pages while making routine changes.

Marketing could edit what already existed, but creating a genuinely new page was difficult without someone who understood the underlying setup.

That made the team cautious. A tool we adopted to let marketing move independently still required specialist support.

Webflow historically capped sites at around 100 static pages. Its paid-plan limit has since been raised to 150, but the constraint shaped the system we had to build.

The Webflow community documented the same problem, including the reverse-proxy workaround developers used to put additional projects behind one domain.

There were also limits on dynamic content per page.

We couldn't host some forms inside Webflow. We couldn't build the free tools we wanted inside it either. Those needed a separate application.

Even on Enterprise, the ecosystem felt restrictive for the site we were trying to build.

At the time we ran the site, publishing worked at the site level.

If someone changed one page and clicked publish, every other in-progress edit could go live too.

That included work another person was still reviewing on a completely different page.

Webflow had a staging environment, but it wasn't strong enough for how we worked. In practice, we ran on production and had to coordinate publishing manually.

We wanted the blog, marketing site, and free tools to live on the same domain. We didn't want to split them across subdomains.

That left us with this architecture:

NGINX reverse-proxied requests across the three systems and made them look like one website.

It worked, but it was hacky. It also made the overall system slow.

The site also had slow page speed and poor Core Web Vitals.

That hurt our SEO, and it was one more reason to get off the platform.

Performance on any stack takes deliberate work, and getting the new site fast is its own ongoing job, so I'm not going to claim a clean before-and-after here. It was a reason we wanted off Webflow, not a trophy.

The Webflow implementation accumulated duplicate classes and poorly structured HTML.

That made the output harder to reason about and harder to maintain.

The visual editor hid some of that complexity, but it didn't remove it.

Even with a dedicated developer, spinning up a page in Webflow took longer than it now takes us with Claude Code.

That was the point when the original tradeoff stopped making sense.

We had accepted less control because no-code was supposed to be faster. Once AI made code faster, the compromise became difficult to justify.

A few months ago, we went through a rebrand.

A team took the Figma designs and turned them into pixel-perfect, responsive Next.js pages. That gave us the initial component library and design foundation.

Then I trained Claude Code on our design system, UI kit, and design tokens.

I could describe a section using the patterns already on the site, and Claude Code could build it consistently. Marketing could direct the work without writing React.

I did a lot of the remaining site work myself, including the website copy, many sections and updates, and the micro-animations.

Animations used to mean creating or importing Lottie files. We now build many of them directly in optimized CSS. They're fast, and the content remains part of the page that search engines can rank.

The design system is what makes this repeatable. Claude Code isn't inventing a new visual language every time. It's working from the same tokens, components, and UI patterns as the rest of the site.

The process starts with what we already have.

Our agents draft the copy. Claude Code borrows components from existing pages. Images come from gpt-image-2. SEO, GEO, and AEO are handled as part of the page.

We can also create templated pages, including integration pages, without manually rebuilding the same structure each time.

And we can build free tools directly into the website.

That last part matters. In Webflow, the free tools had to live in a separate Next.js app. In the new setup, they can share the same codebase, components, and deployment workflow as the rest of the site.

For day-to-day content, marketing works in Sanity. For a new page, the team uses Claude Code.

A completely new page with no reusable components still needs more work, but that case is rare.

We didn't replace the block editor with an unreviewed AI publishing directly to production.

Everything is git-based.

The page workflow is:

Every change has a diff. Every page has a preview. Work in progress stays separate until it's ready.

Marketing gets a much faster way to create pages. Engineering keeps control over what reaches production.

The marketing site wasn't the only part of the stack we migrated.

We also moved the WordPress blog to Next.js and Sanity.

Blog pages now run through the same Next.js foundation, load quickly, and use structured schemas. We can experiment with the experience without maintaining a separate WordPress system behind NGINX.

Marketing still gets a CMS. The team can publish and edit through Sanity without opening the codebase.

Our Writesonic agent system also works with that content layer. It can spin up content, create drafts, and update existing posts.

The separation is straightforward:

This gives marketing an editor where an editor makes sense and code where code gives us more control.

I expected this section to contain a list of failures.

It doesn't.

Nothing really broke. We moved the blocks and pages fairly easily.

The important decision happened before the technical migration. We pruned the content library first.

We removed dormant, cannibalizing, and low-intent pages. A lot of them were older AI-writing and AI-content pages that no longer matched what we wanted the site to do.

We redirected the pages we removed.

That left us with far fewer pages to carry into the new system. The migration became easier because we had already decided which content still deserved to exist.

If I were doing this again, I'd use this order:

The stack change was easier than the content decision.

Moving a page from Webflow or WordPress into Next.js is mechanical. Deciding whether that page should survive is the part that needs judgment.

Our first Next.js attempt failed because every marketing request became an engineering request.

Webflow solved part of that problem, but it introduced consultant dependency, editing risk, platform limits, publishing problems, split infrastructure, and slower page creation.

Claude Code changed the operating model.

Marketing directs the AI. The AI works inside our design system and codebase. Vercel gives the team a preview. An engineer controls the final merge. Sanity handles routine content publishing.

We get the speed that originally attracted us to no-code, while keeping the code, flexibility, and deployment history.

That reversal is why we left Webflow.

If this kind of operating detail is useful, subscribe. And send this issue to the founder or marketer who's still coordinating website changes across a visual editor, consultants, and engineering.

PS. Has AI made you reconsider a no-code tool you once depended on? Reply and tell me what changed.