DEV Community: Raphaël Pinson

Autism and the "genius" effect

Raphaël Pinson — Wed, 22 Apr 2026 06:25:00 +0000

This is the tenth post in my autism awareness month series.

When people think of autism, they often think of Rain Man or Sheldon Cooper. On one end, the severely affected person who needs full-time care. On the other, the socially awkward genius whose extraordinary abilities more than compensate. When I tell friends I am on the spectrum, I often hear: "But you don't look autistic."

Neither stereotype is wrong exactly. Both exist, but neither is representative. The vast middle is invisible, largely because it masks.

Before we go further, let's clarify on terminology. "Asperger's syndrome" is no longer a clinical diagnosis: it was folded into the single autism spectrum disorder classification in 2013. It was often used as shorthand for "high-functioning autistic," which is itself problematic, because functioning labels measure visibility of difficulty, not actual experience. The DSM-5 support levels measure required support, not intelligence, not severity of internal experience. A level 1 autistic person isn't mildly autistic. They're autistic in a way that currently requires less visible support, often because they've learned to compensate. That compensation has a cost that isn't measured.

Now, to address the genius question.

High IQ and autism are independent variables. Autism doesn't cause exceptional intelligence, and most autistic people don't have exceptional IQ. What is true though is that high-IQ autistic people are disproportionately visible: they function in professional environments, get diagnosed later, and are the face of autism in public discourse. The genius stereotype is largely a visibility problem.

What autism contributes, independently of IQ, is the constant information-gathering drive that I described two weeks ago in my fourth post. That drive never reaches a point of satisfaction. High IQ adds processing power to that endless process, producing denser cross-domain connections and stronger pattern recognition as a byproduct. The IQ doesn't change the drive. It simply amplifies the output.

But don't be fooled, this is a double-edged sword! The same wiring that produces unusual thinking also produces the exhaustion, the sensory overload, and the social friction described throughout this series. There is no version that keeps the upside and removes the cost. The consequences are real. But they're located in the mismatch between the wiring and the environment, not in a malfunction. And so the autistic people who seem the better socially adapted (through intellectual masking adjustments) are usually the ones experiencing the most anxiety as a result, and most likely to experience a burnout in their 30s or 40s.

In short: autism is not a cause of genius, but it can work as an amplifier for high throughput brains.

Next: on maintaining friendships, and what gets misread as manipulation.

This is part of my April 2026 autism awareness month series. First published on LinkedIn on 2026-04-22.

Building MCP Servers for Genealogy: AI-Powered Historical Research

Raphaël Pinson — Tue, 21 Apr 2026 16:58:46 +0000

For years now, I’ve been writing a book tracing four family branches across Europe, the Middle East, and South Africa. One thread follows Louis Rau, my 3rd great-uncle, who was president of Compagnie Continentale Edison (CCE) in the early 1900s. He was an Edison Pioneer, part of the inner circle that brought Edison's electrical systems to Europe.

Last year, I found that Thomas Edison's papers were digitized at Rutgers University. So I navigated to edisondigital.rutgers.edu, typed "Louis Rau" into the search box, and hit enter, and 847 results were returned.

Somewhere in those 847 documents was the correspondence that would explain Louis Rau's business relationship with Élie Moïse Léon, co-founder of CCE. Somewhere were the letters that traced his movements between Paris and Geneva. Somewhere were the details of CCE's electrical installations across Europe.

But I'd have to click through them one by one, read the snippets, open promising documents, cross-reference dates, take notes, come back later and forget which ones I'd already checked…

A few weeks ago, I started feeding genealogy documents to Claude AI, but that was still pretty tedious, and I kept hitting image upload limits in conversations. And then it clicked: why not build an MCP server, so Claude could perform the search directly?

That question became three MCP servers, a transformed research workflow, and a fundamentally different relationship with historical archives.

First Win: The Edison Papers MCP

The Edison Papers has an API. I didn't know that initially — I just knew they had a website with a search box. But a quick look at the network tab showed clean REST endpoints returning JSON.

I opened Claude Code and asked it to build an MCP server that wrapped the Edison Papers API. A few hours of iteration later, I had:

edison_search: Query with field-level precision (creator:"Rau, Louis", recipient:"Léon, Élie")
edison_get_document: Retrieve full metadata and transcriptions
edison_browse_series: Navigate document collections systematically
edison_get_images: Access high-resolution scans

raphink / edison-archive-mcp

MCP server for the Edison Archive

Edison Papers MCP Server

An MCP server for querying the Thomas A. Edison Papers (Rutgers University) — ~150,000 documents, public domain (CC0).

Tools

Tool	Description
`edison_search`	Full-text search by keyword, author, or recipient
`edison_get_document`	Fetch full metadata and transcription for a document by call number
`edison_browse_series`	List all documents in an archive series

Use with Claude.ai (hosted)

Deploy the server online so Claude.ai can connect to it via HTTP.

1. Deploy to Railway (free)

Push this repo to GitHub
Go to railway.app → New Project → Deploy from GitHub repo
Select your repo, then add this environment variable:
```
MCP_TRANSPORT = http
```
(PORT is set automatically by Railway)
Click Deploy (~2 minutes)
Go to Settings → Networking → Generate Domain to get your public URL

2. Connect to Claude.ai

Go to Claude.ai → Settings → Integrations → Add custom integration and enter:

https://your-app.up.railway.app/mcp

Use with Claude Desktop (local)

1. Install

…

View on GitHub

Now instead of clicking through 847 results, I could ask Claude:

"Find correspondence where Louis Rau is the creator, dated 1892-1895, mentioning electrical installations or Paris operations."

And Claude would orchestrate the full research pipeline:

Search: Call Edison Papers MCP → retrieve all matching results
Triage: Read all abstracts, decide which documents warrant full analysis
Track: Create a Notion database entry for each document with analysis status
Prioritize: Rank documents by relevance
Deep read: For priority documents, get high-resolution images and use OCR for full context
Summary: Provide a summary of all findings

What would have taken hours of manual clicking, note-taking, and cross-referencing now happens in one conversation.

