IAMUVIN

AI & Machine Learning

Building an AI Content Generation Pipeline

Uvin Vindula·June 3, 2024·11 min read

Last updated: April 14, 2026

Share

TL;DR

AI content generation isn't about replacing writers. It's about building a pipeline that handles the repetitive 80% — product descriptions, meta tags, content briefs, first drafts — so humans can focus on the 20% that actually needs a human voice. I've built these pipelines for clients using the Claude API with structured prompts, Zod validation on every output, automated quality scoring, and mandatory human review before anything goes live. The result: 10x content throughput at roughly 40% of the cost, with quality that passes editorial review. This guide covers the exact architecture, prompt patterns, quality control layers, and cost breakdown from real production systems. I'll also be honest about where AI content falls flat and where you still need a human with domain expertise and a pulse.

The Content Pipeline Architecture

Every content pipeline I've built follows the same five-stage architecture. Skip a stage and you'll ship garbage at scale — which is worse than shipping nothing.

Input → Enrich → Generate → Validate → Review → Publish

Stage one is Input. This is where you define what you want: content type, topic, target keywords, tone, audience, length constraints. Structure this as a typed object, not a loose prompt string. Loose prompts produce loose output.

Stage two is Enrich. Before you send anything to the LLM, you gather context. Pull existing content from your CMS to avoid duplication. Fetch keyword data from your SEO tools. Load brand guidelines, style guides, product specs — whatever the model needs to produce informed output. The difference between generic AI content and useful AI content is almost always the quality of context you provide.

Stage three is Generate. This is the Claude API call with a structured prompt. I use system prompts for persona and constraints, user prompts for the specific brief, and I always request structured output — either JSON or markdown with predictable headings.

Stage four is Validate. Automated checks on the output: word count within range, no hallucinated links, readability score above threshold, keyword density in bounds, no duplicate content against your existing corpus. If validation fails, the content goes back to stage three with adjusted parameters. I cap retries at three — if the model can't produce valid output in three attempts, the brief needs human attention.

Stage five is Review. A human reads every piece before it publishes. I know that defeats the "fully automated" dream, but I've seen what happens when you skip this. AI content without human review is a liability.

Here's the core pipeline type:

typescript
// lib/content-pipeline/types.ts
import { z } from 'zod';

export const ContentBriefSchema = z.object({
  type: z.enum(['blog-post', 'product-description', 'meta-tags', 'social-post']),
  topic: z.string().min(10),
  keywords: z.array(z.string()).min(1).max(10),
  targetWordCount: z.number().min(50).max(5000),
  tone: z.enum(['professional', 'conversational', 'technical', 'casual']),
  audience: z.string(),
  brandVoice: z.string().optional(),
  existingContent: z.string().optional(),
  seoData: z.object({
    primaryKeyword: z.string(),
    searchVolume: z.number().optional(),
    competitorUrls: z.array(z.string()).optional(),
  }).optional(),
});

export type ContentBrief = z.infer<typeof ContentBriefSchema>;

export const GeneratedContentSchema = z.object({
  title: z.string(),
  body: z.string(),
  metaDescription: z.string().max(160),
  excerpt: z.string().max(300),
  suggestedSlug: z.string(),
  keywordsUsed: z.array(z.string()),
  estimatedReadTime: z.number(),
});

export type GeneratedContent = z.infer<typeof GeneratedContentSchema>;

export interface PipelineResult {
  content: GeneratedContent;
  qualityScore: number;
  validationErrors: string[];
  retryCount: number;
  costUsd: number;
  tokensUsed: { input: number; output: number };
}

Everything is typed. Everything is validated. When someone asks "what does the pipeline produce?" — you point them at the schema, not a Slack thread.

Prompt Design for Consistent Quality

The single biggest factor in content quality isn't the model — it's the prompt architecture. I've tested dozens of prompt structures and the pattern that consistently produces publishable content is a three-layer system: persona, constraints, and brief.

The persona layer goes in the system prompt. It defines who the model is pretending to be, what they know, and how they write. Be specific. "You are a content writer" produces generic sludge. "You are a senior content writer specializing in B2B SaaS with 8 years of experience writing for technical decision-makers" produces content with actual voice.

The constraints layer defines hard rules. Word count limits, formatting requirements, things to avoid, required sections. These go in the system prompt too, because they apply to every generation — not just this one.

The brief layer goes in the user prompt. It's the specific request: write about this topic, for this audience, hitting these keywords.

typescript
// lib/content-pipeline/prompts.ts
interface PromptConfig {
  persona: string;
  constraints: string[];
  outputFormat: string;
}

