This spring we rebuilt rangle.io in the gaps between client engagements. Five weeks of focused buildout spread over four months. One engineer, Claude as a constant pair, 850 pieces of content moved off Sanity.
The new site runs on MDX files in the same repo as the application code, edited and reviewed like a feature change. Claude Code and the agentic harnesses we've built through client engagements are our content management interface now. No CMS surface, no separate publishing tool, no extra place for things to drift. Agents edit it, and agents read it.
We made the change for a specific reason. We'd noticed our team can update the site through Claude Code more readily than through most CMS interfaces. That's not universally true. It's true at Rangle because we've been investing in agentic delivery practices on client engagements for two years. Once we noticed it, the CMS abstraction stopped paying for itself.
A CMS is general-purpose software designed to work for hundreds of teams that look nothing like yours. SaaS economics perpetuate that breadth. You pay for the workflows, role-based permissions, approval queues, WYSIWYG editor, and content-modeling DSL whether your team uses them or not. Many teams continue to pay the toll for these services. Our team decided we wanted to move at our own pace. We pulled the M out of CMS, and the team is happier without it.
The cost of an abstraction
Lee Robinson made the broader version of the case sharply after migrating cursor.com off its CMS to raw code and Markdown in three focused days for $260 in tokens: with AI and coding agents, the cost of an abstraction has never been higher. We've been making essentially the same argument to clients for two years. The pieces of the practice (typed frontmatter, validators in CI, parallel sub-agents, JSON-LD as the agent contract) aren't novel. What changed for us is having a team mature enough in agentic delivery to actually operate it end to end. So we ran it on ourselves.
What "doing it to ourselves" actually looked like
The scaffold went up January 16. Followed by about eight weeks where nothing happened, because hiring, travel, client engagements, and the bigger agentic-positioning writing all outranked the website. Real buildout started April 8 and ran 35 days.
A useful contrast on scope. Robinson migrated cursor.com in three focused days. Cursor's sitemap has about 130 URLs, most of them blog posts and a flat marketing surface. Cursor is three years old. Rangle is thirteen. Our content tree spans 850 pieces of structured content across a dozen surfaces, with 500+ blog posts, 207 team profiles, 34 case studies, and distinct subtrees for expertise, solutions, partners, industries, and insights. Layered underneath: multiple partial migrations over the years, several of which never finished. The previous "current" stack was already two stacks old. The tools and styling primitives we wanted (Tailwind, Next.js App Router, React Server Components, shadcn/ui) weren't the go-to choices last time anyone took a serious pass at the visual layer.
So the work wasn't only moving content. It was moving content while rebuilding the entire component system on a different stack, untangling thirteen years of accreted URLs without losing link equity, and absorbing redirect debt from prior subdomain experiments. About 22,000 lines of application code, every meaningful change through code review and CI.
Five moves that did the heavy lifting
Specifics, because "agents helped" is too vague to be useful to anyone reading this.
MDX as the content layer. Every page is a .mdx file with frontmatter. The schema is enforced by validate-content.ts running in CI. The real win isn't that we replaced Sanity. It's that content now lives in PRs and can be edited atomically with metadata, redirects, and structured data in the same change. The content team can finally work in the same surface as the engineers, without a ticket.
Facet taxonomy first. Before any pages moved, we defined content/facets.yml.
Six buyer-aligned use cases (Modernize Your Stack, Ship AI Features, Scale Your Design, and so on), capabilities, industries, technology. Every page declares its facets. The site wires itself together from there. Open a case study, see related case studies grouped by use case. Open a service, see the blog posts and partner pages that share its capability. Getting the taxonomy right before content moved meant nothing had to be re-tagged at scale later. This was the single decision with the longest downstream return.
Parallel sub-agents for the boring at-scale work. The 34-case-study migration ran as Claude sub-agents in parallel, one per case study, each consuming legacy Sanity JSON and emitting a single MDX file with frontmatter. Same pattern for the 502 blog posts. The migration code was written once. The output got reviewed by hand. The bottleneck stopped being "how fast can the engineer type" and became "how fast can the engineer review." That's a different bottleneck, and it's one that scales (we're looking at ways to scale it further).
Validators in CI as the safety net. Multiple parallel agents are only safe if there's a CI step that fails when any of them produces a malformed file. validate-content.ts schema-checks every MDX frontmatter block against facets.yml. A typo'd facet, a missing required field, a slug that doesn't match its filename, all fail the build. We trust the validator. We don't trust the model alone, and we don't have to.
JSON-LD as the agent contract: what agentic SEO actually requires. Every page emits WebPage.about populated from its facets, plus BreadcrumbList, Organization, and FAQPage where it fits. Ask Claude or ChatGPT or Perplexity what Rangle does in retail design systems, and the answer is structured for them to read, not buried in marketing prose. Agentic search is already a meaningful slice of inbound traffic for some of our clients. Some people are starting to call this Answer Engine Optimization (AEO). The shape we built for is the same either way. A site that doesn't expose its structure cleanly is going to age badly, fast.
What surprised us
The faceted auto-linking turned out to be the most durable artifact. We expected the value to be in the new pages. The actual value is that every new piece of content automatically surfaces on every related page without anyone wiring it up. The site teaches itself as it grows. We've planned with this in mind in setting up some of our clients' largest CMS initiatives and migrations. Watching it pay back in real time on our own surface reset our intuitions about how much investment to push for upfront on client engagements.
Parallel sub-agents were faster than we'd budgeted for. Forty pages of expertise and services content in a single PR. We'd been mentally pricing AI work as "fast typing." This was closer to "small focused team of researchers who don't need to sleep." The implication for client work is that the cost curve isn't linear in content volume the way we'd been quoting it.
Quality checking turned into product judgment. With agents doing the producing, the bottleneck moved to "does this match what we actually want?" That question is faster to answer when the person reviewing also owns the product decisions. A small team built around a single decision-maker who has the product in their head moved faster than any larger team we've tried at this kind of work. The tooling matters less than who's holding the product.
What slowed us down
Migration-script shape drifted. We did a lot to ensure things were correctly aligned upfront, but inevitably those contracts changed. We learned the schema as we went, especially as we found unexpected past pages in our archives. We adapted, but the process slowed things down a bit. The lesson is to lock the output schema in the validator before kicking off parallel batches, not after the second batch lands.
The legacy redirect surface was bigger than we'd assumed. The SEMRush 404 sweep, the frozen Sanity-managed redirect docs, the subdomain backlinks all surfaced late and cumulatively added days. Worth doing right because the link equity is real money. Worth budgeting for next time and worth bringing into discovery earlier.
The dormant period. The honest version is we let ourselves off the hook for two months. Thirty minutes a week of momentum-keeping would have been the difference between five weeks of intense buildout and ten weeks of comfortable progress. That's true on internal work. It's especially true when there's no client meeting pulling you back.
What changes for us now
The rebuild was the work. The point was learning what happens when a team that's been delivering agentically for clients runs the same loop on something it owns.
A few things stood out. Agent-readable structure isn't an SEO nice-to-have anymore, it's how some clients are already getting found. The bottleneck on content work isn't typing speed; it's reviewer attention. And side-of-desk is a real working mode if you plan for the dormant weeks instead of pretending they won't happen.
What's next on our side is housekeeping: decommission the legacy site, wire up llms.txt for agent discoverability, capture post-launch traffic against the baseline. The bigger shifts are operational. Marketing experiments ship as PRs. New case studies arrive in the same shape as a button change. SEO work happens without a deploy plan.
We didn't rebuild rangle.io to make a point. We rebuilt it because it was the work we were already doing for clients, and we wanted to run it on something we owned. The site is the proof. The way of working is the takeaway.
If you're sitting on a CMS migration you've been postponing, or trying to figure out where coding agents fit in your delivery model, come find us. We've been running it on ourselves.
