Ik bouwde een zelflerend LinkedIn-systeem met Claude Code

Het bericht dat mijn kijk op LinkedIn-automatisering veranderde, was er niet een dat ik zelf schreef. Het was een bericht dat het systeem schreef nadat het zevenenveertig van mijn eerdere posts had geanalyseerd, had vastgesteld dat transformatiehooks 2,3x beter presteerden dan mijn geliefde "ik"-openers op bereik, en om 4 uur 's nachts op een dinsdag — terwijl ik sliep — zijn eigen contentstrategie herschreef.

Ik werd wakker met een Notion-database met een nieuw leadmagneet, een LinkedIn-bericht dat al ingepland was via Blotato, en een strategiedocument dat uitlegde waarom het zijn aanpak had veranderd. De redenering was beter dan de meeste contentaudits waar ik mensen voor had betaald.

Dat moment kristalliseerde iets waar ik al maanden omheen draaide: de echte doorbraak in AI-gestuurde content is niet de generatie. Het is de feedbackloop. Elke prompt kan een fatsoenlijk LinkedIn-bericht produceren. Wat een systeem dat stagneert onderscheidt van een systeem dat groeit, is of het leert van wat daadwerkelijk werkt — en bijstuurt zonder te wachten tot jij het opmerkt.

Dit is het verhaal van hoe ik dat systeem bouwde met Claude Code, Karpathy's auto research-patroon, en een handvol tools die de meeste mensen los van elkaar gebruiken maar nooit aan elkaar koppelen. Het draait volledig op GitHub Actions. Ik heb al zes weken geen LinkedIn-bericht meer handmatig geschreven. En de betrokkenheid stijgt.

Waarom de meeste LinkedIn-automatisering binnen twee weken mislukt

Ik heb de voor de hand liggende aanpakken geprobeerd. Buffer. Hootsuite. Zelfs een aangepaste n8n-workflow die onderwerpen uit RSS-feeds haalde en berichten genereerde via de OpenAI API. Ze delen allemaal hetzelfde fatale gebrek: het zijn open-loop-systemen.

Open-loop betekent dat het systeem output produceert maar nooit het resultaat observeert. Het genereert Bericht A, publiceert het, en genereert vervolgens Bericht B met exact dezelfde strategie. Of Bericht A 47 vertoningen of 4.700 kreeg, is irrelevant — het systeem weet het niet en het kan het niet schelen.

Dit is alsof een chef elke avond kookt maar het eten nooit proeft of de gasten vraagt wat ze ervan vonden. Na een maand heb je iemand die dertig maaltijden heeft gekookt en niets heeft geleerd.

Het LinkedIn-algoritme in 2026 maakt dit probleem erger. Weergaven zijn ruwweg 50% gedaald jaar-op-jaar volgens recente platformdata, betrokkenheid is met 25% afgenomen, en volgersgroei is met 59% gekelderd. Het algoritme beloont nu leestijd en gesprekskwaliteit boven ruwe reacties — expertinteracties wegen 7-9x zwaarder in het algoritme dan een snelle duim omhoog. Het oude spel van "consequent posten en hopen" werkt niet meer sinds LinkedIn's aanbevelingsmotor echt geavanceerd is geworden.

Wat je nodig hebt is niet meer berichten. Je hebt een systeem nodig dat observeert wat daadwerkelijk resoneert bij jouw specifieke doelgroep en continu zijn doel aanscherpt.

Daar komt Karpathy's auto research-patroon om de hoek kijken. En daar viel alles voor mij op zijn plaats.

Karpathy's Auto Research: het mentale model dat alles verandert

Andrej Karpathy bracht zijn autoresearch-project begin 2026 uit, en de AI-gemeenschap is er sindsdien niet meer over uitgepraat. Het oorspronkelijke concept was elegant: geef een AI-agent een kleine LLM-trainingsopstelling, laat het de code aanpassen, voer een kort experiment uit, evalueer de resultaten, en bepaal of de wijziging een verbetering was. Bewaar de winsten, verwerp de verliezen, herhaal.

Karpathy liet deze loop twee dagen draaien. De agent voerde 700 experimenten uit. Het ontdekte 20 optimalisaties die de trainingstijd verbeterden. Toen diezelfde 20 aanpassingen werden toegepast op een groter model, leverden ze een versnelling van 11% op.

Dit is wat de meeste mensen over dit verhaal missen: het onderliggende patroon heeft niets met machine learning-training te maken. Het werkt voor alles wat je kunt meten.

Je LinkedIn-berichten? Meetbaar. Hookprestaties? Meetbaar. Betrokkenheidspercentages per berichtformaat? Meetbaar. Welke onderwerpen je doelgroep daadwerkelijk interesseren versus welke jij denkt dat ze interesseren? Zeer meetbaar.

