This is a guide to building a pipeline in Claude Code that turns a spreadsheet into a series of LinkedIn posts.
A series here means posts you write more than ten times a year in the same shape, like partnership announcements or integration launches. A pipeline is a fixed order of small steps, each done by a script or a prompt.
Claude Code, Anthropic’s AI assistant that works with the files on your computer, writes the scripts and runs the steps.
We’ll build one example step by step: Fernstack, a US project management tool with 48 integration partners, wants one announcement per partner over the next year.
Say each post takes 45 minutes by hand: finding the facts, finding a sharp logo, building the graphic, writing and scheduling. That’s 36 hours for 48 posts. With the pipeline, say setup takes 8 hours and each batch of twelve posts, one run of the pipeline, takes 90 minutes, most of it reading. That’s 14 hours for all 48.
This guide is for marketing and partnership teams, and for founders with a long list of integrations nobody has announced yet. Read it in order once. If your graphics already work, skip to step 5, the rules that keep the drafts from all sounding the same.
How the pipeline works
A sheet goes in, and finished drafts with their graphics come out, ready for a person to approve. The pipeline has six stages:
- Sheet. One row per post with the facts, filled in by a person.
- Logo. A script finds each partner’s logo and writes its link into the row.
- Graphic. A script fills a design template with the logo and a caption and saves the image.
- Draft. Claude writes the post from the row under fixed rules, and a script checks the rules.
- Review. A person reads every draft, edits it in the sheet and marks it approved.
- Scheduler. A script sends approved rows to your scheduling tool as drafts, and a person picks the dates.
A script here is a short program, usually in Python, that Claude Code writes for you. Claude is the AI model behind Claude Code, and it writes the posts.
One status column connects the stages. Every row has a status, like “new” or “draft_ready”. Each stage only picks up rows with its own status and moves them one status forward. A stage that fails writes the error into a last_error column and leaves the status as it is.
So you can rerun any stage at any time. A row that already moved on is never processed twice, and a broken logo for one partner doesn’t stop the other eleven in the batch.
In Claude Code the whole pipeline is one small folder: one script per stage, the prompt as a text file, and the sheet. I’d add a skill too.
A skill is a file of instructions that Claude Code follows when you type its name, for example /post-series. It makes Claude Code run the stages in the same order every time.
To set it up, create a folder, open the Terminal, go to the folder and type claude to start Claude Code. Press Shift+Tab for plan mode, so Claude Code proposes the design before it writes code. Every service the scripts talk to gives you an API key, the password your script uses. Put each key into a file called .env in the folder, one per line. Then paste:
Build a post pipeline in this folder. posts.csv has one row per
post with the columns I'll give you, including status and last_error.
One Python script per stage in tools/: logo, graphic, draft, check,
scheduler. Each script only picks up rows with its own input status,
moves them one status forward and writes errors into last_error
without changing the status. Every script has a --dry-run flag that
prints what it would do. Read API keys from .env.
Write a skill /post-series that runs the stages in order and stops
before the scheduler until I say the batch is approved.
Test every stage on 2 rows first and show me the result.
1. Check which posts belong in a pipeline
Use a pipeline for posts whose structure stays the same while only the facts change. My test: could you write the outline once and fill it from one row of a sheet?
Good fits:
- Partnership and integration announcements
- Release notes for a product that ships on a regular schedule
- Customer quotes, with the customer’s written approval
- Event speakers, webinar guests and new team members
Opinion posts, personal stories and anything where your own view makes the post don’t fit. A pipeline can’t have an opinion for you. If you force it, every post ends up with the same generic opinion.
2. Put every fact into the sheet
If a fact isn’t in the row, it doesn’t go in the post. This one rule removes most of the risk that the model invents a feature your partner never built.
Use Google Sheets or Airtable if several people fill in rows, or a CSV file (a plain spreadsheet file) if you work alone. For Google Sheets, the script logs in with a service account, a Google login made for scripts. Claude Code can walk you through creating one. These are the columns I’d start with:
partner_name exact spelling, the way the partner writes it
partner_domain root domain only, e.g. kettlebase.com
partner_contact who approves the post on their side
what_it_does 1 to 2 sentences: what moves where, in which direction, how fast
who_its_for the team or role that uses it
example_workflow one concrete job it removes, in plain words
availability plans or regions it is live on, or "all plans"
link docs or launch page, with UTM tags
angle workflow | data | customer | problem
post_date YYYY-MM-DD
layout 1 | 2 | 3 (graphic variant, blank = rotate)
logo_url filled by the logo stage, overwrite if wrong
graphic_path filled by the graphic stage
caption filled by the draft stage
post_text filled by the draft stage, edited by the reviewer
partner_ok "yes" once the partner approved wording and date
status new > logo_ready > graphic_ready > draft_ready > approved > in_scheduler
scheduler_id filled by the last stage
last_error filled by any stage that fails
Three of these columns matter more than the rest.
what_it_does is written by someone who knows the integration, with direction and timing spelled out. “Won deals in Kettlebase create a project in Fernstack within a minute” gives the model something to write from. “Connects your CRM” gives it nothing, and the post will be as vague as the row.
angle is where the post starts: the job the integration removes (workflow), the data that moves (data), the team that asked for it (customer) or the problem it solves (problem). Set it when you fill in the row and rotate it across the batch, so no two posts in a row start the same way.
partner_ok stays empty until the partner has seen the final wording. The last stage refuses every row without it.
link carries UTM tags, short labels at the end of a link like ?utm_source=linkedin&utm_campaign=partners. Your analytics then shows which posts sent visitors to the docs page.
3. Find a logo for every partner
Start with the partner’s own press kit or brand page. That’s the version they want you to use.
For the rest, a logo API saves you the search. An API (application programming interface) is a way for a script to ask a service for data.
Brandfetch and Logo.dev both return a company’s logo for its domain, in light and dark versions. Brandfetch’s Logo API is free and needs a free client ID. Logo.dev requires a visible credit link on some plans, so check yours before you publish.
Paste this into Claude Code: “Write tools/logo.py. For every row with status new, look up the logo for partner_domain with <logo API>, prefer the SVG or the largest PNG, save it to logos/, write the path into logo_url and set the status to logo_ready. If the only image is smaller than 400 pixels wide, write that into last_error.”
A person looks at every logo. The usual problems are a blurry favicon (the tiny icon in a browser tab), last year’s logo after a rebrand, and a dark logo that disappears on a dark background.
4. Build the graphic from one template
Every post gets an image with both logos and a short caption. Build all of them from one template, so the series looks like a series.
Design two or three layouts. Name the parts the script will change, for example partner_logo, partner_name and caption. Rotating the layouts keeps the feed from showing the same picture 48 times.
There are two common ways to fill the template:
- Figma. Claude Code can write into a Figma file through Figma’s MCP server. MCP (Model Context Protocol) is an open standard that lets an AI assistant use an outside tool directly. Figma’s docs say you need a Full seat, the seat type for people who edit designs, to write to files this way. To export, Figma’s API renders each frame (one design on the canvas) as a PNG image at up to four times its size.
- Bannerbear or Placid. Both turn a template into an image through their API. The script sends the template and the new text and logo for each named layer, and gets the finished image back. Bannerbear also has an MCP server.
In Figma, I’d duplicate the template once per row instead of editing one frame again and again. You end up with a page of finished graphics you can check in ten seconds, and a broken one stands out right away.
Figma’s export links expire after 30 days. So the script downloads every PNG right away and writes the file path into graphic_path.
For the Bannerbear or Placid route, the prompt is short: “Write tools/graphic.py. For every row with status logo_ready, send the template ID from .env with partner_logo = logo_url, partner_name and caption to <tool>’s API, download the image to graphics/, write the path into graphic_path and set the status to graphic_ready.”
5. Give the drafts rules a script can check
One plain prompt over twelve rows tends to give you twelve versions of one post, with similar openers and similar last lines. Each draft reads fine alone.
Side by side, it’s obvious they came from a template, and your followers do see them side by side, a week apart.
In my experience the cause is the setup. The same prompt and the same row shape make the model pick the most likely post every time.
The fix is rules a script can check, plus inputs that differ on purpose:
- No opener twice in a batch. The prompt gets the first lines already written in this batch. After writing, a script compares the first eight words of every draft with all the others and sends repeats back.
- Facts only from the row. The model lists every fact it used under FACTS_USED. The script checks each one against the row and flags any number or name it can’t find there.
- Banned phrases. A list of the phrases most announcements use, checked by simple text matching. Checking costs nothing, so the list can be long.
- An angle per row. Different angles produce different first sentences before any rule is needed.
- A length range. I’d use 90 to 160 words. Longer announcements start to read like press releases to me.
Here’s the prompt with those rules built in:
You are writing one LinkedIn post for {company}'s company page.
It announces a new integration with {partner_name}.
Use ONLY the facts in this row. If something is not in the row,
it does not go in the post:
{row as JSON}
Openers already used in this batch. Do not start the same way,
and do not reuse their first three words:
{first lines so far}
Angle for this post: {angle}
- workflow: open with the job the integration removes
- data: open with the exact field or object that now moves
- customer: open with the type of team that asked for it
- problem: open with the problem in the user's own words, as a statement
Rules:
- 90 to 160 words. Short paragraphs, one idea each.
- Say what moves where, in which direction, and when.
- Every number, feature and customer name must come from the row.
- Write {partner_name} exactly like this: {partner_name}
- One link, at the end: {link}
- No hashtags, no emojis, no exclamation marks.
- Never use: "excited to announce", "thrilled", "proud to partner",
"game-changer", "seamless", "unlock", "supercharge", "empower",
"in today's", "the future of", "best-in-class", "we're happy to share".
Return exactly:
CAPTION: max 70 characters, goes on the graphic
POST: the post text
FACTS_USED: every fact you used, copied word for word from the row
The checks live in their own script. Ask Claude Code for it in one sentence: “Write tools/check.py that runs the five rules above on every draft_ready row and writes each failed rule into last_error.”
I’d add one more check across the batch: flag any two drafts that share a run of five words anywhere in the text. Repeated middle sentences give a series away as much as repeated openers.
When a draft fails a check, send it back with the rule it broke, like “opener repeats draft 3” or “the number 40% is not in the row”. In my experience two rounds fix almost everything. If one row keeps failing, look at the row before you change the prompt. Usually what_it_does is too thin to write from.
6. Read and approve every draft
The scripts check the form. A person checks everything a script can’t see, edits post_text in the sheet and sets the status to approved:
- Does the integration work the way the post says? Click through it once or ask whoever built it. Rows are often written from the plan, and the shipped version can be narrower.
- Has the partner approved the wording and the date? Send them the draft and the graphic. Their logo is on it too.
- Is the logo current and the name spelled their way? Capital letters included.
- Who gets tagged? The partner’s company page and the person who built the integration on their side. In my experience that’s what gets a post shared further.
- What else goes out that week? Two partners from the same category back to back look like a pattern. And a week when the partner is in the news for bad reasons is the wrong week for their announcement.
- Would you say this to a customer? Read it out loud. If a sentence sounds wrong, rewrite it in the sheet.
7. Send approved posts to your scheduler as drafts
The last script sends every approved row to your scheduling tool as a draft. A person picks the date.
Buffer and Typefully both have an API that creates LinkedIn drafts. In Buffer, a draft isn’t published until someone schedules it, and the graphic goes along as an attachment. Buffer is also listed in LinkedIn’s own directory of marketing partners for company pages.
If you use another tool, check that it can post to company pages before you build on it.
Run the script in test mode first, so it only prints what it would send. Then run it for real. The script writes the scheduler’s post ID into scheduler_id and sets the status to in_scheduler, so a second run skips the row.
I’d never let the script pick the dates. Dates move all the time: a partner asks for a week’s delay, or your own launch lands on the same Tuesday. Scheduling by hand takes a minute per post and puts a person in front of the final version one more time.
8. Use the same pipeline for other series
Everything above carries over to other repeating posts. You change the columns, the angles and the template. You keep the status column, the facts rule and the review.
- Customer quotes. Columns for the quote, name, title, company, approval date and photo. The facts rule gets stricter: the quote is copied word for word, and the model only writes the lines around it.
- Release notes. One row per release, with what changed, who asked for it and a screenshot in place of the logo.
- Event speakers. Talk title, time, speaker photo and the one sentence the speaker would use to describe the talk.
For Fernstack, say the partner series runs well for a quarter. Adding customer quotes takes a new tab in the sheet, a new template and a new prompt file. The scripts stay as they are.
Where to start today
You can turn your next post series into a pipeline in three steps:
- Put every fact into a sheet, one row per post, with the columns from step 2.
- Let Claude Code write the drafts and build the graphics with the template from step 4 and the prompt from step 5.
- Approve the drafts and send them to your scheduler as drafts.


