Inside My AI Content Factory: How I Publish Evidence-Backed Guides With Claude Code

In 2022 I made a video about writing a blog post in 10 minutes with AI. 295,000 people watched it. And I spent a good part of that video warning everyone: use AI as a writing assistant, don't copy paste, because what it wrote on its own was generic. Today we have a name for that kind of content. AI slop.

Three years later I still spend about 10 minutes per article. But the 10 minutes buy something completely different now. They run a factory.

This guide is the full tour of that factory: what the blocks are, what one piece looks like going through it, what it costs, and how you could build one for whatever you teach or sell. It is the written companion to my video about the system, and it goes deeper than the video could.

One line in, one published guide out

The input is one line, something like:

create a guide on how to self host supabase using my content-factory

One line. No outline, no prompt engineering, no 2,000-word mega prompt. The system knows its stages, so the idea is all it needs from me at the start.

From that one line, on its own: it pulled the real search data, read the top-ranking pages, and found the gap. It wrote a plan with a cost estimate and stopped until I approved. It rented a DigitalOcean server, deployed Supabase's full 11-container stack, broke it on purpose, fixed it, measured everything, and destroyed the server when it finished. Then it wrote the guide, checked every claim against the evidence, and I read every word before it went live.

The result is the self-hosted Supabase guide. Same pipeline, different topics: self-hosting n8n (it fired 3,000 real webhook calls at its own deployment) and self-hosting Plausible, the pilot piece. Real pages, live on this site. Read them and judge the output before you read about the machine.

What is an AI content factory?

An AI content factory is a system around the model that does what a good technical writer does before and after writing: research what already exists, test the thing for real, write from evidence in a defined voice, verify every claim, and put a human decision at the points that matter. The model writes. The system is everything that makes the writing trustworthy.

That definition matters because the common setup is the opposite. Most "AI content" workflows are a prompt, a generate button, and a publish button. The model writes from its memory of the internet, which means it writes the average of what everyone else already said. That average is the slop.

The factory's bet is simple. The scarce thing is not text generation, it is first-hand evidence. So the system spends most of its time generating evidence, and only then writes. In my Build With AI course I keep repeating that the value is never the model, it is the system you wrap around it. This factory is that idea applied to content.

Why I built it

In 2021 I paid professional writers $150 to $300 for one technical post, and waited 2 to 7 days with all the back and forth. That was normal back then.

In 2022, writing blog posts with AI became free and instant. It also became generic. The 10-minute post was fast, but I had to warn people in the same video: it is an assistant, don't copy paste. The models improved a lot since then. The copy-paste problem did not go away, it scaled.

And here is the thing nobody hired could do. No writer I ever paid could rent a server, deploy the software, break its connection pooler, capture the exact error, and time the fix. Not for $300, not for any reasonable price. The evidence work was always the bottleneck: the writer summarizes other people's experience because generating their own is too expensive.

That is the actual reason the factory exists. Not to write faster. To make first-hand evidence cheap.

The five building blocks

The whole system is five blocks. Nothing in any of them is magic, and that is the point: you can rebuild each one for your own niche.

Block 1: the contract

The heart of the factory is a Claude Code skill: a markdown file that describes the pipeline in plain English. Ten stages, from "capture the idea" to "feed the lessons back to the brain." The rules live there too: every experiment must be a script, every claim needs a receipt, never exceed the approved budget, stop and wait for approval at two fixed checkpoints.

I want to be precise here, because this is the part people assume is code. It is not. It is instructions, the same way you would onboard a very capable new hire: here is our process, here are our standards, here is what you never do without asking. Claude Code reads that file and runs the process. The supporting scripts (creating servers, taking screenshots, checking drafts) exist, but Claude wrote them, from the contract.

Block 2: the senses

Before writing anything, the system pulls real search volumes from keyword APIs (ToolerBox in my case) and fetches the actual top-ranking pages for the topic. Not to imitate them. To find what they all miss, and to check the topic is worth writing at all. If it can't name a real gap, it tells me the topic is weak before anything is written. Some ideas die at this stage. That is a feature, not a failure.

Block 3: the hands

A guide about software needs screenshots of that software. The system takes them itself: it drives a real browser with Playwright, logs into the app it just deployed, and shoots what the guide needs.

Block 4: the lab

This is the expensive-sounding block that is actually cheap. For each piece that needs one, the system creates a fresh cloud server from a prepared image, runs its experiments as scripts, saves every output to evidence files, and destroys the server when the stage ends. Teardown is part of the job, not cleanup I do later. Server time is billed by the hour, and you will see the real total below. It is less than a coffee.

Block 5: the brain

The factory reads from a separate repository I maintain: my identity, voice rules, beliefs, and real stories with the real numbers, each entry with its source. When it drafts, my actual positions and experiences are in its context, so the draft opens with my argument instead of a generic intro. I explained that system in the AI second brain guide, and it is load-bearing here: the factory writes from it, and, as you will see at the end, writes back to it.

One piece through the factory

Theory done. Here is the Supabase piece going through the pipeline, stage by stage, with the real artifacts.