Het auto research-patroon is een gesloten-loop-optimalisatiesysteem: handelen, meten, analyseren, bijsturen, herhalen. Het "onderzoek"-deel is niet het browsen op het web of het lezen van papers — het systeem onderzoekt zijn eigen prestaties en trekt conclusies die de volgende cyclus informeren.

Toen ik Duncan Rogoff dit concept zag demonstreren toegepast op LinkedIn-content — hij is een voormalig art director die AI-agency-oprichter werd en een community runt genaamd The Build Room — verschoof er iets in mijn denken. Duncan had een systeem gebouwd waarbij Claude Code leadmagneten genereerde, LinkedIn-berichten publiceerde via Blotato, betrokkenheidsstatistieken scrapete via Apify, en vervolgens een wekelijkse auto research-analyse draaide om zijn contentstrategie te herschrijven. De hele pipeline draaide op GitHub Actions zonder menselijke interventie.

Ik wilde het niet alleen repliceren. Ik wilde elke laag diep genoeg begrijpen om het aan te passen aan mijn eigen workflow. Dus bouwde ik mijn eigen versie helemaal opnieuw.

Hier is de architectuur.

De vijflaagse architectuur: hoe het systeem daadwerkelijk werkt

De meeste tutorials beschrijven automatisering als een lineaire pipeline: input gaat erin, output komt eruit. Dit systeem is beter te begrijpen als een loop met vijf afzonderlijke lagen, elk met een specifieke taak. Sla één laag over en de feedbackloop breekt.

Laag 1: De leadmagneetmotor

Elk bericht in dit systeem begint met een leadmagneet. Niet het bericht zelf — het asset dat het bericht promoot. Dit is een strategische beslissing, geen technische. LinkedIn's algoritme in 2026 onderdrukt externe links (ruwweg 60% bereikvermindering), dus je moet mensen een reden geven om op het platform te reageren voordat je ze ergens naartoe stuurt.

De leadmagneetmotor is een Claude Code-skill die drie inputs neemt: een beschrijving van de doelgroep, een trending onderwerp uit de onderzoekslaag, en een contentformaat (framework, playbook, promptpakket of verhalend stuk). Het levert een compleet leadmagneet op dat wordt opgeslagen in Notion — titel, structuur, de daadwerkelijke inhoud, en verhaalelementen die zijn ontworpen om het asset de moeite waard te laten voelen om op te vragen in de reacties.

De skilldefinitie is hier enorm belangrijk. Ik heb twee uur besteed aan het verfijnen van de prompt die deze skill aandrijft, en ik schat dat die investering me sindsdien meer dan 60 uur heeft bespaard. De prompt bevat de specifieke pijnpunten van mijn doelgroep (experts met diepgaande kennis maar lage online zichtbaarheid), de positionering van mijn merk, en expliciete instructies over diepgang. Ik wil geen dunne, generieke "5 tips"-pdf's. Ik wil assets waarbij iemand denkt "deze persoon weet écht waar hij het over heeft."

Hier is het skelet van de skillconfiguratie:

name: lead_magnet_generator
description: Generate high-value lead magnets for LinkedIn distribution
inputs:
  - audience_profile: "Professionals with expertise but low online visibility"
  - topic: "{{trending_topic}}"
  - format: "{{selected_format}}"  # framework | playbook | prompt_pack | story
context:
  - brand_voice_guide.md
  - top_performing_magnets.md  # auto-updated by research layer
  - audience_pain_points.md
output:
  destination: notion
  database: "Lead Magnets"
  fields:
    - title
    - hook
    - body_content
    - storytelling_elements
    - cta_text
    - target_format

Het bestand top_performing_magnets.md is het belangrijkste onderscheidende element. Dit is geen statisch document — de auto research-laag herschrijft het wekelijks op basis van welke leadmagneten daadwerkelijk de meeste reacties en betrokkenheid opleverden. Het systeem leert zichzelf letterlijk welk type assets jouw doelgroep wil.

Laag 2: De berichtenschrijver en publiceerder

Zodra het leadmagneet in Notion staat, genereert een tweede Claude Code-workflow het LinkedIn-bericht. Deze workflow leest het leadmagneet, het huidige contentstrategiedocument (ook automatisch bijgewerkt), en produceert een bericht dat is geoptimaliseerd voor de patronen die momenteel werken.

De berichtenschrijver volgt specifieke structuurregels die voortkwamen uit de auto research-analyse:

• Hook: Onder de 200 tekens. LinkedIn-data toont aan dat hooks onder de 200 tekens die spanning introduceren of specifieke waarde beloven dramatisch beter presteren dan verklarende openingen. Het systeem roteert tussen hooktypes — transformatiehooks, tegendraadse hooks en specifieke-getal-hooks — en houdt bij welk type het best presteert.

