Static Site Generators: Your Secret Weapon for AI Content Strategy

By Mike Levin

This article? How to explain? Hmmm. I just go ahead and ask Claude to just explain to me what I’m doing.

Claude: Based on the article content and code I’ve reviewed, you’re developing a comprehensive approach to using static site generators (like Jekyll) with large language models for advanced content analysis and SEO optimization. Here’s what you’re doing:

1. Creating “Context Kung Fu” Methodology: You’ve developed a technique you call “Context Kung Fu” that leverages static site generators’ plain text storage (Markdown files with YAML front matter) to analyze entire websites using LLMs with large context windows.

2. Building Python Tools: You’ve created Python tools (like context_foo.py) that can:
   • Extract and parse YAML front matter from Markdown files
   • Process entire directories of blog posts
   • Manage token limits for different LLMs (Claude, GPT-4, Gemini)
   • Chunk content appropriately for LLM processing
   • Generate consistent URLs

3. Using GSC Data for SEO: You’ve recently added a section about “striking distance analysis” where you use Google Search Console data (analyzed with your gsc_page_query.ipynb notebook) to identify keywords ranking in positions 5-20 that could be improved.

4. Demonstrating Real-World Applications: You’re showing practical applications of this approach:
   • Site architecture analysis and reorganization
   • Striking distance keyword opportunities
   • Intelligent internal linking suggestions
   • Content gap identification

Your article is educational content explaining this methodology to other site owners and SEO professionals, highlighting how static site generators provide significant advantages for AI-powered content analysis compared to traditional CMS platforms like WordPress.

The key insight is that by storing content in clean, structured text files rather than databases, you can feed entire websites directly into LLMs for holistic analysis, gaining deeper insights than traditional SEO tools can provide.

Yup, thank you Claude. I couldn’t have said it better. There’s the article intro right there!

Static Site Generators: The Secret Context Kung Fu for LLM-Powered Content Analysis

Look, I’ll be straight with you. What I’m about to share isn’t just another “10 SEO tips” article. This is about a genuine paradigm shift that’s happening right now at the intersection of static site generators, large language models, and content strategy.

I’ve been in the trenches of SEO and content management for over 20 years, and I’ve never seen anything with the transformative potential of what’s happening today. If you’ve been managing websites with WordPress or other traditional CMS platforms, what I’m about to show you might seem like magic — but it’s just good context kung fu.

The Text-File Revelation

Here’s the deal: Static site generators like Jekyll, Hugo, and Gatsby aren’t just faster and more secure than WordPress — they’re fundamentally better suited for AI analysis. Why? They store everything as plain text files.

This might seem like a minor technical detail, but it changes everything about how you can leverage AI for content analysis.

When I first realized this, I was working on my own site after migrating from WordPress to Jekyll. I wanted to analyze my content strategy and identify gaps. With my old WordPress site, I would have needed to:

1. Export the database
2. Write queries to extract content
3. Clean HTML markup
4. Process content in chunks due to API limits
5. Hope I didn’t miss anything important

Instead, I ran a simple script (similar to the context_foo.py you see referenced in the title) that collected all my markdown files, extracted the front matter metadata, and fed everything directly into Claude with a 3 million token context window.

The conversation went something like:

Me: Here are 212 blog posts from the last 5 years. What are the main themes,
how have they evolved, what topics are we missing, and what should be our
content strategy for next quarter?

Claude: [Proceeds to deliver comprehensive analysis that would have taken a
human team weeks]

This isn’t just faster — it’s a fundamentally different approach to content analysis.

Yes, you could technically get this data through a website crawl, but that creates a broken feedback loop. When the LLM suggests changes based on crawled content, you’re stuck with the tedious task of manually implementing those changes back into your CMS. With a static site generator, the LLM can work directly with your actual content files — the same files you’ll be editing — creating a much tighter and more efficient workflow between analysis and implementation.

The Context Kung Fu Advantage

I call this approach “Context Kung Fu” because, like the martial art, it’s about leveraging position and structure rather than brute force. Traditional CMS platforms require you to muscle your way through databases and APIs. Static site generators let you flow with the natural structure of content.

The secret sauce has three main ingredients:

1. Markdown’s inherent parsability: Markdown files are clean, structured text that LLMs can process with minimal token waste. HTML from traditional CMSs is noisy, filled with divs, classes, and other markup that consumes precious tokens in your LLM’s context window.

2. YAML front matter: That little block at the top of each markdown file? It’s a gold mine. Categories, tags, dates, authors, custom fields — all neatly structured and ready for analysis. In WordPress, this metadata is scattered across database tables.

3. Direct file access: No API rate limits, no database queries — just files on disk that you can read directly.

Let me show you what this looks like in practice with a snippet from my own tooling:

def extract_front_matter(content):
    """Extract YAML front matter from Jekyll blog post."""
    front_matter_match = re.match(r'^---\n(.*?)\n---\n', content, re.DOTALL)
    if front_matter_match:
        try:
            front_matter = yaml.safe_load(front_matter_match.group(1))
            return front_matter, content[front_matter_match.end():]
        except yaml.YAMLError:
            return None, content
    return None, content

This simple function separates the structured metadata from the content body. Now I can analyze both independently or together, depending on the task.

Token Efficiency: More Content, Less Noise

Let’s talk numbers. I recently ran an experiment comparing the token usage between a WordPress export and the same content in Markdown:

That’s not a small difference — it’s more than double the efficiency. With today’s LLMs supporting context windows of 3M+ tokens (Claude), 2M tokens (Gemini 2?), or even 128K tokens (GPT-4), this efficiency means you can analyze more content in a single pass.

Let’s look at how we account for these different context windows in code:

# Model token limits
GEMINI_15_PRO_LIMIT = 2_097_152  # Gemini 1.5 Pro's 2M token limit
GEMINI_25_PRO_LIMIT = 1_048_576  # Gemini 2.5 Pro's 1M token limit
CLAUDE_LIMIT = 3_145_728  # Claude's 3M token limit
GPT_4_TURBO_LIMIT = 4_194_304  # GPT-4 Turbo's 4M token limit (128K tokens)
TOKEN_BUFFER = 10_000  # Buffer for pre/post prompts and overhead

By building awareness of these limits into your tools, you can make smart decisions about how to process your content.

Real-World Applications: Beyond Theory

Enough theory — let’s talk about what you can actually do with this approach:

1. One-Shot Site Architecture Analysis

My blog has 6 months worth of posts, and I was struggling to organize them effectively. The navigation was becoming unwieldy, and I couldn’t see the forest for the trees.

Using Context Kung Fu, I fed my entire blog into Claude and asked:

“Analyze these posts and propose a coherent site architecture with no more than 7 main categories and 3 levels of hierarchy. Identify the 20 most important posts that should serve as ‘hub pages’ for key topics.”

The result? A completely reimagined information architecture that made both intuitive and business sense, with clear paths between related topics and natural entry points for new readers.

This wasn’t just a mechanical organization — the LLM understood the conceptual relationships between posts that I hadn’t explicitly recognized myself, despite being the author!

2. Striking Distance Analysis with GSC Data

After noticing a traffic plateau in my blog analytics, I decided to go beyond basic keyword research. I exported my Google Search Console data using a custom Python script (gsc_page_query.ipynb) and fed it alongside my blog content into Claude.

I asked: “Based on my content and GSC data, identify keywords where I’m ranking positions 5-20 that align with my core topics, and recommend content updates to improve these positions.”

The LLM analyzed both my content evolution and ranking data, revealing something I hadn’t spotted: I had several articles ranking just outside the first page for high-intent keywords related to Python automation, but these posts lacked specific code examples that searchers were looking for.

What made this analysis powerful wasn’t just identifying “striking distance” keywords (positions 5-20), but understanding the relationship between my existing content and what users wanted. The LLM could pinpoint exactly which posts should be updated and how, rather than suggesting I create new content from scratch.

This approach would have been nearly impossible with traditional SEO tools alone. It required synthesizing my actual content, ranking data, and user intent - something LLMs excel at when given both the content and structured data for context.

3. Intelligent Internal Linking

Internal linking is one of the most powerful and underutilized SEO techniques. But doing it manually is tedious, and automated solutions often create forced, unnatural connections.

With Context Kung Fu, I’ve built systems that can:

1. Analyze the semantic relationships between all posts
2. Identify natural linking opportunities based on conceptual relevance, not just keyword matching
3. Generate natural anchor text that fits the content flow
4. Prioritize links based on business goals (conversion pages, underperforming content, etc.)

Here’s how we might structure a prompt to achieve this:

Analyze these blog posts and identify natural internal linking opportunities. 
For each post, suggest up to 5 other posts that would make valuable internal links.
For each suggestion, explain:
1. Why these posts are conceptually related
2. Where in the source post the link would naturally fit
3. Natural anchor text that would make sense in context
4. The business value of creating this link (improving underperforming content, creating topical clusters, etc.)

The Tools of Context Kung Fu

You don’t need to be a programming wizard to implement these techniques. Here’s a simplified version of my own approach:

1. Basic File Processing

import os
import yaml
import re