1. S0Intake. The one-line idea, a workspace, a row in the ledger
2. S1Brain pull. Load my voice, beliefs, and the stories relevant to the topic
3. S2Recon. Keyword data + read every top-ranking page + find the gap
4. S3Plan. Thesis, outline, experiments, cost estimate. ✋ Checkpoint 1: I approve the plan and the budget
5. S4Lab. Rent the server, run every experiment as a script, save the evidence, destroy the server
6. S5Assets. Screenshots by Playwright, diagrams, charts from the measured data
7. S6Draft. Write from brain + evidence, building the claims map row by row
8. S7Verify. Loops: evidence check, adversarial pass, voice check. Re-run until clean
9. S8Ship. Build, test, commit. ✋ Checkpoint 2: I read every word before it goes live
10. S9Seed. Distill the lessons and offer them back to the brain. I approve each one

The senses: it reads before it writes

The first thing the system did with that one line was measure it. It pulled the real search cluster around self-hosting Supabase: about 1,900 searches a month in total, "supabase self host" as the most-searched phrasing, and both word orderings returning the identical results page, so one page can take the whole cluster. Then it read every top-ranking page for the topic, including a 20,012-word GitHub discussion where real users listed everything that breaks in self-hosted Supabase, so the plan targeted those exact pains.

The plan, and the stop

Then it planned: the thesis, the outline, 8 experiments it wanted to run, and the cost: estimated at $0.70 of server time with a hard cap of $1.50 it is not allowed to pass. And then it stopped. Nothing touches a server before I approve the plan and the budget. Agents propose, I approve. I approved.

The lab: failures are evidence too

A server existed just for this piece: 2 CPUs, 4 GB of RAM, Frankfurt. The system cloned Supabase's repo in 2 seconds, pulled 8.9 GB of Docker images in 114 seconds, and had the studio serving 20 seconds after start. All 11 containers healthy on a 4 GB box, with the RAM of every container measured.

=== E1 bring-up + measure ===
host: cf-self-host-supabase | date_start_utc: 2026-08-11T12:35:13Z
clone_seconds: 2
 Image supabase/supavisor:2.9.5 Pulled
 Image supabase/postgres:17.6.1.136 Pulled
 ...
pull_seconds: 114
TYPE            TOTAL     ACTIVE    SIZE      RECLAIMABLE
Images          11        0         8.908GB   8.781GB (98%)
studio_serving_seconds: 20 (http 307)
NAME                             IMAGE                                    STATUS
supabase-db                      supabase/postgres:17.6.1.136             Up 19 seconds (healthy)
supabase-auth                    supabase/gotrue:v2.189.0                 Up 8 seconds (healthy)
supabase-envoy                   envoyproxy/envoy:v1.39.0                 Up 11 seconds (healthy)
supabase-studio                  supabase/studio:2026.08.03-sha-022b374   Up 19 seconds (healthy)
 ... 11 containers total, all healthy after settle

Then it started breaking things on purpose, because the recon said the pain is in what happens after the happy path. It proved sign-up emails are dead by default and captured the exact error. It timed a version upgrade with a probe hitting the API every second: the longest single gap was 5 seconds, and 11 of 31 one-second checks failed during the swap.

And then the big one. It rotated the security keys the way the docs suggest you should, and the connection pooler silently died. No error message. Clients just hang forever. One experiment sat stuck for 8 hours because of it. The system diagnosed it (the pooler snapshots credentials at first boot, so rotating them later breaks its login quietly), wrote the fix, proved the fix, and that became the headline advice of the guide: set all your secrets before the first boot. I have not found that warning in any ranking guide. My factory knows it because it lived it.

When the stage finished, it destroyed the server and confirmed nothing was left running. The whole lab, including the 8 hours it spent stuck, billed $0.76.

Writing from the brain

Only now does it write. Before drafting, it loaded my voice rules and my actual positions: my belief that you should own your stack, and the real story of adding up my cloud bills, about $8,400 a year, which is why I moved everything to my own servers in the first place, the same move I teach in Self Hosting 2.0. So the draft argues what I argue, with my numbers, backed by its fresh evidence. Not a neutral summary with my name on it.

The anti-slop machinery

Everything above makes the draft good. This part makes it trustworthy. Two mechanisms plus one rule, and none of them are optional.

The claims map

While drafting, the system builds a second file next to the draft: every factual claim, mapped to the evidence file or primary source that proves it. The Supabase piece has 49 of these rows. The rule is blunt: a claim without a receipt does not ship.

The verification loops

The draft then has to survive a set of checks, and each one re-runs until it passes clean. One loop cross-checks the draft against the evidence files. One is adversarial: its whole job is to attack the draft and find a claim that is wrong, stale, or stronger than its receipt. One checks the voice against the brain's rules, hunting for the phrases I never use. One checks the technical layer: links, schema, rendering. A separate lint script scans for the mechanical tells, like em dashes and banned phrases, on every pass.

The model is creative. That is exactly why the leash is mechanical.

The read: the rule that did not move