• Hoofdtekst: Opgemaakt voor leestijd. Korte regels. Strategische regelafbrekingen. Het algoritme weegt nu zwaarder of iemand 45 seconden je bericht leest dan of ze op de like-knop drukken.

• CTA: Op reacties gebaseerd, niet op links. "Reageer FRAMEWORK en ik stuur het je toe" presteert veel beter dan "Download hier: [link]" omdat het betrokkenheidssignalen genereert die het algoritme beloont.

Publicatie verloopt via Blotato, dat API-toegang biedt vanaf $29/maand op de starterslaag. Blotato ondersteunt negen platformen — LinkedIn, X, Instagram, Facebook, TikTok, Pinterest, YouTube, Threads en Bluesky — en heeft native n8n- en Make.com-nodes. Voor dit systeem gebruik ik de REST API rechtstreeks vanuit een Node.js-script dat Claude Code heeft geschreven.

// publish-to-linkedin.js (simplified)
const axios = require('axios');

async function publishPost(postContent, mediaUrl = null) {
  const payload = {
    content: postContent,
    platforms: ['linkedin'],
    publish_at: calculateOptimalTime(), // based on engagement data
    media: mediaUrl ? [{ url: mediaUrl, type: 'video' }] : []
  };

  const response = await axios.post(
    'https://api.blotato.com/v1/posts',
    payload,
    {
      headers: {
        'Authorization': `Bearer ${process.env.BLOTATO_API_KEY}`,
        'Content-Type': 'application/json'
      }
    }
  );

  return response.data;
}

De functie calculateOptimalTime() is niet hardgecodeerd op "dinsdag om 9 uur" zoals elke generieke LinkedIn-gids suggereert. Het haalt gegevens op uit de betrokkenheidsdatabase en berekent wanneer mijn specifieke doelgroep het meest actief is op basis van historische prestaties. Nog iets dat de auto research-laag zelf heeft ontdekt.

Laag 3: Het videocomponent

Deze laag verraste me het meest. Duncan's systeem bevat een stap waarbij Claude Code een schermopname van 6-7 seconden maakt terwijl er door het leadmagneet in Notion wordt gescrold, met merkgebonden tekst-overlays — specifiek lettertype (Gotham), neongroene markeervak met zwarte rand. De video wordt aan het LinkedIn-bericht gehecht.

Waarom is dit belangrijk? Omdat documentberichten en videoberichten op LinkedIn in 2026 betrokkenheidspercentages van 6,60% halen, het hoogste van elk format. Standaard tekstberichten komen nauwelijks boven de 2%. Een korte scroll-video van je leadmagneet dient twee doelen: het geeft een voorproefje van de waarde (verlaagt de drempel om te reageren) en het signaleert aan het algoritme dat dit rijke media-content is die het waard is om te verspreiden.

Ik heb dit aangepast aan mijn eigen merkkleuren en stijl. Het opnamescript gebruikt Puppeteer om de Notion-pagina te openen, er met een gecontroleerd tempo doorheen te scrollen en het scherm vast te leggen. Een apart FFmpeg-commando voegt de tekst-overlay toe en levert een gecomprimeerde MP4 op.

De volledige videogeneratie duurt ongeveer 30 seconden. Geen menselijke tussenkomst. Geen schermopnamesoftware. Geen bewerking.

Laag 4: De datascraper

Hier begint de loop zich te sluiten. Elke dag scrapt een Apify-actor betrokkenheidsstatistieken van mijn LinkedIn-berichten. Apify's LinkedIn-scrapers kunnen likes, reacties, reposts, vertoningen en reactie-indelingen extraheren — allemaal zonder cookies of accounttoegang nodig te hebben voor openbaar toegankelijke data.

De prijsstelling is redelijk: ruwweg $1-2 per 1.000 gescrapete berichten, wat voor een dagelijkse controle van je laatste 30 berichten verwaarloosbare kosten betekent.

De gescrapete data wordt geschreven naar een Notion-database met dit schema:

Post ID | Date | Hook Type | Post Length | Line Length | Content Format |
Content Angle | Topic | Likes | Comments | Shares | Impressions |
Engagement Rate | Lead Magnet Type

Elk bericht wordt bij aanmaak getagd met metadata (hooktype, format, invalshoek, onderwerp), zodat wanneer de data terugkomt, het systeem prestaties kan kruisverwijzen met deze variabelen. Dit is de instrumentatie die de onderzoekslaag krachtig maakt. Zonder gestructureerde metadata verzamel je alleen maar cijfers. Mét metadata verzamel je bruikbare inzichten.

Laag 5: De auto research-motor