This was immediately useful. But it surfaced a new problem: where do all these findings go?

The Organization Problem: Enter Notion MCP

I was already using Notion to organize my research: person profiles, document summaries, research questions. And Claude already had an MCP for Notion.

So now when I asked:

"Search Edison Papers for Louis Rau correspondence from 1892-1895, create a Notion page summarizing the findings, and link it to Louis Rau's profile."

Claude would:

Search: Call Edison Papers MCP → retrieve all matching results
Triage: Read all abstracts, decide which documents warrant full analysis
Track: Create a Notion database entry for each document with analysis status
Prioritize: Rank documents by relevance
Deep read: For priority documents, get high-resolution images and use OCR for full context
Document: Update Notion pages with findings
Connect: Update profile pages for people mentioned (Louis Rau, Élie Léon, etc.)

This was amazing. Structured knowledge, automatically organized, all in one conversation.

But then Claude started hallucinating.

The Hallucination Problem: Claude Needs Ground Truth

Claude would find documents mentioning for example Samuel Léon and Élie Léon, and confidently conclude that they that Samuel was Élie's nephew, completely making it up.

Or it would claim someone was born in 1847 when they were actually born in 1867. Dates off by decades. Family relationships invented wholesale.

The problem: Claude had access to documents (via Edison Papers MCP) and research notes (via Notion MCP), but not the actual genealogy data. It was inferring family structure from fragmentary mentions in letters and my incomplete notes.

I needed to give Claude access to the tree itself, the actual source of truth about who's related to whom and when they lived.

Attempt 1: GEDCOM MCP (Local)

My family tree lives in Geni — a collaborative genealogy platform to build a unique World family tree. Geni has an API, but OAuth kept failing when I tried it and I wanted something working now.

So I took a shortcut. From time to time, I export data from Geni to GEDCOM (the genealogy standard format), with about 25000 individuals in my export. I used airy10's GEDCOM MCP to make it queryable locally.

airy10 / GedcomMCP

MCP Server to create or query GEDCOM files

GEDCOM MCP Server

Genealogy for AI Agents, by AI Agents

A robust MCP server for creating, editing and querying genealogical data from GEDCOM files Works great with qwen-cli and gemini-cli

This project provides a comprehensive set of tools for AI agents to work with family history data enabling complex genealogical research, data analysis, and automated documentation generation.

The server has been recently improved with fixes for critical bugs, enhanced error handling, and better code quality while maintaining full backward compatibility.

Some sample complex prompts:

   Load gedcom "myfamily.ged"
   Make a complete, detailled biography of <name of some people from the GEDCOM> and his fammily. Use as much as you can from this genealogy, including any notes from him or his relatives
   You can try to find some info on Internet to complete the document, add some historical or geographic context, etc. Be as complete as possible to tell us a nice

…

View on GitHub

This worked! Now Claude could:

Search for individuals by name
Verify relationships ("Is X related to Y?")
Check birth/death dates
Trace lineage paths

No more hallucinated family connections. The GEDCOM became a hypothesis database, and claims in documents could be verified against known family structure.

Why Geni as my main database?

I use Geni instead of maintaining a private tree because genealogy is collaborative research. Multiple people contribute information, sources get peer-reviewed, duplicates get merged. A tree on Geni is a shared knowledge base, not siloed private data that might be duplicated (and wrong) across dozens of individual researchers' files.

But the GEDCOM approach had limitations:

It only works in Claude Desktop (local MCP)
It requires manually re-exporting GEDCOM whenever the tree updated
No access in claude.ai web sessions (or phone)

I needed the real API.

Back to Geni: Tackling OAuth

So I went back to the Geni API. A few more hours of iteration with Claude Code, and I had:

Full OAuth implementation (access tokens, refresh flow)
13 tools: profile CRUD, relationship pathfinding, merge candidate detection, family traversal
Search by name, verify relationships, trace lineage paths programmatically

raphink / geni-mcp

An MCP Server for Geni

geni-mcp

An MCP (Model Context Protocol) server that gives Claude access to Geni — the collaborative genealogy platform. Use Claude to browse, search, correct, and extend your family tree.

Features

Tool	Description
`get_authorization_url`	Start the OAuth flow — get the URL to authorize Claude
`exchange_code`	Complete OAuth — exchange the code for tokens
`get_my_profile`	Get your own Geni profile
`get_profile`	Look up any profile by ID
`update_profile`	Correct names, dates, locations, biography
`create_profile`	Add a new person to Geni
`get_immediate_family`	Get parents, siblings, spouses, children
`get_relationship_path`	Find relationship path between two profiles
`get_union`	Get a family unit (couple + children)
`add_relation`	Add a parent, child, sibling, or spouse
`search_profiles`	Search by name with optional birth/death filters
`get_merge_candidates`	Find potential duplicate profiles
`merge_profiles`	Merge a duplicate into a base profile

Prerequisites

A Geni account at geni.com
A registered Geni app — create one at geni.com/platform/developer/apps
Node.js 20+

Setup

1. Clone &

…

View on GitHub

Now I could ask mid-conversation: "Is Samuel Léon related to Élie Moïse Léon?" and get the relationship path instantly, whether I was in Claude Desktop or claude.ai.

The tree became queryable context accessible anywhere, not just on my local machine with an up-to-date GEDCOM file.

Third Server: Newspapers MCP

With Edison Papers and Geni working, I could trace business connections and verify family relationships. But I was still missing contemporary context: how did the public see these people? What did newspapers say about CCE's operations? Were there announcements, obituaries, social mentions?

Historical newspapers are digitized across dozens of national archives. Each has its own interface. Searching them all manually meant opening multiple websites, running the same query in different systems, downloading results individually.

So I built a newspapers MCP that:

Aggregates multiple national newspaper archives
Searches across collections simultaneously
Returns snippets as base64-encoded images (because OCR quality varies)

raphink / newspapers-mcp

Newspapers MCP Server

An MCP (Model Context Protocol) server for searching online newspaper archives across multiple countries and regions. This server provides unified access to newspaper collections from around the world through a single, standardized interface.

Supported Archives