def process_markdown_directory(directory_path):
    """Process all markdown files in a directory."""
    posts = []
    for filename in os.listdir(directory_path):
        if filename.endswith('.md'):
            filepath = os.path.join(directory_path, filename)
            with open(filepath, 'r') as f:
                content = f.read()
                front_matter, post_content = extract_front_matter(content)
                posts.append({
                    'filename': filename,
                    'front_matter': front_matter,
                    'content': post_content,
                    'url': get_post_url(front_matter, filename)
                })
    return posts

2. Token Management

For larger sites, you’ll need to be smart about token usage:

def estimate_tokens(text):
    """Estimate token count using a simple heuristic."""
    # Very rough estimate: average English word is ~1.3 tokens
    return len(text.split()) * 1.3

def chunk_content(posts, max_tokens=2000000):
    """Split posts into chunks that fit within token limits."""
    chunks = []
    current_chunk = []
    current_tokens = 0
    
    for post in posts:
        post_text = yaml.dump(post['front_matter']) + post['content']
        post_tokens = estimate_tokens(post_text)
        
        if current_tokens + post_tokens > max_tokens:
            chunks.append(current_chunk)
            current_chunk = [post]
            current_tokens = post_tokens
        else:
            current_chunk.append(post)
            current_tokens += post_tokens
            
    if current_chunk:
        chunks.append(current_chunk)
        
    return chunks

3. URL Management

Maintaining consistent URLs is crucial:

def get_post_url(front_matter, filename):
    """Generate consistent URLs from front matter or filename."""
    if front_matter and 'permalink' in front_matter:
        permalink = front_matter['permalink'].strip('/')
        return f"https://yourblog.com/{permalink}/"
    
    # Extract date and slug from Jekyll filename format (YYYY-MM-DD-title.md)
    match = re.match(r'(\d{4}-\d{2}-\d{2})-(.*).md', filename)
    if match:
        date, slug = match.groups()
        return f"https://yourblog.com/{date}/{slug}/"
    
    # Fallback
    return f"https://yourblog.com/posts/{filename.replace('.md', '')}"

Beyond Text: The Future of Content Analysis

What I’ve described is just the beginning. As LLMs continue to evolve, we’re seeing new possibilities emerge:

Multimodal Analysis

Modern LLMs like GPT-4 Vision and Gemini can analyze images alongside text. For a static site, this means you can include image analysis in your content audit:

def process_post_with_images(post_path, images_dir):
    """Process a post and its associated images."""
    with open(post_path, 'r') as f:
        content = f.read()
    
    front_matter, post_content = extract_front_matter(content)
    
    # Extract image references from markdown
    image_pattern = r'!\[.*?\]\((.*?)\)'
    image_paths = re.findall(image_pattern, post_content)
    
    image_data = []
    for img_path in image_paths:
        full_img_path = os.path.join(images_dir, img_path)
        if os.path.exists(full_img_path):
            # For GPT-4 Vision, you'd convert these to base64
            image_data.append({
                'path': img_path,
                'exists': True
            })
    
    return {
        'front_matter': front_matter,
        'content': post_content,
        'images': image_data
    }

Semantic Embeddings

Vector embeddings take Context Kung Fu to the next level. By generating embeddings for each post, you can perform similarity searches, cluster related content, and identify conceptual patterns that might not be apparent from keywords alone:

from openai import OpenAI

client = OpenAI()

def generate_embeddings(posts):
    """Generate embeddings for a list of posts."""
    results = []
    for post in posts:
        # Combine title and content for a complete representation
        text = f"{post['front_matter'].get('title', '')} {post['content']}"
        
        response = client.embeddings.create(
            input=text,
            model="text-embedding-3-small"
        )
        
        embedding = response.data[0].embedding
        results.append({
            'post': post,
            'embedding': embedding
        })
    
    return results

The Philosophical Shift: Content as a Knowledge Graph

The most profound impact of Context Kung Fu isn’t technical — it’s philosophical. It changes how we think about content.

Traditional CMS platforms encourage us to think of content as individual pages in a hierarchy. Static sites with LLM analysis let us see content as it truly is: a knowledge graph where each piece connects to others through complex semantic relationships.

This shift has implications beyond SEO. It affects:

• Content Creation: Writing with awareness of how each piece fits into the larger knowledge graph
• User Experience: Creating navigation that reflects actual conceptual relationships, not just hierarchical categories
• Business Strategy: Identifying knowledge gaps and opportunities based on the structure of existing content

Getting Started: Your First Steps

If you’re intrigued by this approach but don’t know where to start, here’s a simple roadmap:

1. If you’re already using a static site generator: Congratulations! You’re halfway there. Start with the simple scripts I’ve shared and experiment with feeding your content to LLMs like Claude, GPT-4, or Gemini.

2. If you’re on WordPress: Consider a migration to a static site generator, or at least create a parallel static export for analysis purposes. Tools like Jekyll Exporter can help.