Dit is het brein. Eenmaal per week (ik experimenteer met het verhogen van de frequentie) haalt een Claude Code-workflow de volledige betrokkenheidsdataset op, voert een gestructureerde analyse uit en produceert twee outputs:

1. Een prestatierapport dat identificeert wat werkt en wat niet
2. Een bijgewerkte contentstrategie die de leadmagneetmotor en berichtenschrijver gebruiken voor de volgende cyclus

De analyse omvat:

• Hookprestaties: Welke hooktypes (transformatie, tegendraads, specifiek getal, vraag, verhaal) genereren de meeste vertoningen, reacties en betrokkenheidspercentage?
• Formatprestaties: Presteren frameworks beter dan playbooks? Slaan promptpakketten beter aan dan verhalende berichten?
• Lengteanalyse: Is er een sweet spot voor de totale berichtlengte en gemiddelde regellengte?
• Onderwerpanalyse: Op welke vakgebieden reageert de doelgroep het meest?
• Invalshoekprestaties: Presteren resultaatgerichte berichten beter dan social-proof-berichten? Overtreft kwetsbaarheid autoriteit?

Het systeem identificeert niet alleen correlaties — het genereert hypotheses en plant experimenten. "Transformatiehooks presteren 2,3x beter. Volgende week drie transformatiehooks testen met verschillende onderwerpgebieden om te bepalen of het hooktype of het onderwerp de primaire drijfveer was."

Dit is Karpathy's auto research-patroon in zijn puurste vorm. Handelen, meten, analyseren, hypothese vormen, volgend experiment ontwerpen, herhalen.

Hier is een vereenvoudigde versie van de analyseprompt:

## Auto Research Analysis

You have access to the following LinkedIn post performance data:
{{engagement_data}}

Analyze this data to answer:
1. Which hook types generate the highest engagement rate?
2. Which content formats drive the most comments (our primary KPI)?
3. What's the optimal post length range?
4. Which topics resonate most with the audience?
5. What content angles perform best?

Then produce:
- A performance summary with specific numbers
- Updated recommendations for the content strategy
- 3 specific hypotheses to test next week
- An updated top_performing_magnets.md file

De output overschrijft content_strategy.md en top_performing_magnets.md — dezelfde bestanden die de leadmagneetmotor en berichtenschrijver als context lezen. Het systeem heeft zojuist zijn eigen instructies herschreven op basis van empirisch bewijs.

Als je mijn stuk over zelfverbeterende AI-systemen bouwen met Claude Code hebt gelezen, herken je deze architectuur. Het reflectie-agentpatroon dat ik daar beschreef — waarbij één AI de output van een andere evalueert en de systeemprompt aanpast — is precies wat hier gebeurt. Het verschil is dat in plaats van chatbot-gesprekken te evalueren, dit systeem LinkedIn-betrokkenheidsstatistieken evalueert. Hetzelfde patroon, totaal andere toepassing.

De GitHub Actions-pipeline opzetten

Het hele systeem draait headless op GitHub Actions. Geen server. Geen cronjobs op mijn machine. Geen Zapier. Alleen een repository met workflowbestanden die volgens schema worden getriggerd.

Hier is de dagelijkse workflow:

# .github/workflows/daily-content.yml
name: Daily LinkedIn Content Pipeline

on:
  schedule:
    - cron: '0 7 * * *'  # 7 AM UTC daily
  workflow_dispatch:  # manual trigger for testing

jobs:
  generate-and-publish:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Install dependencies
        run: npm ci

      - name: Generate lead magnet
        run: node scripts/generate-lead-magnet.js
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          NOTION_API_KEY: ${{ secrets.NOTION_API_KEY }}

      - name: Generate LinkedIn post
        run: node scripts/generate-post.js
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          NOTION_API_KEY: ${{ secrets.NOTION_API_KEY }}

      - name: Record lead magnet video
        run: node scripts/record-video.js
        env:
          NOTION_API_KEY: ${{ secrets.NOTION_API_KEY }}

      - name: Publish to LinkedIn
        run: node scripts/publish.js
        env:
          BLOTATO_API_KEY: ${{ secrets.BLOTATO_API_KEY }}

      - name: Scrape engagement data
        run: node scripts/scrape-engagement.js
        env:
          APIFY_API_KEY: ${{ secrets.APIFY_API_KEY }}
          NOTION_API_KEY: ${{ secrets.NOTION_API_KEY }}

En de wekelijkse onderzoeksworkflow:

# .github/workflows/weekly-research.yml
name: Weekly Auto Research

on:
  schedule:
    - cron: '0 9 * * 0'  # Sunday 9 AM UTC
  workflow_dispatch:

jobs:
  auto-research:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Pull engagement data
        run: node scripts/pull-engagement-data.js
        env:
          NOTION_API_KEY: ${{ secrets.NOTION_API_KEY }}

      - name: Run auto research analysis
        run: node scripts/auto-research.js
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

      - name: Update content strategy
        run: node scripts/update-strategy.js
        env:
          NOTION_API_KEY: ${{ secrets.NOTION_API_KEY }}

      - name: Commit updated strategy files
        run: |
          git config user.name "Auto Research Bot"
          git config user.email "[email protected]"
          git add strategy/
          git commit -m "auto-research: update strategy $(date +%Y-%m-%d)" || true
          git push

Zes secrets in de GitHub-repository-instellingen. Twee workflowbestanden. Dat is de volledige operationele laag.

Eén ding dat ik wil benadrukken: je zult fouten tegenkomen. Duncan noemde in zijn uitleg dat Claude Code fouten gooide tijdens de initiële setup — scrapers die time-outs hadden, API-limieten, Notion-veldtype-mismatches. Ik had al die problemen plus nog een paar meer. De Apify-scraper retourneert soms verouderde data als een bericht minder dan 2 uur oud is. De Blotato API heeft een eigenaardigheid waarbij videobijlagen boven de 10MB stilzwijgend falen zonder foutmelding. En Notion's API retourneert verschillende veldformaten voor rollup-eigenschappen versus formula-eigenschappen, wat je data-ingestiescript breekt als je niet beide afhandelt.

Mijn advies: bouw elke laag onafhankelijk en test ze afzonderlijk voordat je ze aan elkaar koppelt. Draai de leadmagneetgenerator tien keer handmatig. Publiceer vijf berichten rechtstreeks via Blotato's API. Scrape je laatste twintig berichten met Apify en inspecteer de ruwe JSON. Debug laag voor laag, koppel dan.

Als je liever hebt dat iemand dit soort automatiseringspipelines helemaal opnieuw bouwt, neem ik AI-automatisering en agent-developmentopdrachten aan. Je kunt zien wat ik heb gebouwd op fiverr.com/s/EgxYmWD.

De verrassende bevinding: transformatiehooks winnen (en het is niet eens spannend)

Ik zaaide het systeem met data van mijn laatste 47 LinkedIn-berichten voordat ik de auto research-loop inschakelde. Dit gaf de analyse-engine genoeg data om vanaf dag één echte conclusies te trekken in plaats van weken te wachten om signalen te verzamelen.

Het eerste auto research-rapport bevatte een bevinding die me oprecht verraste.

Ik had aangenomen — op basis van alles wat ik had gelezen over LinkedIn-copywriting — dat "ik"-hooks met specifieke getallen de toppresteerders zouden zijn. Berichten die openen met "Ik heb 6 uur besteed aan het testen van..." of "Ik bouwde een systeem van €3K/maand met..." voelden alsof ze zouden moeten werken. Ze zijn persoonlijk, specifiek en wekken nieuwsgierigheid.

De data zei anders.

Transformatiehooks — berichten die een voor-en-na-progressie tonen — presteerden 2,3x beter dan persoonlijke "ik"-hooks op bereik en 1,8x op reactiepercentage. Hooks als "Van nul volgers naar 400 leads in 90 dagen" of "Wat er gebeurt als je stopt met het najagen van betrokkenheid en begint met het bouwen van systemen" haalden consistent meer vertoningen en diepere betrokkenheid.

Waarom? Mijn beste theorie: transformatiehooks activeren het eigenbelang van de lezer directeur. Een "ik"-statement gaat over mij. Een transformatiehook gaat over een resultaat dat de lezer wil. De lezer projecteert zichzelf in de transformatie. Ze denken niet alleen "interessant" — ze denken "zou dat ik kunnen zijn?"

Dit is geen universele wet. Het is wat werkt voor mijn doelgroep op dit moment. En dat is precies het punt. Een statische contentstrategie zou me eindeloos "ik"-hooks hebben laten schrijven omdat ze goed leken. De auto research-loop identificeerde het werkelijke patroon binnen zes dagen analyse.

Het systeem heeft sindsdien zijn strategie nog drie keer geëvolueerd. De sweet spot voor berichtlengte verschoof van 1.200-1.500 tekens naar 800-1.100 (korter, pakkender). Frameworks begonnen playbooks te overtreffen als leadmagneetformaat. Dinsdag en donderdag als posttijden versloegen maandag en woensdag. Geen van deze inzichten had ik handmatig opgepikt — in elk geval niet zo snel.

Meerdere agents parallel draaien

Eén technisch detail dat het waard is om uit te breiden: Claude Code's vermogen om meerdere agent-threads parallel te draaien versnelt zowel de bouwfase als de dagelijkse uitvoering dramatisch.