Archive	Region	Source key	Full-text search	OCR text	Snippet images	API key
Europeana Collections	Europe (multi-country)	`europeana`	✅	✅	✅	Optional (get key)
Gallica (BnF)	France	`gallica`	✅	✅	✅	None
Deutsche Digitale Bibliothek	Germany	`ddb`	✅	—	✅	None
digiPress (BSB)	Germany / Bavaria	`digipress`	✅	✅	✅	None
ANNO (Austrian NL)	Austria / Austro-Hungarian Empire	`anno`	✅	✅	✅	None
Delpher (KB)	Netherlands	`delpher`	✅	✅	✅	None
Chronicling America (LoC)	United States	`chronicling_america`	✅	✅	✅	None
eLuxemburgensia (BnL)	Luxembourg	`eluxemburgensia`	✅	✅	✅	None
Trove (NLA)	Australia	`trove`	✅	✅	—	Required (free — get key)
Norwegian NL (nb.no)	Norway	`norwegian`	✅	—	—	None

…

View on GitHub

Here’s a real example:

I asked Claude to search for "Joseph Dreyfus grain Paris 1895" (a grain merchant in the family who had a financial collapse). The MCP found the concordataire liquidation announcement in French commercial journals. That single search led to discovering a 90-page Archives de Paris dossier (D14U³/89) I'm still analyzing.

One search. Ten minutes. What would have been days of archive website navigation.

How They Work Together: Finding Solomon Rau in Munich

Here's a recent example showing how the MCPs orchestrate together:

I asked Claude to search for Solomon Rau's activity in Munich newspapers. The newspapers MCP returned various results, including this advertisement:

This ad showed Solomon Rau advertising the reimbursement of DDSG (Danube Steam Shipping Company) stock — a discovery that:

Revealed his business activity (financial/stock trading)
Connected him to DDSG, a major shipping company
Provided a concrete date and location (Munich)
Led to further discoveries about other family members' activities

Claude then cross-referenced this against the Geni tree to verify Solomon's identity and relationships, and documented the finding in Notion with the newspaper snippet as a source.

It then correlated it to the DDSG stock that Adolphe Grünberg, Solomon’s son-in-law, had in his post-mortem inventory the next year in 1878, and added another note there.

Have you built AI integration for research yourself? What were your best findings?

When authority doesn't compute

Raphaël Pinson — Mon, 20 Apr 2026 06:50:00 +0000

This is the ninth post in my autism awareness month series.

In the previous post, I described the autistic person who looks at you and smiles while you wait for them to comply with something they know they have to do and simply won't. Part of what produces that smile is the absence of spontaneous facial mimicry. But there's something else behind it: the submission reflex that isn't there.

For most people, deference to authority is not primarily a conscious decision. It's a conditioned reflex: the body responds before the mind deliberates. Lowered gaze, softened posture, adjusted tone. These happen automatically, as a result of social conditioning that accumulates from early childhood.

The autistic brain doesn't register this reflex. Not because the social training wasn't there — it often was, extensively. But no amount of training installs a reflex the nervous system doesn't have a slot for. What training produces instead is anxiety: the awareness of doing it wrong, knowing consequences are coming, but no access to the expected behavior. The performance isn't available, only the awareness of its absence is.

This is why "just learn to respect authority" doesn't work as an instruction. The target behavior isn't a choice being withheld — it's a reflex that isn't firing. Authority without reason doesn't register as authority. It registers as an unsupported assertion, and connects directly to the previous post: the brain that won't perform a task without a valid reason also won't defer to a person without one. Same mechanism, different domain.

There is an emotional cost associated to this, though it surfaces later rather than in the moment. During a high-load confrontation, the autistic brain is fully occupied processing the external situation. Emotional processing gets deferred. When it finally surfaces — sometimes hours later — it attaches to whatever small thing is happening then. A minor frustration, something completely trivial. The reaction looks disproportionate — such as tears or rage. The connection to the original cause is invisible to everyone watching because of the delay.

This pattern is particularly visible in children. Most high functioning autistic adults learn over time to defer emotional processing to private moments, but the cost is still there. In undiagnosed adults, these accumulated costs are frequently misread as depression or anxiety, and sometimes treated as such, with interventions that can inadvertently make things worse.

Understanding the underlying mechanism changes what help actually looks like. I'll cover that more fully in the last post of this series. In the meantime, if any of this resonates, feel free to DM me.

This is part of my April 2026 autism awareness month series. First published on LinkedIn on 2026-04-20.

Tasks that don't make sense

Raphaël Pinson — Fri, 17 Apr 2026 08:15:00 +0000

This is the eighth post in my autism awareness month series.

There's a pattern many autistic people recognize but rarely name: the inability to perform tasks that don't make sense. Not tasks that are hard, or unpleasant, or boring, but tasks whose purpose doesn't compute.

This is different from procrastination. Procrastination is knowing you should do something and not doing it. What happens here is closer to a blank: the brain doesn't engage because it hasn't received a valid reason to.

I studied medicine for two years. My friends would put in ten-hour study days without question, and I couldn't get myself to do the same, not because I was exhausted or distracted, but because the task simply wouldn't engage. When I asked one of them why she worked so hard, she said: because my parents want me to be a doctor. There was no way my brain would let my body work that hard for that reason. It wasn't laziness, I can work intensely when things make sense. The engine just wouldn't start for this.

The same pattern shows up anywhere social pressure substitutes for genuine reason: everyone else is doing it, you have no choice. Those don't satisfy the brain's actual question: what is the purpose of this, in terms I can evaluate?

When that answer isn't there, the block isn't reluctance or stubbornness, it's closer to turning the key in a car with no engine. The action is available, the result isn't. What pushing harder produces is something between frustration and despair: the feeling of wanting to move, making the effort, and finding that nothing responds. The will is there. The compliance isn't available. From the outside it looks exactly like not trying.

And what the observer sees often makes things worse. The autistic person may just look at you and smile, while you wait for them to do something they know they have to do and simply won't. The smile isn't defiance, it's the combined result of two absent automatic systems: the spontaneous facial mimicry that would normally adjust your expression to match the gravity of the situation, and the conscious control over that expression, which isn't available because the brain is already occupied with the block itself.