const CONTENT_PROMPTS: Record<string, PromptConfig> = {
  'blog-post': {
    persona: `You are a senior content writer with deep expertise in technology and business. 
You write in a direct, conversational style — short sentences, concrete examples, no filler. 
You never use phrases like "in today's fast-paced world" or "it's important to note." 
You back claims with specifics: numbers, case studies, technical details. 
You write for practitioners who build things, not executives who read summaries.`,
    constraints: [
      'Use H2 headings to break content into scannable sections',
      'Include at least one code example or technical diagram per 500 words',
      'Every claim must include a specific number, example, or reference',
      'No paragraphs longer than 4 sentences',
      'No bullet point lists longer than 7 items',
      'Do not use these words: leverage, synergy, ecosystem, paradigm, holistic',
      'Do not start any sentence with "It is" or "There are"',
      'End with a concrete next step the reader can take today',
    ],
    outputFormat: `Return a JSON object with these fields:
- title: compelling headline under 70 characters
- body: full article in markdown
- metaDescription: SEO meta description under 160 characters
- excerpt: article summary under 300 characters
- suggestedSlug: URL-friendly slug
- keywordsUsed: array of keywords naturally included
- estimatedReadTime: minutes to read at 200 wpm`,
  },

  'product-description': {
    persona: `You are an e-commerce copywriter who converts features into benefits. 
You write product descriptions that answer the buyer's real question: "why should I care?"
You use sensory language for physical products and outcome language for digital products.
You never pad descriptions with obvious statements.`,
    constraints: [
      'Lead with the primary benefit, not the product name',
      'Include exactly 3-5 bullet points for key features',
      'Each bullet starts with a benefit, then explains the feature',
      'Total length between 150-300 words',
      'Include one social proof element if context is available',
      'End with a clear call-to-action',
    ],
    outputFormat: `Return a JSON object with these fields:
- title: product title optimized for search
- body: full product description in markdown
- metaDescription: SEO meta description under 160 characters
- excerpt: one-sentence product summary
- suggestedSlug: URL-friendly slug
- keywordsUsed: array of keywords naturally included
- estimatedReadTime: minutes to read`,
  },
};

export function buildSystemPrompt(contentType: string): string {
  const config = CONTENT_PROMPTS[contentType];
  if (!config) {
    throw new Error(`Unknown content type: ${contentType}`);
  }

  return [
    config.persona,
    '',
    '## Rules',
    ...config.constraints.map((c, i) => `${i + 1}. ${c}`),
    '',
    '## Output Format',
    config.outputFormat,
  ].join('\n');
}

export function buildUserPrompt(brief: ContentBrief): string {
  const parts = [
    `Write a ${brief.type} about: ${brief.topic}`,
    `Target audience: ${brief.audience}`,
    `Tone: ${brief.tone}`,
    `Target word count: ${brief.targetWordCount}`,
    `Primary keywords: ${brief.keywords.join(', ')}`,
  ];

  if (brief.brandVoice) {
    parts.push(`Brand voice guidelines: ${brief.brandVoice}`);
  }
  if (brief.existingContent) {
    parts.push(`Context from existing content: ${brief.existingContent}`);
  }
  if (brief.seoData) {
    parts.push(`Primary SEO keyword: ${brief.seoData.primaryKeyword}`);
    if (brief.seoData.searchVolume) {
      parts.push(`Search volume: ${brief.seoData.searchVolume}/month`);
    }
  }

  return parts.join('\n');
}

Two things I learned the hard way about prompt design for content:

Ban specific words. Every LLM has verbal tics. Claude loves "certainly" and "I'd be happy to." GPT-4 loves "delve" and "tapestry." Your ban list should grow over time as you spot patterns in output. I maintain a shared ban list across all client projects and update it monthly.

Constrain paragraph length. Without explicit limits, models produce dense walls of text. "No paragraphs longer than 4 sentences" is one of the highest-impact constraints I've found. It forces the model to break ideas into digestible chunks, which is exactly what you want for web content.

Template System

For recurring content types — weekly blog posts, product launches, category pages — I use a template system that separates structure from content. The template defines the sections, their order, and their constraints. The model fills in the content.

typescript
// lib/content-pipeline/templates.ts
interface ContentSection {
  id: string;
  heading: string;
  instruction: string;
  minWords: number;
  maxWords: number;
  required: boolean;
}

interface ContentTemplate {
  name: string;
  sections: ContentSection[];
  globalRules: string[];
}