Toen ik dit systeem bouwde, had ik drie Claude Code-instanties tegelijkertijd draaien. Eén schreef het leadmagneet-generatiescript. Een andere bouwde de Apify-scrapingintegratie. Een derde werkte aan de video-opnamepipeline. Ze werkten op aparte bestanden in dezelfde repository en verwezen af en toe naar gedeelde utilitymodules.

Dit is geen theoretisch patroon — het is de agent teams-architectuur waar Anthropic hard aan duwt sinds Opus 4. Elke agent heeft zijn eigen contextvenster, zijn eigen taak en zijn eigen vermogen om bestanden te lezen en te schrijven. Toen ik de scraping-agent nodig had om data te formatteren op een manier die de research-agent kon consumeren, definieerde ik het dataschema in een gedeeld specificatiebestand en verwees beide agents ernaar.

Tijdens de dagelijkse uitvoering draait de pipeline sequentieel (genereren, dan publiceren, dan scrapen) omdat elke stap afhangt van de vorige. Maar tijdens de wekelijkse onderzoeksfase heb ik geëxperimenteerd met het parallelliseren van de analyse. Eén agent analyseert hookprestaties terwijl een andere formatprestaties analyseert terwijl een derde onderwerptrends onderzoekt. De resultaten worden samengevoegd tot één strategie-update.

Totale tijd van lege repository tot werkend systeem: ongeveer 20 minuten daadwerkelijke Claude Code-interactietijd voor de initiële MVP, plus nog een paar uur testen en verfijnen in de week erna. Duncan rapporteerde een vergelijkbare tijdlijn — de basis van het systeem komt snel samen omdat Claude Code het standaardwerk afhandelt. De verfijning is waar het menselijke oordeel ertoe doet.

Wat ik verkeerd deed (en wat ik zou veranderen)

Zes weken erin, hier is mijn eerlijke beoordeling van wat niet volgens plan verliep.

De videolaag is fragiel. Puppeteer die draait in een GitHub Actions-container haalt soms een time-out wanneer Notion te lang nodig heeft om te laden. Ik heb retry-logica toegevoegd, maar ik overweeg over te stappen naar een vooraf gerenderde afbeeldingscarrousel — betrouwbaarder, en de betrokkenheidsdata toont geen significant verschil tussen een scrollvideo en een goed ontworpen statische carrousel.

Wekelijks onderzoek is niet frequent genoeg. Tegen de tijd dat de zondaganalyse een falend patroon identificeert, heb ik al 5-6 berichten gepubliceerd met de oude strategie. Ik stap over naar twee keer per week — woensdag en zondag — om de feedbackloop aan te scherpen. Karpathy's oorspronkelijke autoresearch draaide continu. Contentsystemen kunnen dat tempo niet helemaal evenaren omdat je berichten genoeg betrokkenheidsdata moet laten verzamelen voordat analyse zinvol is. Maar eenmaal per week voelt te langzaam.

Het systeem handelt reacties niet af. Dit is de grootste kloof. Wanneer iemand "FRAMEWORK" reageert op een bericht om het leadmagneet aan te vragen, moet een mens (ik) nog steeds de DM sturen. Ik heb oplossingen op basis van de LinkedIn API verkend, maar LinkedIn's berichten-API zit achter partnerschapsprogramma's die niet toegankelijk zijn voor individuele ontwikkelaars. Voorlopig reageer ik twee keer per dag handmatig in batches op reacties. Het kost 10 minuten maar doorbreekt de volledig autonome droom.

Doelgroeptargeting heeft constante verfijning nodig. Mijn initiële doelgroepomschrijving was te breed: "professionals met expertise maar lage online zichtbaarheid." De auto research-loop identificeerde dat mijn berichten met de hoogste betrokkenheid een smaller segment targetten — specifiek soloconsultants en agency-oprichters in de AI/automatiseringsruimte. Ik heb sindsdien het doelgroepprofiel aangescherpt, en de volgende golf content presteert merkbaar beter.

Niet elk bericht moet een leadmagneet zijn. Pure waarde-berichten, tegendraadse meningen en persoonlijke verhalen presteren beter dan leadmagneetberichten op bereik (omdat ze geen transactionele CTA hebben). Het systeem wisselt nu af: 3 leadmagneetberichten per week, 2 pure betrokkenheidsberichten. De betrokkenheidsberichten voeden de perceptie van het algoritme over de kwaliteit van mijn account, en de leadmagneetberichten zetten dat bereik om in daadwerkelijke leads.

De cijfers na zes weken

Ik ben voorzichtig met het rapporteren van statistieken omdat context enorm uitmaakt. Mijn accountgrootte, niche, postfrequentie en doelgroepsamenstelling beïnvloeden deze cijfers allemaal. Ze zijn richtinggevend, niet voorschrijvend.