There's a strength in this though. The same trait that makes arbitrary tasks impossible makes unnecessary complexity visible. The person who keeps asking "why are we doing this?" in a process review is often the one who finds the actual bottleneck.

That smile I mentioned above, and what it looks like when authority meets a brain that doesn't have a submission reflex, will be the topic of the next post.

This is part of my April 2026 autism awareness month series. First published on LinkedIn on 2026-04-17.

The filter that isn't running

Raphaël Pinson — Wed, 15 Apr 2026 06:30:00 +0000

This is the seventh post in my autism awareness month series.

Last week, in a shop, the music felt loud. It wasn't painful to my ears at all. But it felt like a violation of my mind, occupying space I needed for thinking. I couldn't form a coherent thought. Part of me wanted to scream for it to stop. Instead I chose to step outside.

That's not a metaphor. That's what happened.

Here's why. Neurotypical auditory processing includes an automatic attention filter, the brain selects what to process and suppresses the rest. It's why you can follow one conversation in a noisy room, why background music stays in the background. The cocktail party effect. The filter runs without effort or awareness.

The autistic brain doesn't apply this filter the same way. Everything comes in at full processing weight. Not louder, just unfiltered. My wife could sit in the same shop and simply not notice the music after a few minutes. Not because she was trying to ignore it. Because her brain filed it as background and moved on. Mine didn't.

This is why "just ignore it" doesn't work as advice. You can't consciously override a central processing response. The sensation isn't at the ear, it's downstream, in what the brain does with the signal. Earplugs help with some sounds but not others, because the problem isn't always volume. Loop earplugs, which I've tried, turned the music into a muffled ASMR mess, a different problem, not a solution.

The whispering from the previous post fits here too. When I asked my family to speak more quietly, they whispered. That made it worse, because whispering is harder to pay attention to, not easier. The problem wasn't loudness, it was simultaneous signals at full weight, and whispering added effort on top of the load.

And it's not just sound. The same mechanism applies to any sensory input: touch, light, heat, and less obviously, physical discomfort from hunger, illness, or food sensitivities. My son finds heat the most unbearable. Not because his body overheats differently, but because the thermal signal competes for processing at the same weight as everything else. Once, as a child, he was outside upset because he was hot. My wife told him to get out of the sun. He kept saying he was hot. Moving wouldn't have helped immediately, the signal was already inside, already being processed. The brain doesn't flush on command.

The same logic applies to diet. Removing dairy helped my son noticeably, not because dairy causes autism, but because a food sensitivity generates internal signals that an unfiltered system has to process. Managing unnecessary inputs is load management, removing them helps with sensory overload. The wiring stays the same. You're just giving it less to handle.

Next: when the brain won't comply.

This is part of my April 2026 autism awareness month series. First published on LinkedIn on 2026-04-15.

When the sensory threshold moves

Raphaël Pinson — Mon, 13 Apr 2026 07:53:00 +0000

This is the sixth post in my autism awareness month series. The previous ones tried to explain mechanisms. This one is harder to write, because it's about a typical evening at the dinner table.

A reader commented on post 3 that the color blindness analogy has a limit: color blindness doesn't fluctuate with how you're feeling or what's happening around you. She's right, and autism does.

The sensory threshold isn't fixed. It doesn't move day to day. It can move minute to minute. The same sound that was fine an hour ago becomes unbearable. The same touch from the same person that felt fine yesterday is suddenly intolerable. Not because something changed externally, but because the internal load crossed a line that isn't visible from the outside.

Here's what that looks like in practice. I'm at dinner with my family. A normal dinner, with normal quiet conversations between two adults and four children. At some point the noise becomes too much: multiple conversations, overlapping voices, a specific pitch. I ask everyone to speak a bit lower, or one at a time. They try to help: they start whispering. This actually makes it worse, because whispering is a different frequency problem, not a volume problem. So I ask again, more precisely this time. Now I'm the one enforcing rules on everyone for what looks like no good reason. I don't want to leave, as I'm genuinely interested in what's happening, and leaving would be rude. So I stay. And eventually I reach a point where I simply can't continue, and I leave the table, not dramatically, but not quietly either, because by that point I've already absorbed more than the system can handle.

From the outside it looks like an overreaction to nothing. There's no visibly valid reason for me to be upset about the situation. The buildup was invisible.

The coping strategies most of us have learned — don't leave abruptly, stay engaged, don't make others uncomfortable — are exactly the ones that prevent the only real regulation option available in the moment. The polite thing and the functional thing are in direct conflict. And we've been trained, often the hard way, to choose polite.

Over time, extended periods of this produce what's called autistic burnout. Not laziness, not mood. A system that has been running above capacity for too long and needs to shut down. For many highly functional autistic people, it often kicks in their 40s, after decades of invisibly costly adjustment.

Which raises a question: why does the same sound feel fine one moment and unbearable the next? That's what the next post is about.

This is part of my April 2026 autism awareness month series. First published on LinkedIn on 2026-04-10.

More autism in IT?

Raphaël Pinson — Fri, 10 Apr 2026 07:34:00 +0000

This is the fifth post in a series for autism awareness month.

Three years ago, I created a channel called #autism on my company's Slack. I wasn't sure what to expect. On the first day, about 20 people joined, roughly one in six of the company at the time. Four personal testimonies came in within hours. Dozens more wanted to understand better. I later renamed it #neurodiversity to be more encompassing.

That wasn't a trend. That was a room full of people who had been waiting for the door to open.
So: is there more autism in IT? Or does IT just make it easier to be autistic?
Probably both, and they're not contradictory.

My wife worked for years as a psychologist with autistic children. Shortly after our second child was born, she started noticing patterns in him that she recognized professionally. It took ten years to get a formal diagnosis. When the psychiatrist finally explained why our son was on the spectrum, I remember thinking: he's describing me.

