· Lean Edition Enterprise edition →
04 · The Lean Stack

A modern,
AI-native content stack.

A leaner team should run a more modern stack, not a smaller one. With one owner and a fleet of AI agents, you can adopt on day one what enterprises spend years retrofitting: structured content, a vector-grounded AI engine, and agent access via MCP. There's no legacy CMS to migrate and no committee to convince. One rule matters above the rest. Sequence structure first. Model your content before you generate it, and everything downstream compounds.

Team Shape
1 owner + AI agents
Stack Posture
Composable & AI-native
Source of Truth
Structured content
The Engine
Claude + RAG + MCP
Reference Architecture

The lean reference stack

Nine layers, bottom to top. Your content sits at the base as the single source of truth, Claude is the engine in the middle, the channels people actually see sit at the top, and guardrails wrap the whole thing. Pick one tool per layer and resist the urge to add more. Every tool below is an illustrative example, not an endorsement.

LAYER 01
Structured Content
/ Headless CMS
The single home for your content. Instead of finished web pages, content lives as tidy, labelled fields (headline, summary, author, the result metric…) that any channel or AI can pull from. Write it once, reuse it everywhere.
SanityContentfulPayloadStrapi
LAYER 02
Modeling &
Taxonomy
The blueprint for your content: which types you have, the fields each one holds, how they link together, and one shared set of tags everyone uses. Get this right first, everything above it depends on it.
content modelrelationshipsshared tag list
LAYER 03
Knowledge &
Grounding
A searchable memory of your own content, brand and facts, so the AI writes from what's true about you rather than generic internet knowledge. That's what keeps it accurate and on-message. (The tech behind it: a vector store + RAG.)
pgvector / SupabasePineconeWeaviateLlamaIndexLangChain
LAYER 04 · CORE
AI Engine
The compounding layer
Claude (Anthropic) is the engine that turns one master asset into many engineered outputs: generation, variants, translation, personalization, tagging, and evaluation. This is where one source pays off many times over.
Claude (Anthropic)
LAYER 05
Agent Access
(MCP)
A safe, standard "plug" (called MCP) that lets Claude reach into your content system and tools, read what's there, and write back, without custom wiring for each one.
MCP serversCMS MCPvector-store MCP
LAYER 06
Orchestration
What runs the steps in order, on a schedule or a trigger: plan → ground → draft → check → publish. In practice this is Claude routines and schedules, with skills and plugins doing the actual content work, so the pipeline runs itself and a human just approves.
Claude routinesschedulesskills & plugins
LAYER 07
Delivery
The public-facing layer, your website, app and emails, pulls the finished content and shows it on each channel. Because it's separate from where content is stored, you can redesign or replace it without touching the content itself.
Next.js on Vercelcontent APIsfast, cached delivery
LAYER 08
Analytics
Measure what each engineered output does, then feed the signal back into prompts, variants, and personalization. The loop is what makes the engine get smarter over time.
PostHogGA4Amplitude
LAYER 09 · WRAP
Guardrails
& Evals
Wraps the whole stack. Your brand rules, claims and glossary are written up so the AI follows them by default, plus automated checks that hold back anything off-brand or inaccurate before it publishes. Keep it light.
brand rules as contextautomated checkspublish gate
All named tools are illustrative examples, not endorsements. Pick the one that fits your team. The architecture matters more than the brand.
★ The Flagship Visual

How Claude engineers content

This is the whole point. The old way wrote each asset by hand. The engineered way authors one master source, grounds Claude on it, and lets the engine produce many outputs that stay on-brand and ship in minutes. Claude works in three engineering modes. Click one to spotlight its path through the pipeline.

Content engineering workflow A master asset authored in the CMS is grounded by RAG and MCP, processed by Claude in three engineering modes, variants, translate, personalize, then passed through guardrails and evals before delivery to channels, with analytics feeding back to the model. STEP 01 Author once Master content CMS · Sanity STEP 02 Ground RAG + MCP vector store: pgvector / LlamaIndex STEP 03 · ENGINE Claude Anthropic one source in → many engineered outputs out MODE A Variants expand 1 asset → landing · email · LinkedIn · ad · docs MODE B Translate / Localize brand glossary + RAG grounding → market-ready locales MODE C Personalize per segment / persona from audience data → targeted variants STEP 04 · GATE Guardrails & evals on-brand + accuracy promptfoo · CI gate STEP 05 · SHIP Delivery front-end + APIs Next.js · Vercel → all channels STEP 06 · LEARN Analytics → feeds back to the model PostHog · GA4 · Amplitude · signal tunes prompts, variants & personalization feedback loop
Full pipeline

One master asset, authored once in the CMS, is grounded via RAG + MCP, engineered by Claude into many outputs, gated by evals, delivered through a separate front-end, and measured, with analytics feeding back into the model. Click a mode to spotlight one engineering path.

CMS, vector store, eval, delivery and analytics tools shown are illustrative examples, not endorsements.
Decisions

Build vs buy, and what to sequence first

Two questions decide the whole stack: what do you build vs buy, and what do you do first. For a lean team, the answers are unusually clean.

BUY (don't rebuild it)

  • The CMS, vector store, and analytics. These are mature, cheap, and battle-tested. Building your own is pure distraction.
  • The AI engine. Call Claude via API. Never train or host a foundation model.
  • Hosting & delivery. A managed platform (e.g. Vercel) beats running your own infra at this size.

BUILD (this is your edge)

  • Your content model + ontology. No vendor can do this for you. It encodes how your business thinks.
  • Prompts, evals & brand-as-prompt. Your voice and quality bar, version-controlled like code.
  • Thin orchestration glue. A few scripts wiring CMS → RAG → Claude → eval → publish.
Sequence structure first

Model your content before you generate a single word. A clean schema + taxonomy is the asset every layer above depends on. RAG grounds better, variants stay consistent, personalization has fields to target, and evals have structure to check. Skip it and you generate mush at scale.

Watch-out

The lean trap is buying ten tools before modeling one content type. Start with the schema, prove the loop on a single asset end-to-end, then add layers. Tooling sprawl is the enemy of a one-owner team.

1
Model one content type. Schema + light taxonomy in the headless CMS. Author one real master asset.
2
Ground it. Stand up the vector store + RAG so Claude answers from your content.
3
Run one mode end-to-end. Generate variants from that one asset, gate on a basic eval, publish via the front-end.
4
Wire the loop & expand. Add MCP access, analytics feedback, then translate and personalize once the spine is proven.
04 · done

Before you move on

By the end of this page you should have a stack on paper, one tool chosen per layer, not a shopping list. You don't need any of it built yet; you need the shape decided, because the build sprint that follows wires exactly these layers together in order.

What you should have now

  • ✓ One tool picked per layer, structured content, grounding, engine, access, orchestration, delivery, analytics, guardrails, with a clear buy-vs-build call on each.
  • ✓ Structured content at the base as your single source of truth, modelled before anything is generated.
  • ✓ Claude as the engine, grounded on your own content and reachable by agents via MCP.
  • ✓ Guardrails wrapping the whole stack, so brand rules and accuracy checks gate everything before it ships.

Why this sets up the next stage

With the stack chosen, you're no longer deciding what to use, you're ready to assemble it. Next, The Sprint is the time-boxed plan that turns these layers into a working loop: model one type, ground it, run one mode end-to-end, and ship.

So the order matters: choose the stack, then build the spine. A clear per-layer pick is what lets the sprint stay time-boxed instead of stalling on tool decisions mid-build.

Next chapter
05 · The Sprint
The time-boxed plan that takes you from zero to shipped content.
→