3. If you’re just starting: Choose a static site generator like Jekyll, Hugo, or Eleventy. The investment in learning these tools will pay off enormously in your ability to leverage AI for content analysis.

The most important step is to start thinking differently about your content. It’s not just a collection of pages — it’s a knowledge graph waiting to be discovered, analyzed, and optimized.

The Context Foo Way

I call my approach to this “Context Foo” (a play on “kung fu,” which literally means “skill achieved through hard work”). It’s about mastering the art of context — knowing how to collect, structure, and present your content to LLMs in ways that reveal insights impossible to discover otherwise.

Like any martial art, Context Foo has its principles:

1. Respect the text: Clean, well-structured content is the foundation
2. Flow, don’t force: Work with the natural structure of your content rather than fighting it
3. Adapt to change: As LLMs evolve, so should your techniques
4. Practice mindfully: Each analysis teaches you something new about your content

The script I reference at the beginning, context_foo.py, embodies these principles. It’s not just a utility — it’s a way of thinking about content that respects its inherent structure and flow.

Final Thoughts: The New Information Craft

We’re entering a new era of content management — one where the boundaries between writing, SEO, information architecture, and data science are blurring.

The practitioners who will thrive in this new landscape aren’t just writers or marketers or developers. They’re information craftspeople who understand how to shape and structure content for both human readers and AI analysis.

The tools I’ve shared are just the beginning. The real power comes from combining them with your unique understanding of your content and business goals.

So start your Context Foo journey. Learn the basic moves, practice regularly, and soon you’ll be performing content analysis feats that would have seemed impossible just a few years ago.

Your content has stories to tell — stories about its structure, its evolution, its gaps and opportunities. With Context Kung Fu, you can finally hear them.

Gemini 2.5 Experimental’s Take

Okay, here are the requested pieces based on the article:

Summary from the Author’s Perspective (Brief Paragraph):

[Moved to top]

Title and Headline Ideas:

• Context Kung Fu: Master LLM Content Analysis with Static Sites
• Static Site Generators: Your Secret Weapon for AI Content Strategy
• Unlock Deep Content Insights: Why SSGs Beat WordPress for LLM Analysis
• The Text-File Advantage: Supercharge LLM Analysis with Markdown & YAML
• Beyond WordPress: How Static Sites Enable Next-Gen AI Content Audits
• Token Efficiency & Deep Insights: The Power of SSGs + LLMs
• Analyze Your Entire Site with AI: The Static Site Generator Method
• Content as Code, Analysis as Conversation: SSGs Meet LLMs
• From Database Drudgery to Context Flow: AI Analysis with Static Sites
• The Future is Static: Leveraging SSGs for Smarter Content AI

Article Strengths:

• Clear Value Proposition: Effectively argues the specific advantages of SSGs for LLM analysis.
• Compelling Metaphor: “Context Kung Fu” / “Context Foo” is memorable and helps illustrate the core idea of leveraging structure.
• Practical Examples: Provides concrete use cases (architecture, gaps, linking) that resonate with content professionals.
• Technical Grounding: Includes code snippets and discusses token efficiency, adding credibility and demonstrating feasibility.
• Authoritative Voice: The author establishes expertise through stated experience.
• Forward-Looking: Touches upon future possibilities like multimodal analysis and embeddings.
• Actionable Advice: Offers clear starting points for readers depending on their current tech stack.

Article Weaknesses:

• Technical Barrier to Entry: Assumes a degree of technical comfort with SSGs, command-line tools, and basic scripting (Python).
• Downplays SSG Complexity: Migrating from a traditional CMS to an SSG, or learning an SSG workflow from scratch, involves a significant learning curve and effort not fully captured.
• LLM Access/Cost: Doesn’t explicitly address the potential costs or complexities of accessing and using large context window LLMs.
• Potential for Oversimplification: While powerful, LLM analysis isn’t always “magic” and can require significant prompt engineering and result validation, which isn’t deeply explored.
• Niche Audience: The core message is most relevant to those directly involved in website technical management, SEO, and advanced content strategy willing to explore alternative platforms.

My (AI) Opinion of the Article:

This is a highly insightful and valuable article that clearly articulates a significant, practical advantage of static site generator architecture in the age of large language models. The author effectively connects the technical characteristics of SSGs (plain text files, Markdown, YAML front matter) to tangible benefits in AI-driven content analysis (token efficiency, direct access, structured data). The “Context Kung Fu” metaphor is effective, and the real-world examples and code snippets provide a strong foundation for understanding and implementing the described techniques. While it might slightly understate the technical hurdles for some users migrating to or adopting SSGs, the core argument is sound and forward-thinking. It highlights a crucial intersection of web development practices and AI capabilities, offering a compelling vision for more powerful and efficient content strategy analysis for those equipped to leverage it.