How-To Guide
How do you build an AI content pipeline with Claude Code?
Where a Claude Code content pipeline splits: the agent drafts over MCP, a human queue decides, and the publish step is the only one that reaches a platform.
By the Superdirector editorial team. Pages read November 14, 2026: Anthropic's custom-connector support page, the Claude documentation on directory and custom connectors, the MCP project's own page, Claude Code's overview and MCP pages, Superdirector's pricing page, and four competitor guides kept as labelled writing examples for structure only; their testimonials, vendor numbers and outcome claims are not adopted.
At a glance
How do you build an AI content pipeline with Claude Code?
Split the job the way every working pipeline splits it, into an agent half, a human half and a publish half. Claude Code researches and drafts over MCP, because the protocol connects it to external tools and data; a review queue holds drafts until a person approves; and the publish step is the only part that reaches a platform. The honest version of this page names where each layer starts and stops, because the tools that merge them quietly are the ones that break them.
- Agent half: connect the remote MCP server, run research with write tools disabled, keep brand rules in a context file, and score drafts against a written standard before a person reads them.
- Human half and publish half: stage every draft in a queue with two checks, showing each draft and asking before actions; then choose the route, a hands-on publish you trigger yourself, or the operated account that publishes under a permission you granted.
The agent and human halves can draft and decide but have no path out, and only the publish half reaches a platform. Original diagram, drawn from this article's own three-stage split.
Make it work for your brand
Find it. Remake it. Post it. Superdirector turns the viral formats in your niche into your brand's carousels, X posts and video scripts, and keeps the calendar full.
The pipeline in one run
Start from the run, because the stages only make sense once you watch one. A topic enters; the agent half researches it with whatever tools it reaches, pulls the sources, and produces a draft with its evidence attached. The human half opens that draft, checks it against the account's rules, corrects it, and approves it. The publish half takes the approved file and reaches the platform. That is the whole machine, and the competitor guide that ranks for this exact question describes the same loop from its side: it writes, scores, rewrites and re-scores a draft until it clears a bar, at which point its own software takes over, which its author discloses. Adopt the loop, keep your own bar.
Why a loop at all? The same page's argument is the sharpest one among the guides read for this page: a single prompt cannot check anything, because nothing about it holds a standard. A pipeline writes, scores, rewrites and re-scores until the draft passes. That is the part worth copying whoever you use, and it is also the part that makes the human queue cheaper, because drafts arrive pre-checked against your written rules instead of pre-vibed.
Claude Code is the agent half's engine. Anthropic's overview describes it as an AI-powered coding assistant that builds features, fixes bugs and automates development tasks, and its MCP integration works the same way for any file-bound or tool-bound job: reading documents in a drive, updating tickets, pulling data or reaching your own custom tooling. A content pipeline is a different job on the same harness, and the honest answer to "can it also post" lives later in this page, in the section on the publish step.
Wire the connector: what the official rules give you
The connector is how the agent reaches outside its own folder, and the official pages define exactly what it is. MCP is an open-source standard for connecting AI applications to external systems, the protocol project's own "USB-C port" comparison, supported across a wide range of clients and servers. Claude connects to remote servers from the directory listing or as a custom connector added by URL, and the documentation on directory versus custom connectors is explicit that both run the same infrastructure: the runtime, transport, authentication and tool-calling code paths are identical. The distinction is what surrounds the runtime: review, discovery, distribution and the Anthropic-side features a listing can use, not capability.
Two official rules shape the setup before any content work starts. First, the network one: Claude connects from Anthropic's cloud infrastructure, so the server must answer over the public internet on standard HTTPS port 443, and a laptop-resident or firewall-hidden server will not connect no matter what the client shows you. Second, the scope one: a default local-scoped server in Claude Code loads only in the project where you added it and stays private to you, which keeps a content pipeline from leaking across every other project on the machine. Both rules come from Anthropic's own pages, and no competitor setup section we have read carries them, which is why their troubleshooting sections fill with connection mysteries.
Third, approve with intent. A connector's tools do whatever their developer defined, from reading data to taking actions on your behalf, and Anthropic's guidance is to review each tool approval and allow a server to run unsupervised only when you trust it and its tool. In a content pipeline the connector's tools are research and preparation tools; the publish tools, if any exist at all, belong to the publish section. The Claude Code MCP page documents the same connection model with one command and the directory's shared infrastructure, so the terminal route and the app route converge on the same server list.
The research stage: read-only first
Run the first stage read-only, and let the platform's own guidance say it: Anthropic's documentation for research mode directs users to disable any tools that can take write actions in external applications while research runs. That single sentence is the difference between a pipeline that collects sources and one that mutates things while it thinks, and it costs nothing to keep. In practice the research stage reaches your source set, reads, and returns findings with links, the same dossier habit the rest of this site's pages hold, and the connector's read tools are its whole job here.
Brand rules belong in the session, not in memory. Claude Code reads a markdown file in the project root at the start of every session, so the account's voice rules, forbidden claims and label requirements live somewhere the pipeline cannot forget between runs. A rule that improves weekly is a rule written down weekly, which is the same habit Blotato's Claude Cowork guide recommends: end each session by telling Claude to update your skills with what you learned. The rules our own page keeps hardest: no invented outcomes, invented examples labelled hypothetical, and no publishing a fabricated review or testimonial, which is our pricing page's own rule and not decoration.
The draft loop: score the draft against your own rules
The loop is the pipeline's spine, and every guide read for this page agrees on its shape. Draft against a written standard, score, rewrite, and re-score until the draft clears the bar. What varies is who owns the rubric. The vendor page's grader checks its hook hardest; a team page would weight claims and labels hardest. Ours names the cheapest-to-automate, highest-cost-if-missed checks first: every external claim traces to a read source, every result is either sourced or labelled hypothetical, platform labels appear wherever required, and every link resolves. The loop earns the reviewer's time by never sending a draft that violates these without flagging itself.
Format caps are the loop's second kind of check, and the clearest example is a practitioner one: Blotato's Instagram carousel guide reports that Instagram and TikTok now cap posts at five hashtags per post, so its own prompt caps at three and tests up. Report caps you read, then set your own stricter rule and let the loop enforce it. The platform rules that deserve deeper reading, per-platform payloads and app-level approval walls, belong to the scheduler comparison and the automation-tool route in the Zapier and n8n how-to, which this page deliberately does not duplicate.
The human queue: where drafts park before anything goes out
The queue is a decision surface, not a folder. Two distinct checks live here, and Blotato's Claude Cowork guide names both: ask before every publishing or scheduling call, and show each draft for editing first. A queue formalizes the second and automates the first: every draft lands with its evidence, its intended platform, and its score against the rules, so the reviewer reads once rather than interrogates. The staging-table habit from Blotato's Instagram carousel guide, generating a few drafts a day and posting only the strongest after five minutes of review, is the same idea at low volume, and it scales up to a batch review session or down to one operator without changing.
Queued means still owned. Blotato's Google Antigravity setup guide's own description of a queued post says it sits where it can be edited, moved or deleted before it goes live, which is the correct shape for every queue these guides describe. Nothing in the pipeline should move a post to live except the route you chose in the publish section, and at least one person remains able to see and stop anything before the platform does. That is the whole review principle, and it is also why the draft loop matters twice: a pre-checked queue makes the human pass minutes, not meetings.
A failing score returns the draft for a rewrite; a passing draft parks in the queue until a person approves it. Original diagram, drawn from this article's own queue sequence.
Two publish routes: hands-on or operated
Everything before this point costs the same on both routes; the routes differ at the button. The hands-on route ends in you: the queue approves, you publish, the receipts and readback are yours. The operated route delegates the button inside a plan: Superdirector's Growth plan publishes eligible Instagram carousels and single X text posts on its own once posting is turned on for an account, after one warning that names the account, the public effect and the cost. That permission is an account-level standing posting permission, granted once for the account and revocable, and it is not rebuilt at each post; the account's other surfaces stay as they are. What the hands-on route buys is the same thing the approval-gate stories from these vendors buy: the last look is human's.
| Route | What runs without you | What stays with you | Declared cost |
|---|---|---|---|
| Hands-on: the queue approves, you publish | Research, drafting, scoring, the queue's organization | Every publish action, platform labels, and the receipts you collect | $29 a month Starter: MCP access and hands-on creation, 300 credits monthly |
| Operated: the account publishes under standing permission | Eligible Instagram carousels and single X text posts once posting is on | Turning posting on per account, the warning read, payments and direction | $199 a month Growth, one AI-run operated account; pricing-page rows: 2,000 credits monthly, two accounts included, extra accounts $99 each |
What neither route claims is worth saying twice, because the marketing of these tools blurs it. No route posts from the connector alone: on the hands-on plan the MCP surface stops at research, drafting and preparation, and on the operated plan publishing starts only when you turn it on for an account. AI video and fully autonomous channels are upcoming, not current, and script drafts are saved with the work, not placed on a calendar. A pipeline you build yourself around a publishing API carries those platform walls as its own maintenance, per the scheduler build comparison, which reads the same platform paperwork in detail.
Proof, limits, and when to skip the pipeline
Proof is a weekly habit, not a dashboard. A published post is verified by reading it back at the destination, not by a send-side success, so the pipeline's own proof list is short: a live URL per destination, receipts wherever the send came from a service, the weekly wheel checked against what actually shipped, and AI labels where the platform requires them. We sell business growth, not guaranteed results, and a pipeline honest about that says exactly what each part can be blamed for: the agent half for bad drafts, the queue for missed checks, the publish route for missed posts.
The honest limits close, in the shape of the best pages read for this one. The connector cannot post; the queue only holds decisions, and the loop cannot make claims true or make a platform accept every file. Before an account publishes consistently, the pipeline adds machinery where the first system is missing, so the manual wheel runs first and pipeline earns the keep once drafting, not deciding, is the bottleneck. Run it a week with every check on before trusting a stage without you, and keep the last look human regardless of route, because every approval-gate story from these vendors ends with a person catching what a rubric missed.