const BLOG_TEMPLATE: ContentTemplate = {
  name: 'technical-blog-post',
  sections: [
    {
      id: 'hook',
      heading: '',
      instruction: 'Open with a specific problem the reader faces. No generic intros.',
      minWords: 50,
      maxWords: 100,
      required: true,
    },
    {
      id: 'context',
      heading: 'Why This Matters',
      instruction: 'Explain the business or technical impact of this problem with real numbers.',
      minWords: 100,
      maxWords: 200,
      required: true,
    },
    {
      id: 'solution',
      heading: 'The Approach',
      instruction: 'Walk through the solution step by step. Include code or architecture diagrams.',
      minWords: 400,
      maxWords: 800,
      required: true,
    },
    {
      id: 'implementation',
      heading: 'Implementation',
      instruction: 'Show the actual code. Explain key decisions. Cover edge cases.',
      minWords: 300,
      maxWords: 600,
      required: true,
    },
    {
      id: 'results',
      heading: 'Results',
      instruction: 'Share measurable outcomes. Before/after metrics. Lessons learned.',
      minWords: 100,
      maxWords: 300,
      required: true,
    },
    {
      id: 'takeaways',
      heading: 'Key Takeaways',
      instruction: 'Summarize 3-5 actionable points the reader can apply today.',
      minWords: 50,
      maxWords: 150,
      required: true,
    },
  ],
  globalRules: [
    'Write in first person when sharing experience, third person for general advice',
    'Every section must add new information — no repeating points across sections',
    'Use transition sentences between sections so the article flows naturally',
  ],
};

export function templateToPrompt(template: ContentTemplate): string {
  const sections = template.sections.map((s) => {
    const heading = s.heading ? `## ${s.heading}` : '(Opening paragraph, no heading)';
    return `${heading}\n${s.instruction}\nWord count: ${s.minWords}-${s.maxWords} words.${s.required ? ' REQUIRED.' : ' Optional.'}`;
  });

  return [
    `Follow this template structure exactly:`,
    '',
    ...sections,
    '',
    'Global rules:',
    ...template.globalRules.map((r) => `- ${r}`),
  ].join('\n');
}

Templates solve three problems at once. They make output predictable across batches — every blog post has the same structure, which your CMS and your readers expect. They make quality easier to measure — you can validate each section independently against its word count and instruction. And they make iteration faster — when a client says "the conclusions are too vague," you update one instruction in one template, not fifty prompts.

I store templates in a database, not in code, so non-technical team members can adjust them through a simple admin interface. The code loads the template by ID at runtime. This separation has saved me from dozens of "can you just tweak the tone" deployment cycles.

Quality Control — Automated Checks

Every piece of generated content passes through an automated quality gate before a human sees it. The gate catches the obvious failures so your reviewers spend their time on judgment calls, not typo hunting.

typescript
// lib/content-pipeline/quality.ts
import { GeneratedContent } from './types';

interface QualityCheckResult {
  passed: boolean;
  score: number;
  errors: string[];
  warnings: string[];
}

function countWords(text: string): number {
  return text.split(/\s+/).filter(Boolean).length;
}

function calculateReadability(text: string): number {
  const sentences = text.split(/[.!?]+/).filter(Boolean);
  const words = text.split(/\s+/).filter(Boolean);
  const syllables = words.reduce((sum, word) => {
    return sum + countSyllables(word);
  }, 0);

  if (sentences.length === 0 || words.length === 0) return 0;

  const avgWordsPerSentence = words.length / sentences.length;
  const avgSyllablesPerWord = syllables / words.length;

  // Flesch-Kincaid grade level
  return 0.39 * avgWordsPerSentence + 11.8 * avgSyllablesPerWord - 15.59;
}

function countSyllables(word: string): number {
  word = word.toLowerCase().replace(/[^a-z]/g, '');
  if (word.length <= 3) return 1;
  const vowelGroups = word.match(/[aeiouy]+/g);
  let count = vowelGroups ? vowelGroups.length : 1;
  if (word.endsWith('e')) count--;
  return Math.max(count, 1);
}

const BANNED_PHRASES = [
  'in today\'s fast-paced world',
  'it\'s important to note',
  'in conclusion',
  'without further ado',
  'game-changer',
  'paradigm shift',
  'synergy',
  'at the end of the day',
  'low-hanging fruit',
  'move the needle',
  'deep dive into',
  'revolutionize',
  'seamlessly',
];