That's not an unusual story. Autism has a well-documented genetic component. Autistic people are more likely to have autistic children, and certain fields, IT among them, have been quietly concentrating people with this neurological profile for decades. Long before most of them had a name for it.

The cognitive traits that make social navigation harder — needing explicit structure, struggling with unspoken rules, finding small talk costly — are often the same traits that make technical work easier. Pattern recognition, deep focus on narrow problems, a preference for systems that behave predictably, a low tolerance for ambiguity that, in code, is actually a feature.

IT didn't create more autistic people. It created conditions where autistic people could function, contribute, and sometimes thrive — without anyone necessarily noticing why. The diagnosis rates are rising because awareness is rising, not because something new is happening.

Next Monday, I'll post about sensory overload and autistic burnout.

This is part of my April 2026 autism awareness month series. First published on LinkedIn on 2026-04-10.

The constant background hum

Raphaël Pinson — Thu, 09 Apr 2026 16:52:00 +0000

This is the fourth post in a series for autism awareness month. Previous posts covered the neurological vs. psychological distinction and what "spectrum" actually means. This week: what runs in the background, all the time.

My mother often reminds me that when I was a child visiting friends, I would tour every room and every corner of their apartment before I could sit down and play. I had no idea I was doing it. I just couldn't settle until I had a complete map.
That pattern never went away.

There's a well-documented phenomenon in autism research called intolerance of uncertainty (IU): the nervous system's difficulty tolerating absent information. The research links it directly to how the autistic brain builds predictions: less automatically, less reliably than in neurotypical brains. The result is a system that needs more explicit data to feel oriented. So it collects data, constantly.

Everyone experiences some anxiety about the unknown. The difference in autism is in the mechanism and the scale. For me, the information-gathering isn't occasional, it's continuous, and it isn't very selective. Any piece of information feels potentially vital. If someone mentions an actor I don't recognize, I need to know who that is. Not out of curiosity, but because there might be a joke about that actor later. Everyone will laugh. I won't follow. And unlike most social awkwardness, I can't fake it convincingly without the underlying data. The gap isn't uncomfortable, it's a predicted failure.

This is what produces the constant background hum: not anxiety about anything specific, but the nervous system permanently scanning for gaps in the map, because any gap is a potential trapdoor.

Special interests are the inverse of this. A domain I know deeply is a domain with no trapdoors. The intensity and relief that come with a special interest aren't enthusiasm, they're the feeling of ground that holds. Talking about it at length isn't ignoring the other person, it's the only moment the scanning stops.

There is an upside to all this collecting though. A brain that has spent decades gathering fragments from unrelated domains ends up with an unusually dense web of cross-references. When something new appears, it rarely arrives in isolation: the system has already indexed something adjacent, something that rhymes, something from three fields over. Pattern recognition and unexpected correlations come almost automatically, not as a skill but as a byproduct of the constant scan. We'll talk more about that in a following post on STEM and IT.

This is part of my April 2026 autism awareness month series. First published on LinkedIn on 2026-04-09.

What "autistic spectrum" actually means

Raphaël Pinson — Thu, 09 Apr 2026 16:48:00 +0000

Last week, I wrote about the difference between a psychological trait and a neurological one, and why autism sits firmly in the second category. This week I want to address something that makes that distinction harder to see: a widespread misconception about what "spectrum" means in the context of autism.

Most people hear "autism spectrum" and picture a line. At one end, severe autism. At the other, neurotypical. Somewhere in the middle, people like me: a little autistic, but mostly fine. The spectrum as a gradient, a dial you can turn up or down.

That's not what it means. Here's an analogy that I find clarifying, using vision 👓.

Most people have some degree of myopia. It's very common, it exists on a continuous scale, and crucially, it's fixable. Glasses, contact lenses, laser surgery. You correct the optics, the problem goes away. Myopia is a vertical spectrum: more or less of the same thing, with a clear correction available.

Color blindness works differently. It's not that color blind people see less color than everyone else, instead they process color through a different configuration of receptors. There's no dial connecting their vision to standard vision. It's a horizontal spectrum: many different ways of being color blind, each with its own profile, none of them simply "less" than normal. And critically, you can't correct it. You can't give someone new cone receptors. What you can do is design the world differently: accessible interfaces, patterns alongside colors, signage that doesn't rely on red-green distinction alone.

Autism is more like color blindness than myopia.

The spectrum in autism isn't a scale from "a bit autistic" to "very autistic" with neurotypical at zero. It's a range of different neurological profiles, all sharing the same underlying difference in how the brain processes certain things — social signals, sensory input, pattern and context — but expressing that difference in very different ways. Some people are overwhelmed by noise; others seek it. Some struggle with eye contact; others make too much. Some have significant language delays; others are relentlessly verbal. Same underlying configuration, very different presentations.

And like color blindness, it's not correctable — only compensable. You can learn strategies, build workarounds, train yourself to recognize patterns you don't process automatically. Many of us do, invisibly, for years. But you're not fixing the wiring. You're working around it.

Autism asks for the same shift as color blindness. Not "how do we correct this person" but "how do we design interactions, workplaces, and social environments that don't rely exclusively on automatic social processing that not everyone has."

That's not a lowering of standards. It's a more accurate picture of human variation.

This is part of my April 2026 autism awareness month series. First published on LinkedIn on 2026-04-07.

Quirk or wiring?

Raphaël Pinson — Thu, 09 Apr 2026 16:45:00 +0000

April is autism awareness month. Yesterday, I posted a comic strip about navigating social situations as an autistic person. I want to spend this month going deeper, with regular posts on experiencing autism.

A good place to start is the difference between a psychological trait and a neurological one.

A lot of autistic experiences look like personality traits from the outside. Introversion. Shyness. Social awkwardness. These are things many people relate to, and that relatability is both a bridge and a trap. It creates the impression we're talking about the same thing, just more so. They are also not helped by the common misconception that 'spectrum' means a "vertical" scale from normal to autistic, rather than a "horizontal" one within the neurological condition of autism.

