How We Built a 500-Article pSEO Pipeline Using Claude Code and $0 in API Costs

Tiger Tail case study: the build, the architecture, and the real numbers, including the unflattering ones.

The problem

Tiger Tail needed organic search traffic. We had a brand-new WordPress site, zero indexed pages, and no content library. Our competitors had years of blog content, domain authority, and backlinks. Going head-to-head on individual keywords would take months to show results.

The standard playbook for this situation is programmatic SEO: generate a large volume of targeted content around long-tail keywords, publish it systematically, and let compound indexing do the work. But the standard tools for pSEO (API-based content generation, n8n workflows, expensive SaaS platforms) felt like overkill for a bootstrapped agency.

We wanted to build the whole pipeline ourselves, keep costs near zero, and produce content that actually reads like a human wrote it.

What we built

A fully automated content pipeline that takes a keyword from a spreadsheet and turns it into a published blog post with SEO metadata, FAQ schema, featured images, YouTube video embeds, and internal linking structure. No manual writing. No copy-paste. No CMS login required.

Total infrastructure cost: $0 beyond the Claude Max subscription we already had.

Phase 1: keyword research and data structure

We started with 500 keywords across 11 categories mapped to Tiger Tail’s service areas:

Each keyword was scored by search intent (commercial, informational, investigational, transactional) and assigned to a priority batch. Batch 1 contained the 59 highest-value commercial keywords closest to Tiger Tail’s core offering. Batch 5 contained 225 informational keywords for long-tail coverage.

Airtable served as the control panel. Every keyword became a row with status tracking, content storage, image queries, YouTube queries, article type, and WordPress post metadata. The status field acted as a state machine: scripts only process records matching specific statuses, which prevents duplicate processing and gives full visibility into where every keyword sits in the pipeline.

Phase 2: content generation with Claude Code

The original plan was to use the Anthropic API with n8n orchestration. We scrapped that when we realized our Claude Max subscription (already paid for) includes access via Claude Code. That saved roughly $75–125 in API costs for 500 articles.

The generation script (generate.sh) reads “Queued” records from Airtable, pipes each keyword to Claude Code with a system prompt file, parses the structured JSON response, and writes the content back to Airtable. Error handling includes status rollback (failed records get marked “Error” with the error message in a notes field), local JSON backups of every generated article, and a fallback JSON extractor that finds valid JSON even when the model adds preamble text.

The key technical decisions:

• claude -p for headless mode, with --system-prompt-file for the writing instructions
• --output-format text with --max-turns 3 to give Opus enough room for long articles
• --model opus for quality (Sonnet was an option for speed but the quality difference was noticeable)
• Structured JSON output mapping directly to WordPress ACF fields, eliminating any parsing ambiguity
• 3-second delay between generations to avoid rate limiting

Phase 3: the system prompt

The system prompt went through multiple iterations and ended up at 323 lines. It’s the single most important piece of the pipeline because it determines content quality. Here’s what’s in it and why.

Voice and humanization. We identified the specific patterns that make AI content detectable: uniform sentence length, corporate jargon, em dashes, synonym cycling, hollow intensifiers, “from X to Y” constructions, and formulaic section structure. The prompt bans 40+ specific words and phrases, requires sentence length variation, allows sentence fragments and tangents, and instructs the model to “let occasional mess in” because perfect structure feels algorithmic.

The banned word list includes the obvious ones (leverage, streamline, cutting-edge) but also the subtler AI tells that most people miss: “serves as a testament,” “reflects broader trends,” “intricate interplay,” “it could potentially be argued.” These came from a humanizer skill based on Wikipedia’s “Signs of AI Writing” guide.

Factual accuracy. We explicitly banned fabricated statistics. The first version of the prompt produced articles citing “McKinsey estimates 11%” and “a Forrester study found 3.5x” with numbers that may not exist. The updated prompt says: if you’re not sure a stat is real, use directional language instead (“most companies” rather than “73% of companies”).

AI search extractability. Based on Princeton’s GEO research (KDD 2024), we optimized for AI citation: 40–60 word standalone definition blocks in the first 300 words, self-contained answer passages, comparison tables for commercial content, and query-phrased H2 headings. A brand entity consistency rule ensures Tiger Tail is described identically across all 500 articles, creating a strong signal for both RAG retrieval and future training data. (This is the same discipline we sell as Found, our AEO/GEO service; we just pointed it at ourselves first.)

Copywriting principles. Pulled from dedicated copywriting and copy-editing skills: the “So What” test (every claim must bridge to a reader benefit), specificity requirements (replace “save time” with “save 4 hours a week”), active voice enforcement, and CTA formulas specific to Tiger Tail’s free AI audit offer.

Article type detection. The prompt auto-detects the appropriate format from the keyword: versus articles for “X vs Y” queries, listicles for “best” or “top” keywords, how-to guides for “how to” keywords, checklists for “assessment” or “readiness” keywords, Q&A articles for question-phrased keywords, and so on. Each type has specific structural instructions (versus articles require a comparison table in the first 500 words, checklists use grouped checkpoints with scoring, etc.).

Content depth by buyer stage. Informational articles target 1,800–2,500 words with frameworks the reader can apply. Commercial articles target 1,200–1,800 words with comparison tables and honest evaluation criteria. Transactional articles are 800–1,200 words and get to the resource quickly. Each intent maps to a buyer stage with specific tactical guidance.

Phase 4: WordPress publishing