Wat ik kan delen: de auto research-loop identificeerde vijf afzonderlijke strategische aanpassingen in zes weken. Elk was gebaseerd op een statistisch significant patroon in de betrokkenheidsdata — geen intuïtie, geen best practice uit een cursus van een of andere LinkedIn-goeroe. Het systeem spotte dingen die ik maanden niet zou hebben opgemerkt, als ik ze überhaupt zou hebben opgemerkt.

Het patroon dat ik het meest overtuigend vind, is niet een enkele metriekverbetering. Het is de trajectorie. De contentstrategie van elke week is meetbaar beter geïnformeerd dan die van de vorige week. De kloof tussen de berichten van de eerste week en de berichten van de zesde week is zichtbaar in de betrokkenheidsdata. Dat samengestelde effect — waarbij elke iteratie voortbouwt op gevalideerde inzichten van de vorige — is precies wat Karpathy's auto research-patroon belooft. En het levert.

Ter vergelijking: mijn handmatige LinkedIn-posting over de voorgaande drie maanden was sporadisch (2-3 berichten per week wanneer gemotiveerd, nul tijdens drukke projectweken) zonder systematische tracking. Het geautomatiseerde systeem post 5 keer per week zonder uitzondering, volgt alles en evolueert zijn aanpak op basis van bewijs. Consistentie alleen verklaart al een aanzienlijk deel van elke betrokkenheidsverbetering. De auto research-optimalisatie bovenop die consistentie is wat de trajectorie versnellend maakt in plaats van vlak.

Hoe je je eigen versie bouwt

Als je dit wilt repliceren, is hier de volgorde die ik zou aanbevelen. Probeer niet alles tegelijk te bouwen — zo sterven automatiseringsprojecten.

Week 1: Handmatige basis. Schrijf 10 LinkedIn-berichten handmatig. Houd hooktype, format en onderwerp bij voor elk bericht. Scrape hun betrokkenheid na 48 uur met Apify (gratis tier werkt prima). Sla alles op in een Notion-database. Dit geeft je seed-data en dwingt je om je contentcategorieën te definiëren.

Week 2: Automatiseer generatie. Bouw de Claude Code-leadmagneetskill en berichtenschrijver. Test ze herhaaldelijk. Vergelijk AI-gegenereerde berichten met je handmatige berichten. Verfijn de skillprompts totdat de outputkwaliteit overeenkomt met of je handmatige schrijven overtreft bij een eerste concept.

Week 3: Automatiseer publicatie. Koppel Blotato. Zet de dagelijkse GitHub Actions-workflow op. Draai het handmatig (met workflow_dispatch) vijf keer voordat je het schema vertrouwt. Verifieer dat elke stap voltooid wordt en het bericht daadwerkelijk op LinkedIn verschijnt.

Week 4: Sluit de loop. Bouw de auto research-laag. Draai de eerste analyse op je verzamelde data (je zou inmiddels 20+ berichten moeten hebben). Bekijk het strategiedocument dat het systeem produceert. Komt de analyse overeen met je intuïtie? Waar verrast het je? De verrassingen zijn waar de waarde zit.

Week 5+: Itereer en breid uit. Verhoog de onderzoeksfrequentie. Voeg het videocomponent toe als het bij je merk past. Experimenteer met de contentmix. Laat het systeem draaien en weersta de drang om zijn aanbevelingen te negeren, tenzij je een specifieke reden hebt.

Eén niet voor de hand liggende tip: bewaar elke versie van je contentstrategiedocument in versiebeheer. Ik gebruik git hiervoor (de wekelijkse onderzoeksworkflow commit strategiewijzigingen automatisch). Over zes maanden wil je de evolutie van je strategie kunnen traceren en begrijpen waarom het systeem elke wijziging maakte. Die geschiedenis is ongelofelijk waardevol voor debugging en voor het op een dieper niveau begrijpen van je doelgroep.

Het grotere geheel: AI-systemen die leren van hun eigen output

Wat ik hier heb beschreven is een LinkedIn-contentsysteem. Maar de architectuur is universeel toepasbaar.

Het auto research-patroon — handelen, meten, analyseren, bijsturen — is toepasbaar op e-mailonderwerpregels, prijspaginateksten, advertentiecreatives, productbeschrijvingen, klantenservicereacties, of elke content waarbij je prestaties kunt meten. De specifieke tools veranderen (je kunt Apify vervangen door Google Analytics, Blotato door Mailchimp), maar de vijflaagse architectuur blijft identiek.

Karpathy's oorspronkelijke auto research draaide 700 experimenten in twee dagen op LLM-trainingsconfiguraties. Duncan Rogoff paste hetzelfde patroon toe op LinkedIn-content. Ik bouwde mijn eigen versie en ontdekte dat transformatiehooks "ik"-statements versloegen voor mijn specifieke doelgroep. Iemand anders zal dit toepassen op YouTube-thumbnails, of landingspagina-koppen, of outbound e-mailsequenties.

