Claude Code + Blotato: Zo Automatiseerde Ik Mijn Volledige Content Pipeline
Afgelopen donderdag uploadde ik een YouTube-video van 22 minuten over het bouwen van AI-agentteams. Binnen 40 minuten had ik negen stukken platformspecifieke content in een conceptenmap op mijn computer staan — drie LinkedIn-berichten met professionele opmaak, drie Instagram-carouselscripts met dia-voor-dia-uitsplitsingen, en drie X-berichten met pakkende quote-visuals. Allemaal op maat gemaakt. Allemaal merkconform. Allemaal wachtend tot ik ze zou beoordelen en op publiceren zou klikken.
Ik heb er niet één handmatig geschreven.
Het systeem dat ze produceerde is een Claude Code-project met vier Python-scripts, een Blotato API-integratie en een concept waar ik steeds op terugkom: skills. Niet het vage "AI kan dingen doen"-soort. Het specifieke, gedocumenteerde, herhaalbare soort — waarbij elke automatisering een naam heeft, een set ingrediënten, een volgorde van stappen en een verwacht uitvoerformaat.
Het bouwen hiervan kostte me ongeveer drie weekenden van iteratie. De eerste versie was gênant kapot. Claude Code probeerde YouTube-pagina's rechtstreeks op te halen en liep tegen botdetectiewanden aan. De beeldgeneratie produceerde te grote PNG's die de API van Blotato afwees. Mijn merkassets laadden niet omdat ik paden had hardgecodeerd die alleen op mijn werklaptop bestonden.
Maar elke fout leerde het systeem iets — en dat is het deel dat niemand uitlegt over werken met Claude Code voor automatisering. De AI voert niet alleen je instructies uit. Hij observeert wat er misgaat, stelt oplossingen voor en werkt zijn eigen skilldocumenten bij zodat dezelfde fout niet twee keer voorkomt.
Ik wil je precies laten zien hoe deze pipeline werkt, want de 9x contentmultiplicator die het creëert heeft oprecht veranderd hoe ik over publiceren denk. Maar eerst moet je begrijpen waarom ik drie andere tools heb opgegeven voordat ik bij deze aanpak uitkwam.
Waarom Hergebruiktools Me Bleven Teleurstellen
Ik heb Repurpose.io geprobeerd, ChatGPT handmatig geprompt, en een tool genaamd ContentFries die "één video, onbeperkte content" beloofde. Ze hadden allemaal hetzelfde probleem: ze behandelden elk platform hetzelfde.
Het LinkedIn-bericht klonk als een tweet met extra alinea's. De X-berichten waren ingekorte versies van wat de tool als eerste genereerde. Geen platformintelligentie — geen begrip dat LinkedIn-doelgroepen professionele frameworks willen terwijl X-doelgroepen een scherpe mening willen die ze kunnen quote-tweeten.
Merkconsistentie was het tweede falen. Mijn profielfoto, geverifieerd badge, kleurenpalet — geen van deze tools liet me merkassets injecteren. Elke output zag er generiek uit. Ik besteedde 20 minuten per bericht aan het handmatig aanpassen van toon en het herformatteren. Twintig minuten maal negen berichten maal vier video's per maand. Twaalf uur mechanisch werk aan content die ik al één keer had gemaakt.
Het derde probleem dreef me ertoe mijn eigen systeem te bouwen: de goedkeuringsworkflow. Of beter gezegd, het ontbreken ervan. Deze tools wilden direct naar mijn accounts auto-publiceren zonder beoordelingsstap. Ik ben eerder gebrand — een planningstool publiceerde ooit een concept met "RELEVANTE STATISTIEK HIER INVOEGEN" naar 14.000 LinkedIn-volgers. De reacties waren... leerzaam.
Ik had drie dingen nodig: platformspecifieke contentintelligentie, merkasset-integratie en verplichte menselijke beoordeling. Claude Code en Blotato gaven me alle drie.
Wat Maakt een "Skill" Anders Dan een Prompt
Als je mijn schrijven over Claude Code agent workflows hebt gevolgd, weet je dat ik skills beschouw als de fundamentele eenheid van AI-automatisering. Maar dit project dwong me om veel preciezer te worden over wat dat eigenlijk betekent.
Een prompt is een eenmalige instructie. "Schrijf een LinkedIn-bericht over deze video." Je typt het, de AI antwoordt, en de interactie is voorbij. Als de output verkeerd is, pas je de prompt aan en probeer je het opnieuw. De kennis over wat werkt leeft in je hoofd.
Een skill is een gedocumenteerd recept. Het heeft vier componenten:
Naam: Een duidelijke identificator. De mijne heten dingen als youtube-to-linkedin, youtube-to-instagram-carousel, youtube-to-x-quote.
Ingrediënten: De inputs die de skill nodig heeft voordat hij kan draaien. Voor youtube-to-linkedin zijn de ingrediënten: videotranscript (platte tekst), videotitel, video-URL, doelgroepomschrijving en pad naar de merkassetmap.
Stappen: De geordende reeks bewerkingen. Geen vage instructies — specifieke, testbare stappen. "Extraheer de drie meest citeerbare uitspraken uit het transcript" is een stap. "Laat het professioneel klinken" is dat niet.
Verwachte Output: Het exacte formaat en de structuur van wat eruit komt. Voor de LinkedIn-skill is de verwachte output een markdown-bestand met een haakregel (minder dan 200 tekens), een hoofdgedeelte (150-300 woorden), drie hashtags en een CTA die teruglinkt naar de volledige video.
Het verschil is belangrijk omdat skills itereerbaar zijn. Wanneer de LinkedIn-output te lang is, prompt ik niet opnieuw vanaf nul. Ik pas stap 4 van het skilldocument aan — "Comprimeer het hoofdgedeelte tot minder dan 250 woorden met behoud van alle frameworkverwijzingen" — en elke toekomstige uitvoering weerspiegelt die wijziging.
Dit is wat ik bedoel als ik zeg dat de AI zichzelf corrigeert. Het skilldocument is een levend artefact. Claude Code leest het voor elke uitvoering, volgt de stappen, en wanneer er iets misgaat — een webophaalactie wordt geblokkeerd, een afbeelding overschrijdt de groottelimiet van Blotato — werk ik het skilldocument bij met de oplossing. De volgende run werkt correct. Het systeem wordt slimmer elke keer dat het faalt.
Mijn project heeft momenteel zeven skilldocumenten. Drie voor contentgeneratie (één per platform), twee voor beeldcreatie (LinkedIn-infographic en X-quote-visual), één voor transcriptextractie en één voor de goedkeuringsworkflow. Elk begon ruw en verbeterde door daadwerkelijk gebruik.
Die iteratieve lus — draaien, falen, de skill repareren, opnieuw draaien — is het werkelijke geheim om AI-automatisering betrouwbaar te maken. Niet betere prompts. Beter gedocumenteerde processen.
Laat me je nu de projectstructuur tonen die dit alles bij elkaar houdt.
De Projectstructuur Die Alles Laat Werken
Ik draai dit hele systeem vanuit één VS Code-project. Zo ziet de mapstructuur eruit:
content-repurposer/
claude.md
scripts/
extract_transcript.py
generate_content.py
create_visuals.py
submit_to_blotato.py
skills/
youtube-to-linkedin.md
youtube-to-instagram-carousel.md
youtube-to-x-quote.md
linkedin-infographic.md
x-quote-visual.md
transcript-extraction.md
approval-workflow.md
drafts/
linkedin/
instagram/
x/
brand-assets/
profile-pic-square.png
profile-pic-round.png
verified-badge.png
color-palette.json
fonts/
approved/
linkedin/
instagram/
x/
.env
Een paar dingen om op te merken.
Het claude.md-bestand in de root is de systeemprompt voor Claude Code. Dit is het brein van de operatie — het vertelt Claude Code wat dit project doet, welke skills beschikbaar zijn en welke beperkingen gevolgd moeten worden. Ik houd de mijne onder de 150 regels. Dat is een harde regel die ik heb geleerd door pijnlijke experimenten. Ga boven de 150 regels en Claude Code begint context te verliezen bij de minder benadrukte instructies. Het model heeft ruim voldoende capaciteit, maar de signaal-ruisverhouding in je systeemprompt is enorm belangrijk.
Hier is een vereenvoudigde versie van mijn claude.md:
# Content Repurposer
## Purpose
Transform YouTube video content into platform-specific
social media posts for LinkedIn, Instagram, and X.
## Available Skills
- transcript-extraction: Get plain text from YouTube videos
- youtube-to-linkedin: Professional long-form posts
- youtube-to-instagram-carousel: Educational carousel scripts
- youtube-to-x-quote: Casual quote-style posts
## Constraints
- NEVER auto-publish. All content goes to drafts/ first.
- ALWAYS use brand assets from brand-assets/ directory.
- Image files must be under 4MB for Blotato API.
- LinkedIn posts: 150-300 words, professional tone.
- Instagram carousels: 5-8 slides, educational tone.
- X posts: Under 280 characters, casual tone.
## API Configuration
- Anthropic API via .env (ANTHROPIC_API_KEY)
- Blotato API via .env (BLOTATO_API_KEY)
- OpenRouter as fallback (OPENROUTER_API_KEY)
De scripts/-map bevat vier Python-bestanden. Elk behandelt een specifieke fase van de pipeline. Ik gebruik Python omdat Claude Code betrouwbare Python sneller genereert dan elke andere taal in mijn tests, en het bibliotheekecosysteem voor API-aanroepen en beeldbewerking is ongeëvenaard.
De drafts/- en approved/-mappen zijn de twee fasen van de goedkeuringsworkflow. Content begint in drafts/. Ik beoordeel het. Goedgekeurde content verhuist naar approved/. Alleen content in approved/ wordt ingediend bij Blotato voor planning.
De brand-assets/-map is verrassend belangrijk. Zonder die map ziet elke gegenereerde visual er generiek uit. Ermee kan Claude Code mijn profielfoto overlappen, mijn kleurenpalet toepassen en merkelementen opnemen die de sociale berichten eruitzien alsof ze van een menselijke ontwerper komen — niet van een script.
Die merkasset-integratie was een van de moeilijkste dingen om goed te krijgen. Laat me je laten zien waarom, en hoe de AI uiteindelijk zijn eigen probleem oploste.
De API-Laag Instellen: Anthropic en Blotato
Voordat er content wordt gegenereerd, moeten twee API's verbonden zijn. De Anthropic Claude API verwerkt alle intelligentie — transcripten analyseren, platformspecifieke tekst genereren, creatieve beslissingen nemen over hooks en opmaak. Blotato verzorgt de distributie — berichten plannen, platformverbindingen beheren en de OAuth-complexiteit afhandelen van het publiceren op LinkedIn, Instagram en X.
Hier is mijn .env-configuratie:
ANTHROPIC_API_KEY=sk-ant-api03-xxxxx
BLOTATO_API_KEY=bl_xxxxx
OPENROUTER_API_KEY=sk-or-xxxxx
BLOTATO_WORKSPACE_ID=ws_xxxxx
DEFAULT_SCHEDULE_OFFSET_HOURS=24
De OpenRouter-sleutel is een terugvaloptie. Wanneer ik snel itereer en Anthropic API-credits verbruik tijdens ontwikkeling, routeer ik een deel van de minder kritische aanroepen — zoals opmaakwijzigingen of hashtaggeneratie — via OpenRouter's toegang tot Claude 3.5 Sonnet, dat goedkoper is per token. Het zware werk — transcriptanalyse, contentgeneratie, toonmatching — gaat altijd rechtstreeks via de Anthropic API voor kwaliteit.
Het instellen van Blotato was eenvoudig maar vereiste een specifieke volgorde. Je maakt een werkruimte aan, verbindt je sociale accounts via Blotato's OAuth-flow (dit gebeurt in hun webdashboard, niet via de API), en pakt vervolgens je werkruimte-ID en API-sleutel. De API-sleutel is gekoppeld aan die werkruimte, zodat al je verbonden accounts toegankelijk zijn via één sleutel.
Hier is de Python-functie die ik gebruik om de verbinding te verifiëren:
import requests
import os
from dotenv import load_dotenv
load_dotenv()
def verify_blotato_connection():
"""Check that Blotato API is reachable and workspace is valid."""
headers = {
"Authorization": f"Bearer {os.getenv('BLOTATO_API_KEY')}",
"Content-Type": "application/json"
}
response = requests.get(
f"https://api.blotato.com/v1/workspaces/{os.getenv('BLOTATO_WORKSPACE_ID')}",
headers=headers
)
if response.status_code == 200:
data = response.json()
print(f"Connected: {data['name']}")
print(f"Accounts: {len(data['accounts'])} linked")
return True
else:
print(f"Connection failed: {response.status_code}")
return False
Iets wat ik heb geleerd: Blotato's afbeelding-uploadendpoint heeft een limiet van 4MB per bestand. Mijn eerste visuele generatiepogingen produceerden PNG's van 6-8MB omdat ik op hoge resolutie renderde zonder compressie. Claude Code ving dit op tijdens het testen — de API gaf een 413-fout terug — en werkte automatisch de linkedin-infographic.md-skill bij met een beeldcompressiestap: "Na het genereren van de visual, comprimeer naar JPEG op 85% kwaliteit. Verifieer dat de bestandsgrootte onder 4MB is voor indiening."
Dat is de iteratieve verbeteringslus in actie. Het skilldocument draagt de oplossing nu permanent met zich mee.
Als je liever iemand hebt die dit soort automatiseringsopzet helemaal vanaf nul bouwt, neem ik aangepaste AI-workflowopdrachten aan. Je kunt zien wat ik heb gebouwd op fiverr.com/s/EgxYmWD.
Maar de API-laag is slechts leidingwerk. De echte magie — het deel dat de content daadwerkelijk goed maakt — gebeurt in de platformspecifieke generatieskills.
Platformspecifieke Contentgeneratie: Drie Doelgroepen, Drie Strategieën
Dit is waar de meeste content-herbestemming mislukt. Mensen nemen één stuk content en formatteren het iets anders voor elk platform. Dat is geen herbestemming. Dat is kopiëren-plakken met verschillende tekenlengtes.
Echte herbestemming betekent dezelfde kernideeën opnieuw bedenken voor fundamenteel verschillende doelgroepen en consumptiecontexten. Hier is hoe elke platformskill werkt.
Hoe Genereert de LinkedIn-Skill Professionele Berichten?
LinkedIn-doelgroepen scrollen tijdens werkuren. Ze zoeken naar professionele inzichten, frameworks die ze op hun werk kunnen toepassen, en content die hen er doordacht uit laat zien als ze het delen. De consumptiemodus is doelgericht — mensen lezen LinkedIn-berichten zorgvuldiger dan tweets.
Mijn youtube-to-linkedin.md-skill volgt deze structuur:
Stap 1: Extraheer de drie meest brancherelevante inzichten uit het transcript. Negeer persoonlijke anekdotes, grappen en opvulling. Focus op frameworks, datapunten en contra-intuïtieve bevindingen.
Stap 2: Schrijf een haakregel van minder dan 200 tekens die ofwel een gangbare aanname uitdaagt of een specifiek resultaat belooft. Begin nooit met "Ik heb net een nieuwe video gepubliceerd" — niemand geeft om je publicatieschema.
Stap 3: Structureer het hoofdgedeelte als een miniframework. LinkedIn's algoritme beloont berichten die gestructureerd aanvoelen — genummerde lijsten, vetgedrukte koppen en duidelijke conclusies krijgen meer engagement dan verhalende alinea's.
Stap 4: Eindig met een vraag die uitnodigt tot reacties. Niet "Wat vind je ervan?" — dat is lui. Iets specifieks: "Wat is het meest contra-intuïtieve dat je hebt geleerd over [onderwerp] in productie?"
Stap 5: Voeg drie hashtags toe. Twee breed (#AIEngineering, #SoftwareDevelopment), één specifiek (#ClaudeCode). Nooit meer dan drie — LinkedIn bestraft overmatig hashtaggebruik.
Stap 6: Genereer een infographic-achtige visual met de linkedin-infographic.md visuele skill. Deze haalt mijn profielfoto uit brand-assets/, past mijn kleurenpalet toe en creëert een strakke grafiek die het kernframework van het bericht benadrukt.
De visuele generatie was een uitdaging die ik niet had verwacht. Mijn eerste aanpak gebruikte Claude Code om HTML te genereren, het te renderen naar een afbeelding met een headless browser, en de PNG op te slaan. Het werkte, maar de afbeeldingen zagen er steriel uit. De doorbraak kwam toen ik mijn color-palette.json aan de merkassets toevoegde:
{
"primary": "#1a1a2e",
"secondary": "#16213e",
"accent": "#0f3460",
"highlight": "#e94560",
"text_light": "#ffffff",
"text_dark": "#1a1a2e",
"background": "#f5f5f5"
}
Met die kleuren geladen, gingen de gegenereerde infographics van "generieke AI-kunst" naar "dit ziet eruit alsof het uit mijn ontwerpsysteem komt." Klein detail, enorm verschil in waargenomen professionaliteit.
Instagram Carousel: Educatieve Dia's Met Merkidentiteit
Instagram is een heel ander verhaal. Mensen scrollen snel, meestal op mobiel, en ze stoppen voor visuals — niet voor tekst. Het carouselformaat is de oplossing: elke dia is visueel genoeg om aandacht te trekken, maar het doorvegen beloont educatieve content die dia voor dia opbouwt.
Mijn youtube-to-instagram-carousel.md-skill genereert 5-8 dia's met deze structuur:
Dia 1 (Hook): Een gedurfde uitspraak of vraag in grote tekst over een merkachtergrond. Gebruikt mijn accentkleur (#e94560) en profielfoto in de hoek met het geverifieerde badge-overlay.
Dia's 2-6 (Content): Elke dia behandelt één kernpunt uit de video. Maximaal 40 woorden per dia. De skill specificeert: "Schrijf op het leesniveau van een slimme 16-jarige. Geen jargon zonder onmiddellijke uitleg. Eén concept per dia."
Dia 7 (Samenvatting): Een snelle recap van alle punten in een compact formaat.
Dia 8 (CTA): "Volg voor meer AI engineering breakdowns" met mijn profielfoto en gebruikersnaam.
De geverifieerde badge-integratie gebruikt Pillow om mijn profielfoto samen te stellen met een verified-badge.png gepositioneerd in de standaard rechteronderhoek. Het create_visuals.py-script laadt merkkleuren uit color-palette.json, creëert dia's van 1080x1080, legt de profielfoto en badge erover, rendert de tekst met Inter Bold op 48pt en voegt een diateller toe in de hoek.
def create_instagram_slide(text, slide_number, total_slides):
"""Generate a single Instagram carousel slide with brand assets."""
with open("brand-assets/color-palette.json") as f:
colors = json.load(f)
slide = Image.new("RGB", (1080, 1080), colors["primary"])
# Composite profile pic + verified badge
profile = Image.open("brand-assets/profile-pic-round.png").resize((80, 80))
slide.paste(profile, (40, 40), profile)
badge = Image.open("brand-assets/verified-badge.png").resize((24, 24))
slide.paste(badge, (96, 96), badge)
# Render slide text and counter
draw = ImageDraw.Draw(slide)
font = ImageFont.truetype("brand-assets/fonts/Inter-Bold.ttf", 48)
draw.text((80, 200), text, fill=colors["text_light"], font=font)
return slide
Elke dia wordt opgeslagen in drafts/instagram/ als een apart PNG-bestand met de naamconventie {datum}_{video_slug}_slide_{nummer}.png.
X-Berichten: Informele Quote-Visuals Die Geretweet Worden
X (voorheen Twitter) is het platform waar beknoptheid wint en persoonlijkheid het meest telt. Niemand deelt een bedrijfsmatig klinkende tweet. Ze delen scherpe observaties, verrassende meningen en citeerbare oneliners.
Mijn youtube-to-x-quote.md-skill neemt een compleet andere benadering dan LinkedIn en Instagram. In plaats van frameworks of educatieve uitsplitsingen te extraheren, zoekt hij naar drie dingen in het transcript:
- De meest citeerbare enkele zin. De regel die iemand zou screenshotten en delen.
- De meest tegendraadse mening. Het moment waarop ik iets zei waar de meeste mensen het niet mee eens zouden zijn.
- De meest praktische oneliner. Een tip zo specifiek en direct toepasbaar dat mensen hem bookmarken.
Voor elk genereert de skill twee outputs: de tweettekst (minder dan 280 tekens, informele toon, geen hashtags — die zien er wanhopig uit op X) en een quote-visual. De quote-visual is een eenvoudige merkafbeelding met de citaattekst in een groot, schoon lettertype over mijn kleurenpaletachtergrond, met mijn profielfoto en handle in de hoek.
De vereiste voor informele toon is het moeilijkste om goed te krijgen. LinkedIn en Instagram verdragen beide gepolijst, enigszins formeel schrijven. X bestraft het. Mijn skilldocument bevat een sectie voor toonkalibratie:
## Tone Rules for X
- Write like texting a smart friend, not presenting at a conference.
- Contractions always. "I've" not "I have." "Don't" not "Do not."
- OK to start sentences with "So" or "Look" or "Honestly."
- One emoji maximum per post. Zero is fine.
- Never use corporate phrases: "leverage," "synergy," "ecosystem."
- If the tweet sounds like it could appear in a press release, rewrite it.
Die toonsectie is vier keer herzien. Versie één klonk als ingekort LinkedIn. Versie twee overcorrigeerde naar tienerterritorium. Versie drie gebruikte te veel uitroeptekens. Versie vier produceert consistent tweets die klinken als iets dat ik daadwerkelijk om 23:00 uur zou schrijven na het hebben van een uitgesproken mening.
Dit is wat me verraste aan het gelijktijdig genereren voor drie platforms: het LinkedIn-inzicht, de Instagram-uitsplitsing en de X-hete mening zijn drie uitdrukkingen van hetzelfde onderliggende idee. Die coherentie is de echte multiplicator. Niet alleen 9x volume — 9x volume met consistente boodschappen.
Maar volume betekent niets zonder kwaliteit. Daar verdient de goedkeuringsworkflow zijn plek.
De Handmatige Goedkeuringsworkflow: Waarom Ik Weiger Automatisch te Publiceren
Ik weet wat je denkt. "Je hebt al deze automatisering gebouwd om... alles nog steeds handmatig te beoordelen?"
Ja. Absoluut. En ik zou het weer doen.
Dit is wat ik heb geleerd na een jaar van het draaien van verschillende contentautomatiseringssystemen: de kosten van het publiceren van één slecht bericht zijn hoger dan de kosten van het beoordelen van twintig goede. Dat LinkedIn-placeholderincident dat ik eerder noemde? Het kostte me drie weken om het engagementpercentage op mijn profiel te herstellen. Drie weken van consequent goede berichten om dertig seconden geautomatiseerde onoplettendheid ongedaan te maken.
Mijn goedkeuringsworkflow heeft drie fasen:
Fase 1: Generatie. Alle content belandt in drafts/. Elk stuk krijgt een metadata-header:
---
platform: linkedin
video_source: "Building AI Agent Teams - March 2026"
generated_at: 2026-03-15T14:23:00Z
status: draft
skill_version: youtube-to-linkedin-v4
---
Fase 2: Beoordeling. Ik open de drafts/-map — meestal één keer 's ochtends, één keer 's avonds. Ik lees elk stuk. Ik controleer op: feitelijke juistheid, toongeschiktheid, merkconsistentie en de "zou ik dit daadwerkelijk publiceren?"-buikgevoelencheck. Als het slaagt, verplaats ik het naar approved/. Als het aanpassingen nodig heeft, bewerk ik direct of draai ik de skill opnieuw met aangepaste parameters.
Fase 3: Planning. Alleen bestanden in approved/ worden ingediend bij Blotato. Het submit_to_blotato.py-script scant de approved/-map, uploadt alle content die nog niet is ingediend, en plant het in op basis van de DEFAULT_SCHEDULE_OFFSET_HOURS uit de omgevingsconfiguratie.
def submit_approved_content():
"""Submit all approved, unsubmitted content to Blotato."""
approved_dir = Path("approved")
headers = {
"Authorization": f"Bearer {os.getenv('BLOTATO_API_KEY')}",
"Content-Type": "application/json"
}
for platform in ["linkedin", "instagram", "x"]:
for content_file in (approved_dir / platform).glob("*.md"):
# Skip already-submitted files (.submitted marker)
if content_file.with_suffix(".submitted").exists():
continue
metadata, body = parse_front_matter(content_file.read_text())
offset = int(os.getenv("DEFAULT_SCHEDULE_OFFSET_HOURS", 24))
schedule_time = datetime.utcnow() + timedelta(hours=offset)
payload = {
"workspace_id": os.getenv("BLOTATO_WORKSPACE_ID"),
"platform": platform,
"content": body.strip(),
"scheduled_at": schedule_time.isoformat() + "Z",
}
response = requests.post(
"https://api.blotato.com/v1/posts",
headers=headers, json=payload
)
if response.status_code == 201:
# Write marker to prevent double-posting
content_file.with_suffix(".submitted").write_text(
json.dumps({"blotato_post_id": response.json()["id"]})
)
De .submitted-markerbestanden voorkomen dubbele publicatie — ik heb dat op de harde manier geleerd toen een vroege versie hetzelfde LinkedIn-bericht drie keer indiende via een cron-job zonder idempotentiecontroles.
Mijn typische beoordelingssessie duurt 10-15 minuten voor een batch van negen berichten. Ik keur ongeveer 80% goed bij de eerste doorgang. De overige 20% hebben kleine bewerkingen nodig — meestal een toonaanpassing of een feitelijke correctie waarbij de AI iets uit de video net iets verkeerd parafraseerde.
Vijftien minuten om negen berichten te beoordelen. Vergeleken met de meer dan twee uur die het me vroeger kostte om ze helemaal zelf te maken. Dat is de efficiëntiewinst die ertoe doet — niet het volledig elimineren van de mens, maar het elimineren van het mechanische werk en het behouden van het beoordelingsvermogen.
Hoe Claude Code Zichzelf Corrigeert: De Iteratieve Lus Die Dit Betrouwbaar Maakt
Ik noemde eerder dat Claude Code leert van fouten. Laat me je precies laten zien hoe dat eruitziet, want dit is het deel van de workflow dat mij het meest verraste.
Tijdens mijn tweede week van testen liep de transcriptextractieskill tegen een muur. Claude Code probeerde YouTube-pagina's rechtstreeks op te halen met Python's requests-bibliotheek en het transcript uit de HTML te parseren. YouTube's botdetectie blokkeerde het onmiddellijk.
Dit is wat er gebeurde in de Claude Code-terminal:
> Running transcript-extraction skill...
> Fetching https://youtube.com/watch?v=xxxxx
> ERROR: 403 Forbidden - Bot detection triggered
> Analyzing failure...
> Updating skill: transcript-extraction.md
> Added step: "Use youtube-transcript-api library instead
> of direct page fetching. Install via pip if not present."
> Retrying with updated skill...
> Success: Transcript extracted (4,847 words)
Claude Code rapporteerde niet alleen de fout. Het diagnosticeerde de oorzaak, identificeerde een alternatieve aanpak, werkte het skilldocument bij met de oplossing en probeerde het opnieuw. De transcript-extraction.md-skill bevat nu een regel die luidt: "Probeer NOOIT rechtstreekse YouTube-paginaophaling. Gebruik altijd het youtube-transcript-api Python-pakket voor transcriptextractie."
Die oplossing is permanent. Elke toekomstige run gebruikt de gecorrigeerde aanpak.
Nog een voorbeeld: de beeldgeneratie voor LinkedIn-infographics produceerde aanvankelijk afbeeldingen van 2400x2400 pixels — veel te groot voor Blotato's uploadlimiet van 4MB. De eerste fout activeerde deze reeks:
> Generating LinkedIn infographic...
> Uploading to Blotato...
> ERROR: 413 Payload Too Large (6.2MB)
> Analyzing failure...
> Updating skill: linkedin-infographic.md
> Added step: "After rendering, resize to 1200x1200
> and compress to JPEG at 85% quality.
> Verify file size < 4MB before upload."
> Regenerating with compression...
> Upload successful (1.8MB)
Ik heb veertien skilldocumentupdates geteld die voortkwamen uit runtimefouten. Veertien problemen die zichzelf oplosten. Elk zou een handmatige debugsessie zijn geweest — de fout vinden, de oplossing bedenken, onthouden om het de volgende keer toe te passen. In plaats daarvan draagt het skilldocument het institutionele geheugen.
Dit is waarom ik skills als levende documenten beschouw. Het zijn geen statische instructies. Het is een kennisbank die groeit elke keer dat er iets misgaat. Na drie weken van het draaien van deze pipeline zijn mijn skilldocumenten aanzienlijk meer beproefd dan de versies die ik oorspronkelijk schreef. De correcties van de AI verwerken vaak randgevallen die ik nooit zou hebben voorzien.
De kanttekening: Claude Code krijgt de oplossing niet altijd bij de eerste poging goed. Ongeveer 30% van de tijd creëert de initiële correctie een nieuw probleem. De beeldcompressiefix comprimeerde eerst naar JPEG op 50% kwaliteit, waardoor tekst onleesbaar werd. Ik heb handmatig naar 85% aangepast. De correcties van de AI zijn goede startpunten, geen onfeilbare oplossingen.
Vertrouw de lus. Verifieer de output.
De Volledige Pipeline Draaien: Van Video tot Geplande Berichten
Goed, hier is het moment waarop alles samenkomt. Je hebt de projectstructuur gezien, de API-opstelling, de platformskills, de goedkeuringsworkflow en de zelfcorrigerende lus. Laat me je door een volledige run leiden.
Stap 1: Ik open het project in VS Code, start Claude Code en plak de YouTube-URL. Claude Code leest de transcript-extraction.md-skill en haalt het volledige transcript op met youtube-transcript-api.
Stap 2: Drie contentgeneratieskills draaien achter elkaar. Elke leest het transcript, past platformspecifieke regels toe en slaat output op in drafts/linkedin/, drafts/instagram/ of drafts/x/.
Stap 3: Visuele generatieskills vuren daarna — LinkedIn-infographic, Instagram-carouseldia's, X-quote-visuals. Allemaal halen ze uit brand-assets/.
Stap 4: Ik open drafts/, beoordeel alles, maak bewerkingen en verplaats goedgekeurde content naar approved/.
Stap 5: python scripts/submit_to_blotato.py pakt alles op in approved/, plant in via Blotato's API en markeert elk bestand als ingediend.
Totale tijd van video-URL tot geplande content: ongeveer 40 minuten, waarvan 15 minuten mijn beoordeling. Voor een enkele video van 20 minuten krijg ik drie LinkedIn-berichten (verschillende invalshoeken), drie Instagram-carouselsets (verschillende secties) en drie X-berichten (citaat, tegendraadse mening, praktische tip). Negen stukken content uit één video.
Dat is de 9x-multiplicator. Niet theoretisch. Daadwerkelijke output die ik wekelijks draai.
Wat Ik Fout Deed en Wat Ik Anders Zou Doen
Drie weken in productiegebruik, wat eerlijke reflectie.
Het claude.md-bestand ging door vijf herschrijvingen. Mijn eerste versie was 300 regels — Claude Code negeerde de helft van de instructies. Op 150 regels werd de uitvoering betrouwbaar. Met AI-systeemprompts geldt: minder is meer. Schrap alles wat geen harde beperking of cruciale context is.
Ik heb beeldgeneratie te complex gemaakt. Headless Chromium die HTML naar PNG rendert was traag en fragiel. Overschakelen naar Pillow was sneller, voorspelbaarder en gaf pixelniveau controle. Sla browserrendering helemaal over.
Kwaliteit is niet uniform over platforms. LinkedIn-berichten bereiken ongeveer 90% van wat ik handmatig zou schrijven. Instagram-carousels landen rond de 80%. X-berichten variëren van geweldig tot middelmatig — korte informele teksten zijn oprecht moeilijker voor AI. Ik ben dat skilldocument nog steeds aan het afstemmen.
Begin met één platform, niet drie. Gelijktijdig bouwen betekende dat elke debugsessie verdrievoudigd was. Als ik opnieuw zou beginnen, zou ik eerst LinkedIn perfectioneren en dan klonen en aanpassen voor Instagram en X.
De goedkeuringsworkflow is niet-onderhandelbaar. Ik heb geprobeerd X-berichten een week lang automatisch te publiceren. Twee van de veertien hadden toonproblemen die ik handmatig zou hebben opgevangen. Eén verwees naar een "recente update" die drie maanden oud was. Handmatige beoordeling blijft.
Hoe Dit Eruitziet op Schaal: De Cijfers na 30 Dagen
Na het draaien van deze pipeline voor een volledige maand met wekelijkse uploads: vier video's produceerden 36 contentstukken. Daarvan slaagden 29 voor de eerste beoordelingsronde (81% goedkeuringspercentage). Vijf hadden kleine bewerkingen nodig. Twee heb ik opnieuw gegenereerd met aangepaste skillparameters. Gemiddelde wekelijkse tijd: 40 minuten voor negen berichten.
Vóór dit systeem besteedde ik 3-4 uur per week aan herbestemming — wanneer ik het überhaupt deed. De consistentieverbetering is belangrijker dan de tijdsbesparing. Ik ging van sporadisch publiceren naar negen keer per week, elke week, met merkconforme boodschappen over alle platforms.
De grootste verrassing? Cross-platform coherentie dreef meer profielbezoeken dan puur volume. Wanneer iemand mijn LinkedIn-frameworkbericht zag, en dan hetzelfde concept als een pakkend X-citaat een uur later, sloeg patroonherkenning aan. Meerdere mensen stuurden me een DM met "Ik zie je content overal." Dat was geen toeval — negen berichten van één video, verspreid over platforms gedurende 48 uur.
Die coherentie krijg je niet met handmatige herbestemming, omdat handmatige herbestemming op verschillende dagen gebeurt, in verschillende stemmingen, met verschillende inspanningsniveaus. Geautomatiseerde herbestemming gebeurt in één batch, vanuit één bron, met consistente kwaliteitsparameters.
Wat Komt Hierna?
Drie uitbreidingen op mijn roadmap. Geparallelliseerde generatie met Python's asyncio om de generatietijd terug te brengen van 25 minuten naar ongeveer 10. Een analytics-feedbacklus die berichtprestatiedata terugvoert naar skilldocumenten — als vraageindigende CTA's consequent beter presteren dan uitspraken op LinkedIn, moet de skill dat automatisch leren. En nieuwsbriefintegratie als vierde outputtype, wat de skillarchitectuur op natuurlijke wijze ondersteunt met één nieuw markdown-bestand.
De onderliggende architectuur schaalt omdat elk nieuw platform gewoon een nieuw skilldocument is. De goedkeuringsworkflow, merkassets en Blotato-integratie blijven hetzelfde. Dat is de kracht van bouwen op skills in plaats van eenmalige scripts — het systeem is modulair van nature.
Ik begon dit project omdat ik het mechanische contentwerk beu was. Ik eindigde met het volledig heroverwegen van de relatie tussen het creëren en distribueren van content. Creatie is het moeilijke deel — het denken, opnemen, uitleggen. Distributie zou automatisch moeten zijn. Je ideeën verdienen het om elk platform te bereiken waar je doelgroep zich bevindt, in het formaat dat elk platform beloont.
Eén video. Negen berichten. Veertig minuten. Het systeem wordt elke week slimmer.
Wat is dat ene stuk content dat je steeds wilt herbestemmen maar waar je nooit tijd voor vindt? Dat is je eerste skilldocument.
Veelgestelde Vragen
Kan ik Claude Code en Blotato gebruiken zonder Python-scripts te schrijven?
Je kunt de ingebouwde terminal van Claude Code gebruiken om individuele skillopdrachten uit te voeren zonder aangepaste scripts. Maar de Python-laag verwerkt beeldgeneratie, bestandsbeheer en Blotato API-aanroepen betrouwbaarder dan shell-commando's alleen. Voor de volledige pipeline is Python de moeite van de installatie waard.
Hoeveel kost de Blotato en Anthropic API-combinatie per maand?
Mijn maandelijkse API-uitgaven liggen gemiddeld op $25-40 voor vier video's aan contentgeneratie. De Anthropic API verwerkt de zware tekstgeneratie (ongeveer $15-25), en het API-gebruik van Blotato valt binnen hun standaard abonnementsprijzen. OpenRouter als terugvaloptie voegt $5-10 toe voor lichtere taken. Voor een diepere blik op het beheren van AI API-kosten, zie mijn AI agent kostenoptimalisatiegids.
Wat gebeurt er als Blotato's API een bericht afwijst?
Het submit_to_blotato.py-script logt de afwijzing met het volledige foutantwoord. Veelvoorkomende oorzaken: te grote afbeeldingen (comprimeer onder 4MB), ongeldige planningstijden (moeten toekomstige tijdstempels zijn) of verlopen OAuth-tokens (opnieuw authenticeren via Blotato's dashboard). De afwijzing heeft geen invloed op andere berichten in de batch.
Hoe houd ik de claude.md-systeemprompt onder 150 regels?
Focus alleen op beperkingen en beschikbare skills. Verwijder uitleg, voorbeelden en context die Claude Code kan afleiden. Elke regel moet ofwel een harde regel zijn ("NOOIT automatisch publiceren") of een verwijzing naar een skilldocument dat de gedetailleerde instructies bevat. Verplaats alle implementatiedetails naar de skillbestanden zelf.
Ondersteunt deze workflow videocontent in andere talen dan Engels?
De youtube-transcript-api-bibliotheek ondersteunt transcripten in meerdere talen. De contentgeneratieskills zouden taalspecifieke toonregels nodig hebben, maar de pipelinearchitectuur blijft identiek. Ik heb dit zelf nog niet getest met niet-Engelstalige content — het staat op mijn lijst voor Q2 2026.
Laten We Samenwerken
Op zoek naar hulp bij het bouwen van AI-systemen, het automatiseren van workflows of het opschalen van je technische infrastructuur? Ik help je graag.
- Fiverr (maatwerk builds & integraties): fiverr.com/s/EgxYmWD
- Portfolio: mejba.me
- Ramlit Limited (enterprise-oplossingen): ramlit.com
- ColorPark (design & branding): colorpark.io
- xCyberSecurity (beveiligingsdiensten): xcybersecurity.io