Publishing required solving several technical problems that aren’t documented well anywhere.

ACF repeater fields via REST API. WordPress’s Secure Custom Fields plugin (an ACF fork) stores repeater data as individual meta rows (faq_items_0_question, faq_items_0_answer, _faq_items_0_question, etc.) rather than a single JSON blob. We had to register each sub-field individually for REST API access via a WPCode snippet with a loop generating 10 slots per repeater, plus register the ACF field key references (the underscore-prefixed meta entries like _faq_items → field_tt_faq) so the template’s have_rows() function recognizes the data.

Protected meta fields. WordPress protects underscore-prefixed meta keys by default. We added an is_protected_meta filter via WPCode to allow writing to the ACF field key references and RankMath SEO fields through the REST API.

The payload builder. Article content with HTML, quotes, and special characters broke every shell-based JSON construction method we tried. The final approach: use jq to safely serialize all data into a temp file (jq handles escaping properly), then a Python script reads the file, expands the FAQ and related_searches repeaters into individual meta keys with field references, and outputs the complete WordPress REST API payload.

The publish flow: create post → upload featured image from Unsplash → set as featured media → search YouTube and embed video → insert inline images → update post content with media → update Airtable with post ID, URL, and YouTube URL.

Phase 5: image and video integration

Unsplash images with duplicate prevention. A shared used_photo_ids.txt file tracks every Unsplash photo ID used across both publish.sh and add-images.sh. Each search fetches 5 results and picks the first one not already in the registry. For the retroactive image script, we built a query generator that produces 3 varied search queries per keyword (topic-specific, category-visual, and diverse fallback) using deterministic hashing so different keywords get different images but the same keyword always gets the same queries.

YouTube embeds with quality filtering. The publish script searches YouTube for each article’s query, fetches statistics for the top 10 results in a single API call, and only embeds videos with 1,000+ views. It selects the highest-viewed qualifying video. The video URL is recorded in Airtable so it can be manually reviewed and swapped if needed.

Rate limit management. Unsplash’s demo tier allows 50 requests per hour (roughly 20 images). YouTube’s free tier allows roughly 95 searches per day. The scripts handle rate limit errors gracefully (posts still publish without images or video), and the retroactive scripts skip posts that already have media.

Phase 6: WordPress configuration

• Permalink structure: changed from flat (/post-name/) to blog-prefixed (/blog/post-name/) for content silo separation
• 11 new categories created via REST API to match the keyword taxonomy
• 3 WPCode snippets: ACF REST API enablement, meta field registration with repeater sub-fields, and protected meta unblocking for ACF field keys and RankMath
• Application Password for REST API authentication
• IndexNow enabled via RankMath for faster Bing indexing
• Search engine indexing enabled after first batch review (was disabled during development)

Results so far (four-month update)

We published this case study with real numbers because that’s the whole point of documenting the build. From Google Search Console, mid-March through late July:

Yes, 74 clicks. We’re publishing that number on purpose. A brand-new domain doesn’t earn clicks in month four; it earns impressions, indexation, and ranking footprint, and the clicks follow as positions climb. This is what the early innings of compound indexing actually look like, and pretending otherwise is exactly the kind of dressed-up case study we don’t want to write.

The stronger proof that the system works: we repointed the same pipeline at an established client domain in healthcare. The programmatic pages there rank top-5 for the high-intent local searches that actually generate patients, and the domain’s organic clicks grew almost 10x in twelve months.

What we’d do differently

Start with the system prompt, not the pipeline. We built the Airtable schema, scripts, and publishing flow before dialing in the content quality. The first batch of articles was publishable but generic. The prompt went through 4+ major revisions incorporating humanization rules, AI SEO research, copywriting frameworks, and article type detection. Starting with prompt quality would have avoided regenerating early batches.

Use the v2 system prompt from day one. A configuration mismatch (generate.sh pointed to system-prompt.txt instead of system-prompt-v2.txt) meant an entire batch was generated without image and video queries. Always verify the script is loading the right file.

Apply for Unsplash production access immediately. The 50 requests/hour demo limit became the primary bottleneck during publishing. Every batch run hit the limit partway through, requiring hour-long waits between runs. Production access (5,000/hour) eliminates this entirely and is usually approved within a day.

Build the ACF REST API configuration first and test it. We went through several rounds of debugging because WPCode snippets weren’t activated, field keys weren’t registered, and protected meta wasn’t unblocked. A single test post through the full pipeline before batch publishing would have caught all of these.

The scripts

All scripts use environment variable overrides for runtime configuration:

# Generate batch 3, 20 at a time, using Sonnet
TARGET_BATCH=3 BATCH_SIZE=20 MODEL=sonnet ./generate.sh

# Publish up to 50 posts
PUBLISH_LIMIT=50 ./publish.sh

What’s next

Internal link backfill. The related-searches field on each article contains slugs of topically related posts. Once enough content is published, a backfill script will match those slugs to actual published URLs and update the internal links.

Third-party presence. The content library is the foundation. The next layer is brand mentions across authoritative surfaces: guest posts, community participation, and review site profiles. Consistent brand narrative across surfaces matters more for AI citations than citation frequency alone.

Client deployment. The pipeline is designed to be repointed at any WordPress site, and it already has been; that healthcare domain above is the proof. Deploying it as a done-for-you service for more clients is the immediate next step. If you want it pointed at your site, that’s a conversation we’re happy to have.

Built by Tiger Tail. The AI implementation agency for businesses that want results, not slide decks.