My wife has transverse myelitis, a condition where the myelin sheath around the spinal cord degrades, disrupting nerve signals. The result: both motor and sensory pathways are affected, and the automatic reflex arc that normally catches you when you stumble overreacts and causes her to fall. Everybody trips. Most people catch themselves without thinking. She doesn't have that fallback. She can scan the ground, plan every step, and still fall, because the pebble she didn't see hits a system that can no longer compensate automatically. The effort is real, the safety net is not present, and the fall unavoidable.

Autism works on a different system — social cognition rather than motor control — but the structure is the same. Everybody has awkward social moments. Most people recover instinctively, the automatic social circuitry recalibrates. That fallback is what I don't have reliably. I can prepare, study the signals, pay close attention, and still miss something obvious to everyone else, because it happened in a channel I'm not wired to process automatically.

The exhaustion isn't from interacting. It's from running manual what most people run on autopilot.

And here's the point that matters: my wife's myelin isn't going to grow back. Physiotherapy helps. A cane helps with balance. But they're compensations for something that isn't there, not a cure for something that went wrong. Autism is the same. You can learn strategies, build workarounds, develop compensations, and many of us do, invisibly, for decades. But you're not fixing the wiring. You're working around it.

When relating to autistic people, don't assume similar external signs mean the same internal experience and causes. Ask, and be surprised by what you'll find.

This is part of my April 2026 autism awareness month series. First published on LinkedIn on 2026-04-03.

Improvisation on the Spectrum

Raphaël Pinson — Thu, 09 Apr 2026 16:36:00 +0000

As you may know, this month is autism awareness month.

Many things will be posted about autism, and I'd like to share one: a little comic strip I made in July last year, in an attempt to capture of one many invisible quirks in the daily life of an autistic person.

‹ ›

This is the first of a series of posts on autism that I will be posting this month.

This is part of my April 2026 autism awareness month series. First published on LinkedIn on 2026-04-02.

How to Automatically Issue Badges for Instruqt Labs

Raphaël Pinson — Thu, 17 Oct 2024 09:00:00 +0000

In the first blog post, we talked about making labs fun and enjoyable by adding elements of gamification. Issuing badges is a fantastic way to motivate learners, giving them a sense of accomplishment for the skills they've gained, and Isovalent issues hundreds of them every month for the Cilium labs!

Issuing Credentials

Obviously, issuing badges can be done manually, but this is not scalable or ideal for creating a seamless experience. So, let's automate it!

Credly is a widely recognized provider of digital badges, so we will be using this solution to issue badges whenever a user finishes an Instruqt lab.

We'll be using Instruqt webhooks, coupled with the Credly API, to automatically issue badges when labs are completed.

And thanks to Isovalent's open-sourced Go libraries for both Instruqt and Credly APIs, you will find this automation process smooth and straightforward.

isovalent / instruqt-go

A Go library for the Instruqt API

instruqt-go

instruqt-go is a Go client library for interacting with the Instruqt platform. It provides a simple and convenient way to programmatically access Instruqt's APIs, manage content, retrieve user data and track information.

Features

Manage Instruqt Teams and Challenges: Retrieve team information, challenges, and user progress.

Installation

To install the instruqt-go library, run:

go get github.com/isovalent/instruqt-go

Example Usage

package main
import (
    "github.com/isovalent/instruqt-go/instruqt"
    "cloud.google.com/go/logging"
)

