I need to be honest about something: I was scared to contribute to open source.
I know how that sounds. I’ve been writing code for years. I’ve shipped production apps. I have repos with real users and real test suites and real deployment pipelines. By every objective measure, I’m a competent software engineer.
But “competent software engineer” and “person who believes they’re competent” are two very different things. Especially when your brain is wired the way mine is.
Who I Actually Am
I’m autistic. I have ADHD. I’m saying that up front because it’s not a footnote — it’s the operating system. Everything else runs on top of it.
The autism gives me pattern recognition that borders on compulsive. I don’t just notice patterns — I can’t not notice them. When I’m reading minified JavaScript at midnight trying to figure out why a regex stopped matching, my brain is doing that thing where it’s already rearranging the symbols before I’ve consciously decided to look. Code makes sense to me in a way that conversations often don’t. Structure, logic, deterministic behavior — that’s my native language.
The ADHD gives me hyperfocus. When something clicks, I don’t work on it — I become it. I started building an astronomy app on December 23rd because I wanted to know what was in the sky that night. Within a couple of days I had a working CLI. Within a week, a basic site. A few weeks later — a complete dashboard with observation logging, Messier catalog tracking, ISS pass predictions, and offline support. 103 Python tests. 206 frontend tests. The whole thing isn’t even two months old. I’d regularly look up from my editor and realize I hadn’t eaten all day. Not “forgot lunch” — forgot food as a concept. That’s what hyperfocus actually looks like. It’s not a productivity hack. It’s your brain deciding that this one thing is the only thing that exists right now, and everything else — hunger, sleep, the passage of time — just stops registering.
Together, the autism and ADHD make me very good at solving problems and absolutely terrible at believing I’m allowed to.
That’s the part nobody warns you about. You can be objectively capable and still have a brain that’s running a background process 24/7 whispering “you’re not good enough, they’re going to find out, everyone else knows what they’re doing and you’re just pretending.” Rejection Sensitive Dysphoria isn’t a personality quirk — it’s a constant negotiation between what you know and what you feel. The knowing rarely wins.
The Solo Loop
So I built alone. For months. It was the safe play.
I made Engram — a semantic memory system for Claude Code. I built a custom semantic search engine in Python and connected it to Claude Code through the Model Context Protocol. The idea was solid: index your conversation history, surface relevant context when you start new sessions, never re-explain your project again. I was genuinely proud of it. I wrote blog posts about it. It was my flagship project.
I built astrosky — the astronomy app. CLI, API, web app, the whole stack. That one came from pure hyperfocus and a clear night sky. It’s still running in production. Still useful. Still something I’m proud of.
I built plugins, workflows, a personal marketplace. All mine, all solo, all in repos where the only reviewer was me.
The pattern was comfortable: find a problem, build a solution, ship it, move on. No code reviews from strangers. No PRs into codebases I didn’t control. No chance of someone looking at my work and deciding I didn’t belong.
I told myself this was independence. It was really just avoidance.
The Moment Everything Shifted
Then Claude Code shipped native session memory and made Engram redundant overnight.
I’m not bitter. Truly. It validated the problem I’d identified — Anthropic clearly agreed that persistent session memory mattered. They just built it into the product. That’s how software works. The best tools eventually become features.
But it stripped away my safety blanket. My “flagship” was now unnecessary. And the thing about building solo is that when your main project becomes obsolete, you don’t have a community to fall back on. You just have yourself and a bunch of repos that suddenly feel smaller.
Around the same time, I noticed that tweakcc — the tool I use daily to customize Claude Code — had a bug. The session memory patch was silently failing on CC 2.1.38+. The very feature that replaced my project wasn’t working because of a changed feature gate pattern.
I could’ve filed an issue and waited. I could’ve worked around it. I could’ve built my own thing — that’s what I always did.
Instead, something in me said: enough.
Enough building alone. Enough telling myself I wasn’t ready. Enough letting fear make decisions that logic should be making.
I opened my editor and started reading someone else’s code.
The Bug (For the Technically Curious)
If you’re here for the human story and don’t care about regex patterns in minified JavaScript, skip to the next section. I won’t be offended.
Tweakcc patches Claude Code by finding feature gates in the minified source and removing them. The session memory gate in CC ≤2.1.37 looked like this:
if(!$_("tengu_coral_fern",!1))return null;A negative guard — if the flag is off, bail out. The patch just strips the line. Simple.
But in CC 2.1.38, Anthropic restructured it into a positive conditional:
if(uL("tengu_coral_fern",!1)){
// ... all the session memory logic lives inside this block now
}Same gate, completely different structure. The old regex couldn’t find it. The patch reported success but the feature was still locked. No error, no warning. Silent failure — the worst kind.
The fix: try the new pattern first, fall back to the old one for backward compatibility.
const patchPastSessions = (file: string): string | null => {
// Try new pattern first (CC >=2.1.38): positive conditional block
const newPattern = /if\([$\w]+\("tengu_coral_fern",!1\)\)\{/;
const newMatch = file.match(newPattern);
if (newMatch && newMatch.index !== undefined) {
const replacement = 'if(true){';
const newFile =
file.slice(0, newMatch.index) +
replacement +
file.slice(newMatch.index + newMatch[0].length);
// ...
}
// Fall back to old pattern (CC <=2.1.37): negative guard
const oldPattern = /if\(![$\w]+\("tengu_coral_fern",!1\)\)return null;/;
// ...
};Replace the conditional with if(true){ — the block always executes. 54 lines added, 11 removed. All 162 existing tests pass.
That was the easy part.
The Hard Part
The hard part was clicking “Create pull request.”
I’d written the code. I’d tested it. I’d verified it against CC 2.1.39. I’d written a clear issue (#506) documenting the problem, the expected behavior, the actual behavior, and the version where it broke. I’d written a PR description with a summary, testing steps, and backward compatibility notes.
Everything was ready. And I sat there for probably fifteen minutes, cursor hovering over the button, while my brain helpfully generated every possible way this could go wrong.
What if the code style is wrong? What if I missed a convention? What if there’s an obvious better approach and I look like an idiot? What if the maintainer is annoyed that some random person is submitting patches? What if—
I clicked it.
My hands were shaking. That’s not a literary flourish — they were physically shaking. ADHD rejection sensitivity is visceral. It’s not worry in the abstract. It’s your entire nervous system bracing for impact.
PR #509. Submitted.
Then I waited.
The review came back. Approved. Merged. No drama, no condescension, no “who are you and why are you here.” Just a clean review and a merged PR.
Then the maintainer tagged me in a comment:
“Congratulations! It was a perfect fix; great job.”
They shipped v4.0.1 with my patch. My fix. In a release that other people would download and use.
I’m not going to pretend I didn’t stare at that comment for a while. All those months of fear, and the actual experience was… fine. More than fine. It felt like something unlocking. Not a dopamine hit like shipping my own project — something quieter and deeper. The feeling of contributing to something bigger than my own little ecosystem.
What This Is Really About
I’m not writing this post because I think my 54-line patch is impressive. It’s not. It’s a regex fix. Any competent developer could have written it.
I’m writing this because I know there are people like me out there. People who can build entire applications from scratch but freeze at the thought of opening a PR on someone else’s repo. People whose brains tell them they’re not good enough, not experienced enough, not real enough to contribute. People who’ve been building alone because alone feels safe.
I was that person yesterday. Literally yesterday.
The “not good enough” voice is lying. It’s always been lying. The evidence has been there the whole time — in the projects I’ve shipped, the tests I’ve written, the problems I’ve solved. The voice just shouts louder than the evidence.
Being autistic means I process the world differently. Being ADHD means my attention is a fire hose, not a garden hose — I can’t always control where it points, but where it points, things grow fast. These aren’t deficits I’ve learned to work around. They’re the reason I’m good at this. The pattern recognition, the hyperfocus, the inability to tolerate friction, the compulsive need to understand why something works the way it does — that’s not a bug. It’s the whole feature set.
I just had to stop letting fear gate my output the way tengu_coral_fern was gating session memory.
The Vibe Coding Thing
While I’m being honest: there’s a culture in the AI development space that I find genuinely frustrating.
“Vibe coding.” Shipping projects in an afternoon with AI-generated code, no tests, no review, no discipline. Treating AI like a replacement for engineering instead of a tool that amplifies it. I’ve watched people build entire applications by just saying “make me a thing” and accepting whatever comes back without reading it, understanding it, or testing it.
That’s not engineering. That’s autocomplete with extra steps.
I use AI every day. Claude Code is central to my workflow. I’m not anti-AI — I’m anti-lazy. There’s a difference between using AI to move faster while maintaining discipline and using AI to skip the discipline entirely. One produces software. The other produces technical debt with a nice README.
Using AI responsibly means the same thing it’s always meant to use any tool responsibly: understand what it’s doing, verify that it’s correct, test the output, own the result. The AI doesn’t know your codebase. It doesn’t know your constraints. It doesn’t know what it doesn’t know. You have to be the engineer. The AI is the assistant.
And if you use open source tools every day — tools that other engineers built and maintain for free — and you find a bug? The responsible thing isn’t to work around it or complain about it on social media or build your own replacement. It’s to fix it and send the patch upstream.
That’s what engineering looks like. Not just building — contributing.
What’s Next
I’m going to keep contributing. Tweakcc is a tool I rely on daily, and there’s more work to be done. Feature gates change with every Claude Code release. Patterns shift. Someone has to keep the patches current.
Might as well be someone who cares about doing it right.
And if you’re like me — sitting on a fix for a tool you use, wanting to open that PR but terrified of the response — I get it. The rejection sensitivity is real. The imposter syndrome is real. The voice that says “they’ll think you’re stupid” is loud and persistent and wrong.
Open the PR. The worst that happens is you learn something. The best that happens is you fix something for everyone.
My hands stopped shaking about thirty seconds after I hit submit.
This was my first open source contribution. It won’t be my last. And if you want to know what’s in the sky tonight, I built an app for that.