export function runQualityChecks(
  content: GeneratedContent,
  targetWordCount: number,
  requiredKeywords: string[]
): QualityCheckResult {
  const errors: string[] = [];
  const warnings: string[] = [];
  let score = 100;

  const wordCount = countWords(content.body);

  // Word count check: within 20% of target
  const lowerBound = targetWordCount * 0.8;
  const upperBound = targetWordCount * 1.2;
  if (wordCount < lowerBound) {
    errors.push(`Word count ${wordCount} is below minimum ${lowerBound}`);
    score -= 20;
  } else if (wordCount > upperBound) {
    warnings.push(`Word count ${wordCount} exceeds target by >20%`);
    score -= 5;
  }

  // Readability check: target grade 8-12
  const readability = calculateReadability(content.body);
  if (readability > 14) {
    warnings.push(`Readability grade ${readability.toFixed(1)} is too high — simplify language`);
    score -= 10;
  } else if (readability < 6) {
    warnings.push(`Readability grade ${readability.toFixed(1)} is too low — content may lack depth`);
    score -= 5;
  }

  // Banned phrase check
  const bodyLower = content.body.toLowerCase();
  for (const phrase of BANNED_PHRASES) {
    if (bodyLower.includes(phrase)) {
      errors.push(`Contains banned phrase: "${phrase}"`);
      score -= 10;
    }
  }

  // Keyword usage check
  for (const keyword of requiredKeywords) {
    const keywordLower = keyword.toLowerCase();
    const occurrences = bodyLower.split(keywordLower).length - 1;
    if (occurrences === 0) {
      errors.push(`Missing required keyword: "${keyword}"`);
      score -= 15;
    } else if (occurrences > Math.ceil(wordCount / 200)) {
      warnings.push(`Keyword "${keyword}" appears ${occurrences} times — possible stuffing`);
      score -= 5;
    }
  }

  // Meta description length
  if (content.metaDescription.length < 120) {
    warnings.push('Meta description is short — aim for 150-160 characters');
    score -= 5;
  }

  // Title length
  if (content.title.length > 70) {
    warnings.push('Title exceeds 70 characters — may be truncated in search results');
    score -= 5;
  }

  // Duplicate paragraph detection
  const paragraphs = content.body.split('\n\n').filter((p) => p.trim().length > 50);
  const seen = new Set<string>();
  for (const para of paragraphs) {
    const normalized = para.trim().toLowerCase().slice(0, 100);
    if (seen.has(normalized)) {
      errors.push('Duplicate paragraph detected');
      score -= 15;
      break;
    }
    seen.add(normalized);
  }

  return {
    passed: errors.length === 0 && score >= 70,
    score: Math.max(0, score),
    errors,
    warnings,
  };
}

A few notes on what I check and why:

Banned phrases catch the most common AI-isms. I started with ten phrases and the list has grown to about forty across my client projects. Every month I review a sample of generated content and add any new phrases that feel obviously machine-written. This is the cheapest quality intervention you can make.

Keyword density has both a floor and a ceiling. Missing the primary keyword means the content won't rank. Stuffing it means Google penalizes you and readers notice. I use a simple ratio: no more than one occurrence per 200 words. It's a rough heuristic but it catches the extremes.

Duplicate paragraph detection catches a specific failure mode where the model restates the same point in different sections. This happens more often than you'd expect, especially with longer content. The check is naive — it compares the first 100 characters of each paragraph — but it catches the worst cases.

Human Review Layer

Automated checks catch the mechanical failures. Human review catches everything else: factual accuracy, brand alignment, tone consistency, logical flow, and the subtle wrongness that a quality score can't measure.

I build the review layer as a simple queue with three states: pending, approved, and rejected with feedback. When content is rejected, the feedback goes back into the generation prompt as a correction. This creates a feedback loop that improves the pipeline over time.

typescript
// lib/content-pipeline/review.ts
interface ReviewItem {
  id: string;
  content: GeneratedContent;
  qualityScore: number;
  qualityWarnings: string[];
  status: 'pending' | 'approved' | 'rejected';
  reviewerNotes: string | null;
  generationMetadata: {
    promptVersion: string;
    model: string;
    retryCount: number;
    costUsd: number;
  };
  createdAt: Date;
  reviewedAt: Date | null;
}

interface ReviewFeedback {
  decision: 'approve' | 'reject';
  notes: string;
  editedContent?: Partial<GeneratedContent>;
}

export function applyReviewFeedback(
  original: GeneratedContent,
  feedback: ReviewFeedback
): GeneratedContent {
  if (feedback.decision === 'approve' && feedback.editedContent) {
    return { ...original, ...feedback.editedContent };
  }
  return original;
}