func main() {
    // Initialize the Instruqt client
    client := instruqt.NewClient("your-api-token", "your-team-slug")

    // Get all tracks
    tracks, err := client.GetTracks()

    // Add context to calls
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    
    clientWithTimeout := client.WithContext(ctx)
    userInfo, err := clientWithTimeout.GetUserInfo("user-id")

    // Attach a logger
    logClient, err := logging

…

View on GitHub

isovalent / credly-go

A Go library for the Credly API

credly-go

credly-go is a Go client library for interacting with the Credly platform. It provides a simple and convenient way to programmatically access Credly's APIs and handle badges and templates.

Features

Badge Management: Issue, retrieve, and manage badges using the Credly API.

Installation

To install the credly-go library, run:

go get github.com/isovalent/credly-go

Example Usage

package main

import (
    "github.com/isovalent/credly-go/credly"
)

func main() {
    // Initialize the Credly client
    client := credly.NewClient("your-api-token", "your-credly-org")

    // Get all badges for user joe@example.com
    badges, err := client.GetBadges("joe@example.com")
}

Contributing

We welcome contributions! Please follow these steps to contribute:

Fork the repository.
Create a new branch with your feature or bug fix.
Make your changes and add tests.
Submit a pull request with a detailed description of your changes.

Running Tests

To run the tests, use:

go test ./...

Make sure…

View on GitHub

Overview

In this post, we'll take you step by step through the process:

Setting up the environment and harnessing Google Cloud Functions.
Initializing imports, constants, and setting up secret environment variables.
Implementing the webhook and explaining each step.
Setting up the webhook in Instruqt and adding signature verification to secure it.
Testing locally using Docker and Docker Compose.
Deploying the webhook and required secrets to Google Cloud Platform.
Wrapping up with some final considerations.

Let's dive in!

Pre-requisites

As for the first blog post, you will need an Instruqt account (with an API key) and a Google Cloud project.

In addition, you will also need a Credly account with an API key this time.

Setting Up the Environment

First, create a directory for your function and initialize the Go environment.

mkdir instruqt-webhook
cd instruqt-webhook

go mod init example.com/labs

Just as in the first post, we create a cmd directory so we can build and test the function locally:

mkdir cmd

Create a main.go file in that directory, with the following content:

package main

import (
    "log"
    "os"

    // Blank-import the function package so the init() runs
    // Adapt if you replaced example.com earlier
    _ "example.com/labs"

    "github.com/GoogleCloudPlatform/functions-framework-go/funcframework"
)

func main() {
    // Use PORT environment variable, or default to 8080.
    port := "8080"
    if envPort := os.Getenv("PORT"); envPort != "" {
        port = envPort
    }
    if err := funcframework.Start(port); err != nil {
        log.Fatalf("funcframework.Start: %v\n", err)
    }
}

Back to the instruqt-webhook directory, create a file named webhook.go to contain the function logic. This file will serve as the webhook handler for incoming events from Instruqt.

Setting Up the Basics

In webhook.go, begin by adding the necessary imports, constants, and initializing the function:

package labs

import (
    "fmt"
    "net/http"
    "os"
    "strings"

    "github.com/GoogleCloudPlatform/functions-framework-go/functions"

    "github.com/isovalent/instruqt-go/instruqt"
    "github.com/isovalent/credly-go/credly"

)

func init() {
    functions.HTTP("InstruqtWebhookCatch", instruqtWebhookCatch)
}

const (
    instruqtTeam = "yourInstruqtTeam"   // Replace with your own team name
    credlyOrg    = "yourCredlyOrg"      // Replace with your own credly organization ID
)

Implementing the Webhook Receiver

Now, let's write the instruqtWebhookCatch function to receive the event.

We will take advantage of the methods provided by the Isovalent instruqt-go library to manage the Instruqt webhook:

func instruqtWebhookCatch(w http.ResponseWriter, r *http.Request) {
    webhookSecret := os.Getenv("INSTRUQT_WEBHOOK_SECRET")
    wbHandler := instruqt.HandleWebhook(processWebhook, webhookSecret)
    wbHandler(w, r)
}

This function works as a proxy between the HTTP connection handler provided by the Google Cloud Functions framework and the instruqt.HandleWebhook method provided by Isovalent's library to manage the Svix webhook.

It allows us to set up a webhook manager by passing the webhook's secret. We will see later where to find the value for the webhook secret.

The instruqt.HandleWebhook method will automatically:

Verify the webhook signature using svix.
Parse the incoming event payload.
Check if the event is valid.
Retrieve the information into an instruqt.WebhookEvent structure.

Step 4: The `processWebhook()` Function

Next, we need to implement the processWebhook function, where our logic will be placed.

This function will receive 3 parameters:

the HTTP connection handlers (http.ResponseWriter and *http.Request) inherited from the GCP Function handler;
the instruqt.Webhook structure parsed by instruqt.HandleWebhook and passed down to us.

Here's the complete implementation:

func processWebhook(w http.ResponseWriter, r *http.Request, webhook instruqt.WebhookEvent) (err error) {
    // Return early if the event type is not track.completed
    if webhook.Type != "track.completed" {
        w.WriteHeader(http.StatusNoContent)
        return
    }

    // Setup the Instruqt client
    instruqtToken := os.Getenv("INSTRUQT_TOKEN")
    if instruqtToken == "" {
        w.WriteHeader(http.StatusInternalServerError)
        return
    }
    instruqtClient := instruqt.NewClient(instruqtToken, instruqtTeam)

    // Setup the Credly client
    credlyToken := os.Getenv("CREDLY_TOKEN")
    if credlyToken == "" {
        w.WriteHeader(http.StatusInternalServerError)
        return
    }
    credlyClient := credly.NewClient(credlyToken, credlyOrg)

    // Get user info from Instruqt
    user, err := instruqtClient.GetUserInfo(webhook.UserId)
    if err != nil {
        fmt.Printf("Failed to get user info: %v", err)
        w.WriteHeader(http.StatusInternalServerError)
        return
    }

    // Get track details to extract badge template ID from tags
    track, err := instruqtClient.GetTrackById(webhook.TrackId)
    if err != nil {
        fmt.Printf("Failed to get track info: %v", err)
        w.WriteHeader(http.StatusInternalServerError)
        return
    }

    // Extract badge template ID from track tags
    var templateId string
    for _, tag := range track.TrackTags {
        // Use strings.Split to parse the tag and extract the badge template ID
        parts := strings.Split(tag.Value, ":")
        if len(parts) == 2 && parts[0] == "badge" {
            templateId = parts[1]
            break
        }
    }

    if templateId == "" {
        fmt.Printf("No badge template ID found for track %s", webhook.TrackId)
        w.WriteHeader(http.StatusBadRequest)
        return
    }

    // Issue badge through Credly
    _, badgeErr := credlyClient.IssueBadge(templateId, user.Email, user.FirstName, user.LastName)
    // Check if the badge has already been issued
    if badgeErr != nil {
        if strings.Contains(badgeErr.Error(), credly.ErrBadgeAlreadyIssued) {
            fmt.Printf("Badge already issued for %s", user.Email)
            w.WriteHeader(http.StatusConflict)
            return
        }
        fmt.Printf("Failed to issue badge: %v", badgeErr)
        w.WriteHeader(http.StatusInternalServerError)
        return
    }

    w.WriteHeader(http.StatusOK)
    return
}

This function does the following:

Check if the event is of type track.completed, exit otherwise.
Instantiate Instruqt and Credly clients using environment variables for the tokens.
Retrieve user information from the Instruqt API. This requires to ensure that Instruqt has that information. See the first blog post to find how to do that with a proxy.
Get track information from Instruqt. We will use set a badge: special tag on the track to store the Credly badge ID to issue.
Parse track tags to find the badge template ID.
Issue the badge using the Credly library.

Setting Up the Webhook on Instruqt

To enable Instruqt to call your webhook, navigate to the Instruqt UI, go to Settings -> Webhooks, and click "Add Endpoint" to set up a new webhook that points to your Google Cloud Function URL.

Select track.completed in the list of events to fire up this endpoint.

Since we'll be hosting the function on Google Cloud Functions, the URL will be in the form https://<zone>-<project>.cloudfunctions.net/<name>. For example, if your function is called instruqt-webhook and is deployed in the labs GCP project in the europe-west1 zone, then the URL will be https://europe-west1-labs.cloudfunctions.net/instruqt-webhook. If in doubt, put a fake URL and you can modify it later.

Create "Create", then locate the "Signing secret" field to the right side of the panel and copy its value.

Export it in your terminal as the INSTRUQT_WEBHOOK_SECRET value:

export INSTRUQT_WEBHHOOK_SECRET=whsec_v/somevalueCopiedFromUi

Then use it to create a new GCP secret called instruqt-webhook-secret:

echo -n "$INSTRUQT_WEBHHOOK_SECRET" | gcloud secrets create instruqt-webhook-secret --data-file=-

Give it the proper permissions to be usable in your function (see first blog post for details):

PROJECT_NUMBER=$(gcloud projects describe $(gcloud config get-value project) --format="value(projectNumber)")
gcloud secrets add-iam-policy-binding instruqt-webhook-secret \
    --member="serviceAccount:${PROJECT_NUMBER}-compute@developer.gserviceaccount.com" \
    --role="roles/secretmanager.secretAccessor"

Also create a secret for your Credly token:

export CREDLY_TOKEN=yourCredlyToken
echo -n "$CREDLY_TOKEN" | gcloud secrets create credly-token --data-file=-
gcloud secrets add-iam-policy-binding credly-token \
    --member="serviceAccount:${PROJECT_NUMBER}-compute@developer.gserviceaccount.com" \
    --role="roles/secretmanager.secretAccessor"

Testing the Code

Let's check that this function builds and runs fine.

First, update your go.mod and go.sum files with:

go get ./...
go mod tidy

Now, run the function:

FUNCTION_TARGET=InstruqtWebhookCatch go run ./cmd/main.go

The function should compile and run fine. You can try sending queries to it on localhost:8080:

curl -i localhost:8080

Expect to get an error since the Svix webhook authentication is not set up properly in the payload:

HTTP/1.1 405 Method Not Allowed
Content-Type: text/plain; charset=utf-8
X-Content-Type-Options: nosniff
Date: Tue, 08 Oct 2024 13:20:47 GMT
Content-Length: 23

Invalid request method

It would be possible to emulate this, but it's a bit complex, so let's just deploy to GCP now!

Alternative testing: using Docker

If you'd like to use Docker to test your function locally, you can create a Dockerfile in your current directory:

FROM golang:1.23

WORKDIR /app

COPY . .

RUN go build -o myapp ./cmd/main.go

ENV DEV=true
ENV PORT=8080

EXPOSE $PORT

CMD ["./myapp"]

Add a docker-compose.yaml file:

version: '3'
services:
  proxy:
    build: ./
    ports:
      - "8080:8080"
    environment:
      INSTRUQT_WEBHOOK_SECRET: ${INSTRUQT_WEBHOOK_SECRET}
      INSTRUQT_TOKEN: ${INSTRUQT_TOKEN}
      CREDLY_TOKEN: ${CREDLY_TOKEN}
      FUNCTION_TARGET: InstruqtWebhookCatch

Finally, build and launch your container:

docker-compose up --build

And you can send requests to localhost:8080 just the same as before!

Deploy the Function

You can then deploy the function (adapt the region if needed), giving it access to all three secret values:

gcloud functions deploy "instruqt-webhook" \
  --gen2 --runtime=go122 --region=europe-west1 --source=. \
  --entry-point="InstruqtWebhookCatch" --trigger-http --allow-unauthenticated \
  --set-secrets="INSTRUQT_WEBHOOK_SECRET=instruqt-webhook-secret:latest" \
  --set-secrets="INSTRUQT_TOKEN=instruqt-token:latest" \
  --set-secrets="CREDLY_TOKEN=credly-token:latest"

This will upload and build your project, and return the URL to access the function.

If necessary, update the URL in your Instruqt webhook configuration.

Testing

Now for the moment of truth: testing!

Create a badge on Credly. Publish it and copy its template ID.
Add a tag to the Instruqt track you want to associate the badge with. Name the tag badge:<template_ID>, replacing template_ID with the ID you just copied.
Publish the track.
Take the track and complete it!

You should get the badge in your email!

Further Considerations

User Information: Make sure you read the first blog post to understand how to send user information to Instruqt.
Make it worth it!: Getting badges is fun, but it's better if users deserve them. Consider adding exam steps to your tracks to make earning the badges a challenge.
Rate Limiting and Retries: Consider rate limiting incoming webhook requests to prevent abuse and adding retry logic to handle temporary failures when interacting with Credly.
Manage more Events: This webhook manager only manages track.completed events. You can extend it to do a lot more things with all the events provided by Instruqt! I typically like to capture lots of events to send them to Slack for better visibility.
Logs: Consider adding more logging (for example using the GCP logging library) to the code.

DEV Community: Raphaël Pinson

Autism and the "genius" effect

Building MCP Servers for Genealogy: AI-Powered Historical Research

First Win: The Edison Papers MCP

raphink / edison-archive-mcp

MCP server for the Edison Archive

Edison Papers MCP Server

Tools

Use with Claude.ai (hosted)

1. Deploy to Railway (free)

2. Connect to Claude.ai

Use with Claude Desktop (local)

1. Install

The Organization Problem: Enter Notion MCP

The Hallucination Problem: Claude Needs Ground Truth

Attempt 1: GEDCOM MCP (Local)

airy10 / GedcomMCP

MCP Server to create or query GEDCOM files

GEDCOM MCP Server

Back to Geni: Tackling OAuth

raphink / geni-mcp

An MCP Server for Geni

geni-mcp

Features

Prerequisites

Setup

1. Clone &

Third Server: Newspapers MCP

raphink / newspapers-mcp

Newspapers MCP Server

Supported Archives

How They Work Together: Finding Solomon Rau in Munich

When authority doesn't compute

Tasks that don't make sense

The filter that isn't running

When the sensory threshold moves

More autism in IT?

The constant background hum

What "autistic spectrum" actually means

Quirk or wiring?

Improvisation on the Spectrum

How to Automatically Issue Badges for Instruqt Labs

Issuing Credentials

isovalent / instruqt-go

A Go library for the Instruqt API

instruqt-go

Features

Installation

Example Usage

isovalent / credly-go

A Go library for the Credly API

credly-go

Features

Installation

Example Usage

Contributing

Running Tests

Overview

Pre-requisites

Setting Up the Environment

Setting Up the Basics

Implementing the Webhook Receiver

Step 4: The processWebhook() Function

Setting Up the Webhook on Instruqt

Testing the Code

Alternative testing: using Docker

Deploy the Function

Testing

Further Considerations

Step 4: The `processWebhook()` Function