Het patroon is wat de moeite waard is om te internaliseren. De tools zijn slechts implementatiedetails.

En de trajectorie van deze systemen is belangrijker dan welke individuele output dan ook. Een contentsysteem dat elke week 10% beter is, klinkt niet dramatisch totdat je beseft dat het na 12 weken op een fundamenteel ander niveau opereert dan waar het begon. Dat is geen lineaire verbetering — het is samengestelde intelligentie toegepast op een specifiek, meetbaar domein.

Mijn AI-marketingteam gebouwd met Claude-skills was de voorloper van dit systeem. Skills gaven me herhaalbare uitvoering. De auto research-laag gaf me herhaalbaar leren. De combinatie van beide — consistente uitvoering plus continue optimalisatie — is wat een contentworkflow transformeert in een contentmotor.

Of je nu precies dit systeem bouwt of het patroon aanpast voor je eigen use case, het principe blijft hetzelfde: stop met AI te behandelen als een eenmalige generator. Begin het te behandelen als een feedbackloop. Het verschil in uitkomsten over tijd is verbijsterend.

Het systeem heeft zojuist het bericht van morgen gegenereerd terwijl ik dit artikel schreef. Volgens de laatste strategie-update test het een nieuw hookformat — een vraaggebaseerde opener gericht op een specifiek pijnpunt dat de data vorige week aan het licht bracht. Ik check de betrokkenheidscijfers over 48 uur. Het zou me niet verbazen als het systeem iets weet wat ik niet weet.

Dat is het hele punt.

Veelgestelde vragen

Hoeveel kost de volledige LinkedIn-automatiseringsstack per maand?

De kernkosten zijn Claude Code API-gebruik (variabel, ruwweg $30-60/maand afhankelijk van volume), Blotato voor $29/maand voor publicatie, en Apify voor ongeveer $1-2 per 1.000 scrapes. GitHub Actions is gratis voor publieke repo's of inbegrepen bij GitHub Pro. Totaal: ruwweg $70-100/maand voor een dagelijks postsysteem.

Kan Karpathy's auto research-patroon werken voor andere platformen dan LinkedIn?

Het patroon werkt overal waar je contentprestaties kunt meten met gestructureerde data. E-mail-openingspercentages, YouTube-retentiecurves, advertentie-klikpercentages en landingspagina-conversiestatistieken voeden allemaal dezelfde handelen-meten-analyseren-bijsturen-loop. Wissel de scraping-tool en publicatie-API uit; de architectuur blijft identiek.

Hoeveel berichten heb je nodig voordat de auto research-analyse nuttig is?

Ik zaaide met 47 berichten en kreeg meteen bruikbare inzichten. Voor statistische significantie bij vergelijkingen van hooktypes, mik op minimaal 20-30 berichten met gevarieerde hooktypes. Minder dan 15 berichten en je leest ruis, geen signaal. Voor een uitgebreidere uitleg van de zelfverbeterende architectuur, zie mijn bericht over zelfverbeterende AI-systemen bouwen met Claude Code.

Bestraft LinkedIn geautomatiseerd posten via tools van derden?

LinkedIn's API-voorwaarden staan publicatie toe via geautoriseerde applicaties van derden. Blotato gebruikt officiële platform-API's, geen browserautomatisering of scraping-hacks. Het risico komt van contentpatronen van lage kwaliteit, niet van de publicatiemethode. LinkedIn's algoritme van 2026 detecteert betrokkenheidspods met 97% nauwkeurigheid maar bestraft legitieme API-gebaseerde publicatie niet.

Hoe ga je om met LinkedIn DM-follow-ups voor leadmagneten?

Dit is momenteel het handmatige knelpunt. LinkedIn's berichten-API vereist partnerschap-niveau toegang die niet beschikbaar is voor individuele ontwikkelaars. Ik reageer twee keer per dag in batches op leadmagneetverzoeken, wat in totaal ongeveer 10 minuten kost. Sommige bouwers gebruiken tools van derden met browserautomatisering voor deze stap, maar die aanpak brengt accountrisico met zich mee dat ik niet bereid ben te accepteren.

Laten we samenwerken

Wil je AI-systemen bouwen, workflows automatiseren of je technische infrastructuur opschalen? Ik help je graag.

• Fiverr (maatwerkoplossingen & integraties): fiverr.com/s/EgxYmWD
• Portfolio: mejba.me
• Ramlit Limited (enterprise-oplossingen): ramlit.com
• ColorPark (design & branding): colorpark.io
• xCyberSecurity (beveiligingsdiensten): xcybersecurity.io