export function feedbackToPromptCorrection(feedback: ReviewFeedback): string {
  if (feedback.decision === 'approve') return '';

  return [
    'IMPORTANT: A human reviewer rejected the previous version with this feedback:',
    feedback.notes,
    '',
    'Address this feedback specifically in the new version.',
    'Do not repeat the same mistakes.',
  ].join('\n');
}

The key insight is that rejected content shouldn't just disappear. The reviewer's feedback is training data for your prompt. If a reviewer keeps saying "too salesy" or "missing technical depth," those become permanent constraints in your system prompt. Over three months of a client project, the rejection rate typically drops from 30% to under 10% as the prompts absorb reviewer feedback.

I also track which types of content get rejected most often. Product descriptions in technical niches have a high rejection rate because the model doesn't know the product specifics. Blog posts on broad topics have a low rejection rate. This data tells you where to invest in better context enrichment (stage two of the pipeline) versus where the model can handle things on its own.

SEO Optimization in the Pipeline

SEO isn't a step you bolt on after generation. It's embedded in every stage of the pipeline — from keyword research in the brief to schema markup in the output.

typescript
// lib/content-pipeline/seo.ts
interface SeoAnalysis {
  titleScore: number;
  metaScore: number;
  headingStructure: boolean;
  keywordPlacement: {
    inTitle: boolean;
    inFirstParagraph: boolean;
    inH2: boolean;
    inMetaDescription: boolean;
  };
  internalLinkOpportunities: string[];
  schemaType: string;
}

