AI Killed the CMS — For Simple Websites, At Least

TL;DR

For simple websites — portfolios, blogs, landing pages, small business sites — a traditional CMS is becoming unnecessary overhead. AI tools like Claude Code, Cursor, and GitHub Copilot can now edit your codebase directly, understand context, translate content, and deploy changes through git. The abstraction layer that CMS provided is being replaced by a smarter interface: natural language.

The CMS tax you're paying

Every CMS comes with a hidden cost. Not just the subscription fee — the entire ecosystem of complexity that wraps around your otherwise simple website:

• Infrastructure: A database to host, an API to maintain, a dashboard to secure. WordPress alone accounts for ~43% of the web and ~90% of CMS-targeted attacks.
• Performance: Dynamic page generation, API calls on every request, client-side hydration of CMS data. Your 3-page portfolio now has the architecture of a SaaS product.
• Vendor lock-in: Your content lives in someone else's database schema. Migrating from Contentful to Sanity? That's a project, not a config change.
• Context switching: Edit code in your IDE, then switch to a browser-based CMS dashboard to change a headline. Two different mental models for what is fundamentally the same operation.
• Cost: Headless CMS pricing often scales with API calls or content entries. A personal blog doesn't need a $99/month content infrastructure.

For a marketing site with 50 people editing content daily, this cost is justified. For a developer's portfolio or a small business landing page? You're building a bridge to cross a puddle.

What changed: AI understands your code

The reason CMS existed was straightforward: non-technical people (and even developers who didn't want to touch code for content changes) needed a visual interface to update websites. The code was too complex, too fragile, too easy to break.

AI fundamentally changed this equation. Modern AI coding tools don't just autocomplete — they understand project structure, read existing patterns, and make contextually correct edits. The workflow shift is dramatic:

# Old workflow: CMS
1. Open browser → log into CMS dashboard
2. Navigate to content → find the right page
3. Edit in WYSIWYG editor → fight with formatting
4. Preview → looks different from production
5. Hit publish → pray the cache invalidates

# New workflow: AI
1. Tell AI: "Change the pricing on the landing page to $29/month"
2. AI edits the file, you review the diff
3. Push to git → deploy

This isn't hypothetical. This very blog runs on SolidStart with content stored as TypeScript files. Every article — including this one — was created by telling AI what to write, reviewing the output, and pushing to git. No CMS dashboard. No database. No API layer between the content and the code.

Real examples from this site

This website supports 10 languages, has a blog, generates OG images dynamically, and produces RSS feeds and sitemaps. Here's what the content layer looks like — pure TypeScript:

// This blog post you're reading right now is a TypeScript file.
// No database. No API. No CMS dashboard.
// Just a typed object that AI can read and edit directly.

export const myPost: BlogPost = {
  slug: "ai-killed-cms",
  date: "2026-04-17",
  translations: {
    en: {
      title: "Why I stopped using a CMS",
      description: "AI understands my codebase better than any CMS UI.",
      content: makeContent(proseEn),
    },
    uk: { /* ... */ },
    de: { /* ... */ },
    // 10 languages — AI translates them all
  },
};

Things I do with AI that would traditionally require a CMS:

• Add a new blog post: "Write a new article about X, follow the same structure as existing posts" — AI creates the file, adds translations, registers it in the index
• Update landing page copy: "Change the hero tagline to Y" — AI finds the right file and updates it
• Translate content: "Add German translation for the pricing page" — AI reads the English version and produces a culturally adapted translation, not a word-for-word swap
• Fix a typo: "There's a typo on the about page, 'recieve' should be 'receive'" — done in 3 seconds, committed to git with a meaningful message

What CMS actually solved — and how AI replaces it

Let's be honest about what CMS brought to the table and how each capability maps to the AI workflow:

The key insight: git is already a better version control system than any CMS has ever built. And natural language is a better interface than any WYSIWYG editor — because it carries intent, not just formatting.

The paradigm shift: code is the content layer

We're witnessing an inversion. For two decades, the trend was to separate content from code — put content in a database, expose it via API, render it on the frontend. This made sense when code was hard to edit and content needed to be accessible to non-developers.

AI didn't make CMS obsolete by being a better CMS. It made CMS obsolete by making code as accessible as a dashboard.

The progression of web content management follows a clear trajectory:

1. 2000s: Monolithic CMS (WordPress, Drupal) — content and presentation coupled in one system
2. 2010s: Headless CMS (Contentful, Strapi) — content separated via API, rendered by frontend frameworks
3. 2020s: Static site generators + Markdown (Hugo, Astro) — content as files, built at deploy time
4. 2025+: Code-as-content + AI — content lives in typed code, AI is the editing interface

When you still need a CMS

This isn't a "CMS is dead" take. CMS solves real problems at scale. You still need one when:

• Large editorial teams: 10+ content editors who need role-based access, approval workflows, and simultaneous editing. Git merge conflicts are not a content editor's problem to solve.
• High-frequency content: News sites publishing 50+ articles per day need optimized editorial pipelines, not git commits.
• Complex content relationships: E-commerce catalogs with thousands of SKUs, product variants, and dynamic pricing need structured databases.
• Regulatory compliance: Industries requiring audit trails, content approval chains, and legally mandated review processes need purpose-built systems.

The boundary is clear: if your content changes require coordination between multiple non-technical stakeholders at high frequency, a CMS earns its complexity. If you're a solo developer, a small team, or managing a site that changes weekly rather than hourly — AI + code is simpler, faster, cheaper, and more reliable.

The future: AI as the universal interface

The trend extends beyond CMS. Every software abstraction layer that existed because "the underlying system is too complex for direct interaction" is being compressed by AI. Admin dashboards, config UIs, visual database editors — all of these are interfaces that translate human intent into system changes. AI does this translation natively.

For simple websites, the future is already here. Your content is code. Your editor is AI. Your version control is git. Your deployment is a push. The entire CMS layer — the dashboard, the database, the API, the hosting — was middleware between your intent and your website. AI removed the need for that middleware.

The best CMS is no CMS. Not because content management doesn't matter — but because AI made the code itself the most intuitive content management interface we've ever had.