One more step before anything goes live, and in my opinion it is the most important one in the whole pipeline. I read it. The entire piece, word by word. Every claim, every command, every number.

I said the same thing in 2021 when I was hiring human writers, and in 2022 when AI could barely write a decent paragraph: it is an assistant, you don't copy paste. The AI now does 1,000 times more of the work, and the rule did not move. Nothing ships under my name before I read every word of it.

Automate the work, as much as you can. Never automate the responsibility.

What it costs to run

The honest full picture, because "76 cents per article" alone would be misleading:

The time part is the one I care about. My hands-on time per piece is roughly what the 2022 video promised for one draft. The difference is what the minutes buy: back then, a draft I had to fix and fact-check myself. Now, a tested piece where my job is judgment: approve the plan, read the result, say yes or no.

The flywheel: it feeds the brain that feeds it

My favorite part of the design is the loop at the ends of the pipeline. The first thing a piece does is read my brain. The last thing it does is feed it: the lessons from the lab, like the pooler fix, get distilled into candidate entries and offered back. I approve what enters, entry by entry. Nothing writes itself into my brain.

Every run ends by proposing what it learned back to the brain, so the next run starts smarter.

So every guide makes the brain better, and a better brain makes the next guide better. It is the same compounding I built into my video editing pipeline, where every generated asset joins a library the next video reuses. Build the tool that builds itself.

And the factory does not run one piece at a time. When the Supabase piece entered the ledger, its intake note recorded 5 sibling pieces already running in their own sessions: a Docker install guide, a reverse proxy guide, n8n, WordPress, and a what-is-self-hosting explainer. Every piece lives in a shared ledger with a lock per piece, so parallel Claude Code sessions never step on each other. Only the final ship step is one-at-a-time. This is the real ledger, from the session that wrote this very guide:

$ python .claude/skills/content-factory/lab/lock.py status
you are session 1df574ab
locks:
  MINE  ai-content-factory              stage=S4  port=8155  S4 harvest scripts
  DEAD  install-docker-ubuntu           stage=S8  port=8168  awaiting Checkpoint 2
  DEAD  self-host-gitlab                stage=S8  port=8194  shipped e625e68; awaiting Checkpoint 2
  DEAD  self-host-n8n                   stage=S8  port=8155  Checkpoint 2: Hasan reviewing
  DEAD  self-host-supabase              stage=S8  port=8156  shipped 057fb87; idle
  DEAD  vibe-engineering                stage=S7  port=8161  draft complete + verified
  ... 4 more pieces trimmed for the screenshot

Yes, the guide you are reading came off the same line. It sat in that ledger as a piece called ai-content-factory, went through recon, a plan I approved, the claims map, the verification loops, and my full read. The ledger tracks 25 pieces so far. Across them: more than 600 mapped claims, 419 experiment scripts, and 159 recorded verification rounds.

Build one for your niche

You do not need my stack. The five blocks are roles, and every niche has its own way to fill them. Answer five questions:

Notice what the lab is for a niche that is not self-hosting: it is wherever the system can generate evidence nobody else has, on its own. An email marketing factory does not rent servers, it runs the real A/B test through your email tool and writes from the actual open rates. A personal finance factory builds the actual spreadsheet model and stress-tests the formulas before it explains them. A factory that teaches an e-commerce platform or a SaaS tool sets up a demo store or a sandbox account and screenshots the real flows. The role transfers; the implementation is yours.

If I were starting from zero, this is the minimal version, and it is genuinely enough for the first month:

1. Write the contract. One markdown file: your stages in plain English, your voice rules, and one checkpoint where the system must stop and show you the plan. This file is the system. Start with Claude Code and this file alone.
2. Add a claims map. A second file per piece: every factual claim, and where it came from. The first time the map catches an invented number, you will understand the whole design.
3. Start the brain. Ten markdown files about you: how you write, what you believe, your five best stories with the real numbers. Feed it to the system before every draft. My second brain guide is the full version of this.
4. Run ONE piece end to end. Not ten. One piece through the full loop teaches you more than a month of designing the perfect pipeline. Then fix what hurt and run the next one.

The blocks are ordinary. The combination is the engine. Everyone has the same model; the difference is the work your system does before and after the model writes. That system design, deciding the blocks, the gates, and the rules, is exactly the builder skill I teach in Build With AI 1.0: you own the architecture, AI executes it.

FAQ

• Updated August 2026
• Pieces in the ledger 25
• Mapped claims 600+
• Server bill per piece under $1
• Human checkpoints 2 per piece
• Engine Claude Code + skills

Related

• Solo Builder Hub every build-with-AI guide on the site
• Build an AI Second Brain the brain this factory reads from and feeds
• Claude Code Video Editing the same system idea, applied to my YouTube videos
• Self-Host Supabase the guide you watched the factory write
• Self-Host n8n factory-made: 3,000 webhook calls as evidence

Build the system, not the post.

Hasan Aboul Hasan builds open-source tools and teaches solo developers how to build, host, and sell AI-powered products. Founder of LearnWithHasan.com, creator of SimplerLLM and PyRunner.