How I Built 160 Projects in 8 Months With ADHD

Eight months ago I couldn’t code. Today my GitHub has 160+ projects and over 4000 commits.

No CS degree. No bootcamp. ADHD and autism, diagnosed. AI in the loop from day one.

This isn’t a humblebrag post. Half of those 160 projects are abandoned, several are embarrassing, and the way I got here breaks most of the standard advice about learning to code. But the numbers are real, and the method behind them is teachable. Here’s the honest version.

Where I started

I’m Wojciech. Self-taught, AuDHD. Before this I had never shipped software. I had the classic ADHD graveyard instead: a dozen abandoned hobbies, courses bought and never finished, notebooks with three used pages.

The pattern was always the same. Massive enthusiasm for two weeks, then the dopamine ran out, then shame, then a new hobby. I fully expected coding to go the same way.

It didn’t, and the reason wasn’t discipline. It was that I accidentally built a learning system that matched my brain instead of fighting it. AI was the biggest piece of that system.

The numbers, honestly

Because “160 projects” invites fair skepticism, let me break it down:

160+ repositories in 8 months. Everything from 2-hour experiments to production systems.
4000+ commits. Real, granular commits, because committing constantly is how I compensate for ADHD working memory (more on that in my full survival guide).
The biggest single project: 747 commits, an enterprise-style platform with 96.5% test coverage.
Maybe 10 projects have real monetization potential. One became an actual product: Borg Tools (on our tools page).
The rest? Learning artifacts. Dead ends. Toys. And that’s exactly the point.

A neurotypical mentor would have told me to pick one project and finish it. That advice would have killed my progress in week three.

Why 160 projects instead of 1 good one

ADHD motivation runs on novelty and interest, not importance. When a project stops being interesting, my brain doesn’t just lose enthusiasm. It loses the ability to work on it. Pushing through produces days of miserable, near-zero output.

So I stopped pushing through. New idea mid-project? Fine. New repo, go. The rule wasn’t “finish everything.” The rule was “always be building something.”

Here’s what nobody tells you about this approach: the skills compound even when the projects don’t. Project #40 abandoned at 60% still taught me auth flows. Project #41 abandoned at 30% still taught me Docker. By project #100, “starting from scratch” meant scaffolding in an afternoon what used to take two weeks.

And a funny thing happens with abandoned projects: some of them come back. The ADHD interest cycle is a cycle. I’ve returned to “dead” repos months later with fresh hyperfocus and shipped them in days. My hyperfocus post digs into how those bursts work.

The AI-augmented workflow

I want to be completely transparent about this, because it’s the part people either overrate or dismiss: AI wrote a lot of my code. Especially early on.

Here’s the loop I settled into:

Describe the goal in plain language to an AI assistant. Messy is fine. “I want a script that watches a folder and resizes any image dropped into it.”
Get a draft, read every line. Not skim. Read. If I couldn’t explain a line, I asked about that line until I could.
Break it on purpose. Change something, predict the failure, run it. This is where the actual learning happened.
Extend it past what the AI gave me. The draft was the floor, never the ceiling.
Commit with a message explaining what I learned. My git log doubled as a learning journal.

For an ADHD brain this loop is close to perfect. There’s no blank page (task initiation, solved). Feedback arrives in seconds (dopamine, sustained). Questions get answered instantly without a 40-minute detour into docs that ends with me reading about mechanical keyboards (context, protected).

Did I sometimes lean too hard on the AI and produce code I didn’t understand? Yes, early on. Those projects broke, I couldn’t fix them, and that pain taught me the read-every-line rule. The failures were part of the curriculum.

What a typical week actually looked like

Not a productivity influencer schedule. A real one:

2-3 hyperfocus days. 8-12 hours of deep building. These generated most of the 4000 commits. I learned to prepare for them (food ready, one task queued, phone in another room) rather than schedule them, because you can’t schedule hyperfocus.
2-3 medium days. A couple of small sessions. Fixing tests, writing READMEs, small features. I aimed everything at “leave a broken build for tomorrow-me” so the next start was frictionless.
1-2 zero days. Nothing. At the start these came wrapped in shame. Eventually I accepted them as the cost of the hyperfocus days and stopped letting one zero day snowball into a zero week.

Averaged out, that’s roughly 17 commits a day across 8 months. Lived day to day, it was feast and famine. Both are fine. Only the average matters.

What went wrong (a lot)

For balance, the failure list:

I burned out once, around month five. Two hyperfocus weeks back to back, then ten days of nothing and a real fear that the whole thing had been a fluke. Recovery: tiny 10-minute sessions until momentum returned.
I rebuilt the same thing four times because I forgot I’d already solved it. That’s when I started keeping decision logs in every repo.
Tutorial-shaped projects taught me almost nothing. Every project that stuck was solving my problem. Every clone of someone else’s idea died fast.
Imposter syndrome hit hardest when things went well. “The AI did it, not you.” I’ve made peace with this: I direct, verify, debug, and own everything I ship. The 96.5% test coverage on my biggest project isn’t there because an AI cared about quality. It’s there because I did.

Can you replicate this?

The exact numbers? Probably not, and they don’t matter. The system? Absolutely:

Follow interest, not curriculum. Build the thing you actually want to exist.
Use AI from day one, with the read-every-line rule. I’ve written a full realistic guide to learning to code with ADHD around this.
Never finish out of obligation. Abandon freely, start freely, keep the streak of building rather than the streak of any one project.
Externalize everything: commits, decision logs, READMEs. Your memory is not a project dependency.
Use tools built for your brain. My current stack is in the ADHD developer tools roundup.
Find your people. Building alone with ADHD means nobody catches you when the shame spiral starts. That’s why I started TheOnes: a place for neurodivergent devs to build together. Come say hi.

Eight months ago the most likely outcome was that coding would join the hobby graveyard. Instead it became TheOnes.io: community, tools, and eventually an AI-first agency run by neurodivergent developers.

If your brain works like mine, the standard path was never going to work for you anyway. Good news: there’s another one.