export function analyzeSeo(
  content: GeneratedContent,
  primaryKeyword: string
): SeoAnalysis {
  const kwLower = primaryKeyword.toLowerCase();
  const titleLower = content.title.toLowerCase();
  const bodyLower = content.body.toLowerCase();
  const metaLower = content.metaDescription.toLowerCase();

  const firstParagraph = content.body.split('\n\n')[0] || '';
  const headings = content.body.match(/^## .+$/gm) || [];
  const h2Texts = headings.map((h) => h.toLowerCase());

  const inTitle = titleLower.includes(kwLower);
  const inFirstParagraph = firstParagraph.toLowerCase().includes(kwLower);
  const inH2 = h2Texts.some((h) => h.includes(kwLower));
  const inMetaDescription = metaLower.includes(kwLower);

  let titleScore = 0;
  if (inTitle) titleScore += 40;
  if (content.title.length <= 60) titleScore += 30;
  if (titleLower.indexOf(kwLower) < 30) titleScore += 30; // keyword near start

  let metaScore = 0;
  if (inMetaDescription) metaScore += 40;
  if (content.metaDescription.length >= 140 && content.metaDescription.length <= 160) {
    metaScore += 40;
  }
  if (metaLower.indexOf(kwLower) < 60) metaScore += 20;

  // Check heading hierarchy
  const h1Count = (content.body.match(/^# [^#]/gm) || []).length;
  const h2Count = headings.length;
  const headingStructure = h1Count <= 1 && h2Count >= 2;

  return {
    titleScore,
    metaScore,
    headingStructure,
    keywordPlacement: { inTitle, inFirstParagraph, inH2, inMetaDescription },
    internalLinkOpportunities: findLinkOpportunities(bodyLower),
    schemaType: inferSchemaType(content),
  };
}

function findLinkOpportunities(text: string): string[] {
  const linkableTopics = [
    { keyword: 'api', suggestedPath: '/services' },
    { keyword: 'web development', suggestedPath: '/services' },
    { keyword: 'case study', suggestedPath: '/work' },
    { keyword: 'contact', suggestedPath: '/contact' },
  ];

  return linkableTopics
    .filter(({ keyword }) => text.includes(keyword))
    .map(({ keyword, suggestedPath }) => `Link "${keyword}" to ${suggestedPath}`);
}

function inferSchemaType(content: GeneratedContent): string {
  if (content.body.includes('```')) return 'TechArticle';
  if (content.estimatedReadTime > 5) return 'Article';
  return 'BlogPosting';
}

The four keyword placements I check — title, first paragraph, at least one H2, and meta description — are table stakes for on-page SEO. Missing any of them means you've left easy ranking signals on the table. The pipeline instruction bakes these into the prompt constraints so the model handles them during generation, not as a post-processing step.

I also generate internal link suggestions automatically. The pipeline knows your site's URL structure. When the generated content mentions a topic you have a page for, it flags the opportunity. This turns every batch of generated content into an internal linking exercise, which compounds over time.

Handling Different Content Types

Not all content is created equal. A product description pipeline looks nothing like a blog post pipeline. I define adapters for each content type that adjust the prompt structure, validation rules, and quality thresholds.

typescript
// lib/content-pipeline/adapters.ts
interface ContentAdapter {
  type: string;
  maxRetries: number;
  qualityThreshold: number;
  model: string;
  maxTokens: number;
  temperature: number;
  preProcess: (brief: ContentBrief) => ContentBrief;
  postProcess: (content: GeneratedContent) => GeneratedContent;
}

const adapters: Record<string, ContentAdapter> = {
  'blog-post': {
    type: 'blog-post',
    maxRetries: 3,
    qualityThreshold: 75,
    model: 'claude-sonnet-4-20250514',
    maxTokens: 4096,
    temperature: 0.7,
    preProcess: (brief) => ({
      ...brief,
      targetWordCount: Math.max(brief.targetWordCount, 800),
    }),
    postProcess: (content) => ({
      ...content,
      body: addTableOfContents(content.body),
    }),
  },
  'product-description': {
    type: 'product-description',
    maxRetries: 2,
    qualityThreshold: 80,
    model: 'claude-haiku-4-20250514',
    maxTokens: 1024,
    temperature: 0.5,
    preProcess: (brief) => ({
      ...brief,
      targetWordCount: Math.min(brief.targetWordCount, 300),
    }),
    postProcess: (content) => content,
  },
  'meta-tags': {
    type: 'meta-tags',
    maxRetries: 2,
    qualityThreshold: 90,
    model: 'claude-haiku-4-20250514',
    maxTokens: 512,
    temperature: 0.3,
    preProcess: (brief) => brief,
    postProcess: (content) => ({
      ...content,
      metaDescription: content.metaDescription.slice(0, 160),
    }),
  },
  'social-post': {
    type: 'social-post',
    maxRetries: 2,
    qualityThreshold: 70,
    model: 'claude-haiku-4-20250514',
    maxTokens: 512,
    temperature: 0.8,
    preProcess: (brief) => ({
      ...brief,
      targetWordCount: Math.min(brief.targetWordCount, 280),
    }),
    postProcess: (content) => content,
  },
};

function addTableOfContents(markdown: string): string {
  const headings = markdown.match(/^## .+$/gm);
  if (!headings || headings.length < 3) return markdown;

  const toc = headings
    .map((h) => {
      const text = h.replace('## ', '');
      const anchor = text.toLowerCase().replace(/[^a-z0-9]+/g, '-');
      return `- [${text}](#${anchor})`;
    })
    .join('\n');

  return `## Table of Contents\n\n${toc}\n\n${markdown}`;
}

export function getAdapter(contentType: string): ContentAdapter {
  const adapter = adapters[contentType];
  if (!adapter) {
    throw new Error(`No adapter found for content type: ${contentType}`);
  }
  return adapter;
}

The important decisions here are model selection and temperature per content type.

Blog posts use Sonnet at temperature 0.7. You want some creativity in long-form content — varied sentence structure, unexpected analogies, natural-feeling transitions. Haiku would produce flat, formulaic posts. Opus would be overkill and three times the cost.

Product descriptions use Haiku at temperature 0.5. These are short, structured, and repetitive. You're generating hundreds of them with similar patterns. Haiku handles this at a fraction of the cost with nearly identical quality to Sonnet for this specific use case.

Meta tags use Haiku at temperature 0.3. You want precision, not creativity. The meta description must be exactly between 140 and 160 characters, include the keyword, and accurately describe the page. Low temperature keeps the output predictable.

Cost Analysis — Real Numbers

Here's what a production content pipeline actually costs. These numbers are from a client project that generates approximately 200 pieces of content per month: 40 blog posts, 120 product descriptions, and 40 sets of meta tags.

Content TypeModelAvg Input TokensAvg Output TokensCost Per PieceMonthly VolumeMonthly Cost
Blog PostSonnet2,4003,200$0.02840$1.12
Product DescriptionHaiku800400$0.001120$0.12
Meta TagsHaiku600200$0.000640$0.02
Retries (~15%)Mixed———~30$0.35
Total API Cost~230$1.61

The API cost is almost irrelevant. At $1.61 per month for 200 pieces of content, the model is the cheapest part of the system. The real costs are:

  • Engineering time to build and maintain the pipeline: 40-60 hours upfront, 4-8 hours monthly.
  • Human review time: 2-3 minutes per piece for an experienced reviewer, roughly 8-10 hours per month for 200 pieces.
  • SEO tool subscriptions: $100-300/month for keyword data and competitor analysis.
  • CMS and hosting: $20-50/month for the content management infrastructure.

Total real cost for 200 pieces per month: approximately $2,000-3,000 including labor, versus $8,000-15,000 for the same volume from freelance writers. That's the actual value proposition — not "AI is free" but "AI reduces the cost per piece by 60-75% while maintaining acceptable quality."

One caveat: these numbers assume the pipeline is already built. The upfront engineering investment is significant. For a client generating fewer than 50 pieces per month, the ROI timeline stretches to 6+ months. Below 20 pieces per month, it's often cheaper to just hire a writer.

When AI Content Works and When It Doesn't

I've shipped enough AI content pipelines to be honest about the boundaries.

AI content works well for:

  • Product descriptions from structured data. Feed it specs, features, and a product category — it'll produce solid descriptions at scale. This is the highest-ROI use case I've seen.
  • SEO content briefs and meta tags. The model excels at synthesizing keyword data into structured outlines and concise meta descriptions.
  • First drafts of blog posts on well-documented topics. If the subject has extensive public information, the model produces a solid 70% draft that a human can polish.
  • Content variations. A/B test headlines, email subject lines, ad copy variations — generating twenty options and picking the best three is faster than writing three from scratch.
  • Content localization. Adapting content for different markets (adjusting tone, examples, cultural references) is a natural fit for LLMs.

AI content fails at:

  • Original research and reporting. The model can't interview people, attend events, or analyze proprietary data. If your content strategy depends on original insights, AI can't help.
  • Deep domain expertise. A model writing about semiconductor manufacturing or maritime law will produce plausible-sounding content that domain experts immediately identify as shallow. The confidence-to-accuracy ratio is dangerously high.
  • Brand voice that took years to develop. You can approximate a brand voice with few-shot examples, but the result is a cover band, not the original artist. For brands where voice is the product (think Stripe's documentation, Apple's marketing), AI content feels off.
  • Emotional and persuasive writing. Fundraising appeals, personal essays, crisis communications — anything that requires genuine empathy lands flat when generated.
  • Anything requiring factual precision. The model will confidently state incorrect statistics, cite papers that don't exist, and attribute quotes to the wrong people. Every factual claim in AI-generated content must be verified by a human.

The pattern is clear: AI content works when you need volume, consistency, and structure. It fails when you need depth, originality, and emotional resonance. The pipeline doesn't replace your content team. It amplifies them.

My Production Pipeline

Here's the orchestrator that ties everything together. This is the function I call from a Next.js API route or a background job when a content brief is submitted.

typescript
// lib/content-pipeline/pipeline.ts
import Anthropic from '@anthropic-ai/sdk';
import { ContentBrief, ContentBriefSchema, GeneratedContentSchema } from './types';
import { buildSystemPrompt, buildUserPrompt } from './prompts';
import { runQualityChecks } from './quality';
import { analyzeSeo } from './seo';
import { getAdapter } from './adapters';
import type { PipelineResult } from './types';

const client = new Anthropic();

export async function generateContent(
  rawBrief: unknown
): Promise<PipelineResult> {
  // Stage 1: Validate input
  const brief = ContentBriefSchema.parse(rawBrief);
  const adapter = getAdapter(brief.type);
  const processedBrief = adapter.preProcess(brief);

  // Stage 2: Build prompts
  const systemPrompt = buildSystemPrompt(brief.type);
  const userPrompt = buildUserPrompt(processedBrief);

  let lastError: string | null = null;
  let retryCount = 0;
  let totalInputTokens = 0;
  let totalOutputTokens = 0;

  // Stage 3: Generate with retry loop
  while (retryCount <= adapter.maxRetries) {
    const correctionNote = lastError
      ? `\n\nPrevious attempt failed validation: ${lastError}. Fix these issues.`
      : '';

    const response = await client.messages.create({
      model: adapter.model,
      max_tokens: adapter.maxTokens,
      temperature: adapter.temperature,
      system: systemPrompt,
      messages: [
        {
          role: 'user',
          content: userPrompt + correctionNote,
        },
      ],
    });

    totalInputTokens += response.usage.input_tokens;
    totalOutputTokens += response.usage.output_tokens;

    // Extract text content
    const textBlock = response.content.find((block) => block.type === 'text');
    if (!textBlock || textBlock.type !== 'text') {
      lastError = 'No text content in response';
      retryCount++;
      continue;
    }

    // Parse JSON from response
    let parsed: unknown;
    try {
      const jsonMatch = textBlock.text.match(/\{[\s\S]*\}/);
      if (!jsonMatch) throw new Error('No JSON found in response');
      parsed = JSON.parse(jsonMatch[0]);
    } catch {
      lastError = 'Failed to parse JSON from model response';
      retryCount++;
      continue;
    }

    // Validate against schema
    const contentResult = GeneratedContentSchema.safeParse(parsed);
    if (!contentResult.success) {
      lastError = contentResult.error.errors.map((e) => e.message).join('; ');
      retryCount++;
      continue;
    }

    const content = adapter.postProcess(contentResult.data);

    // Stage 4: Quality checks
    const quality = runQualityChecks(
      content,
      processedBrief.targetWordCount,
      processedBrief.keywords
    );

    if (!quality.passed && retryCount < adapter.maxRetries) {
      lastError = quality.errors.join('; ');
      retryCount++;
      continue;
    }

    // Stage 5: SEO analysis
    const seo = processedBrief.seoData
      ? analyzeSeo(content, processedBrief.seoData.primaryKeyword)
      : null;

    // Calculate cost (Sonnet pricing as of 2024)
    const costUsd = estimateCost(adapter.model, totalInputTokens, totalOutputTokens);

    return {
      content,
      qualityScore: quality.score,
      validationErrors: [...quality.errors, ...quality.warnings],
      retryCount,
      costUsd,
      tokensUsed: { input: totalInputTokens, output: totalOutputTokens },
    };
  }

  throw new Error(
    `Content generation failed after ${adapter.maxRetries} retries. Last error: ${lastError}`
  );
}

function estimateCost(
  model: string,
  inputTokens: number,
  outputTokens: number
): number {
  const pricing: Record<string, { input: number; output: number }> = {
    'claude-sonnet-4-20250514': { input: 3.0, output: 15.0 },
    'claude-haiku-4-20250514': { input: 0.8, output: 4.0 },
    'claude-opus-4-20250514': { input: 15.0, output: 75.0 },
  };

  const rates = pricing[model] || pricing['claude-sonnet-4-20250514'];
  return (
    (inputTokens / 1_000_000) * rates.input +
    (outputTokens / 1_000_000) * rates.output
  );
}

The pipeline exposes a single function: generateContent. You pass in a brief, it returns structured content with quality metadata. The retry loop handles validation failures automatically. The cost tracking gives you per-piece economics. The adapter system means adding a new content type is a config change, not a code change.

In production, I wrap this in a Next.js API route with authentication and rate limiting, and connect it to a review queue in the CMS. The reviewer sees the content, the quality score, any warnings, and the generation cost. They approve, edit, or reject. Rejected content goes back through the pipeline with their feedback appended.

The entire system — types, prompts, quality checks, SEO analysis, adapters, and orchestrator — is about 800 lines of TypeScript. Not 8,000. Not a microservices architecture with message queues and ML pipelines. Just typed functions that do one thing each, composed into a pipeline that works.

Key Takeaways

  1. Structure your input. Typed briefs with Zod validation prevent garbage-in-garbage-out. Every field in the brief is a lever you can tune.
  1. Invest in prompts, not models. A well-crafted prompt with banned phrases, length constraints, and structural templates produces better content from Haiku than a lazy prompt from Opus.
  1. Automate the obvious checks. Word count, readability, keyword density, banned phrases, duplicate detection — these are mechanical. Let code handle them.
  1. Never skip human review. AI content without editorial oversight is a brand risk. The pipeline amplifies your content team; it doesn't replace them.
  1. Use the right model for the job. Haiku for structured, short-form content. Sonnet for long-form. Opus only when quality justifies 5x the cost. Model selection per content type is the easiest cost optimization.
  1. Track rejection patterns. Every rejected piece is feedback for your prompts. Fold reviewer notes into system prompt constraints. The pipeline gets better over time — but only if you close the loop.
  1. Be honest about limitations. AI content works for volume and consistency. It fails for originality and depth. Know which side of that line your content falls on before you build the pipeline.

*I build AI content pipelines, search systems, and automation tools for businesses that need to scale their content operations without scaling their headcount. If you're generating more than 50 pieces of content per month and spending too much on writers for repetitive formats, let's talk about what a pipeline could do for you.*

*— Uvin Vindula (@IAMUVIN↗)*

Working on a Web3 or AI project?

Let's talk↗
Share
Uvin Vindula

Uvin Vindula

Web3 and AI engineer based in Sri Lanka and the UK. Author of The Rise of Bitcoin. Director of Blockchain and Software Solutions at Terra Labz. Founder of uvin.lk — Sri Lanka's Bitcoin education platform with 10,000+ learners.

hello@iamuvin.comuvin.lk↗LinkedIn↗