What 7 Months of ADHD Hyperfocus Builds

I can't code.

That's not false modesty. I have no formal training, no computer science degree, no background in software development whatsoever. I'm a Navy veteran, a published horror author, and a neurodivergent single dad living in a converted bus in Perth, Western Australia.

And I just spent seven months building a 170,000 line Python application from scratch. I got the concept, ADHD Hyperfocus kicked in and away I went.

So when a tool called GitNexus let me visualise the entire architecture as a knowledge graph... I wasn't expecting what I saw.

I need to back up a bit.

NeuroRythm exists because 663 apps failed me. Not metaphorically. I actually kept a count for a while. Productivity apps, habit trackers, task managers, focus tools... every one of them designed by neurotypical brains, for neurotypical brains, with a neurotypical assumption that you just... do the thing you're supposed to do.

My brain doesn't work like that. ADHD means the standard "just make a to-do list" advice isn't unhelpful, it's insulting. So I decided to build something that actually worked the way my brain works.

Which meant building something I had no idea how to build.

AI made it possible. But not in the way people think.

Vibe Coding

Vibe Coding Has a Ceiling

Everyone's talking about vibe coding right now. Drop a prompt in, get an app out. Look ma, no hands.

Look, if you want a basic note-taking app or a Spotify clone... sure. Maybe. I'm not going to completely dismiss it.

But the second complexity enters the picture, vibe coding falls apart. Not a little. Completely. The tools are trained on millions of examples of simple, isolated, well-documented code. They're incredible at that. NeuroRythm is none of those things.

NeuroRythm is 578 files where everything talks to everything else. Systems that have to know about each other without directly depending on each other. An error reporting architecture that has to be completely separate from the debugging architecture because they serve fundamentally different purposes. One is for the user, one is for me. A language system that rotates through ten distinct personalities and has to stay coherent across 69 message types.

There is no chance... zero... that any current vibe coding tool could have built this.

I tried some of them early on, for a far easier project. I know.

AI Is Trained on Lazy Human Code

That's the first fight I had to win. The second one was subtler and honestly more frustrating.

AI is trained on human code. Human code, broadly speaking, is full of lazy patterns. Not because developers are lazy. Because certain patterns become habits, habits become conventions, conventions get reinforced across millions of repos, and then AI absorbs all of it and presents those patterns back to you like they're gospel.

Backward compatibility assumptions nearly broke me.

I'd ask for implementation of a new feature and get back code with compatibility layers baked in. Deprecation warnings. Fallback handlers for older versions of data structures that had never existed in the first place.

NeuroRythm is version one. There are no users yet. There is nobody to maintain backward compatibility for. There is no legacy data. The entire premise of "we need to make sure older versions can still..." mate, there are no older versions. This is the first one.

I had to fight that instinct out of every significant implementation. Over and over. Explicitly telling the AI: stop catering to users that don't exist yet.

Print statements were another one. I hate "print('got here')" scattered through production code. It's lazy debugging. NeuroRythm has a proper error reporting system. If something breaks, I want to know about it through the right channel, not because someone left a throwaway print statement buried in a function three layers deep.

Every time I turned my back, they'd reappear.

The Fight to Keep Two Systems Separate

The debugging and error reporting battle took the longest.

These are two different things. Error reporting is a feature. It's how I know what's happening in production, what users are experiencing, what needs fixing. Debugging is a development process. It's how I understand what broke and why.

They should not live in the same system. They should not share logic. They should not be aware of each other except through clearly defined interfaces.

AI disagreed. Repeatedly.

Not because it was wrong about everything. Merging them is a common pattern. It's in a lot of codebases. It reduces apparent complexity. But apparent complexity and actual complexity are different things. Separate systems means separate concerns means I can improve one without breaking the other.

I held the line. Every time it tried to collapse them back together, I pushed back.

That stubbornness is now baked into 170,000 lines of code.

Then I Saw the Graph

GitNexus builds knowledge graphs of codebases. Nodes are files and functions. Edges are connections between them -- calls, imports, dependencies. The denser the graph, the more interconnected the system.

I ran NeuroRythm through it at four points in the build. This is what I saw.

July 2025

NeuroRythm files July 2025

This isn't the graph. This is July 2025, about six weeks in. Everything living in one flat directory. No systems architecture. No organisation. Just a pile of Python files sitting next to each other like they're equals.

That's what the start of a hyperfocus build looks like.

August 2025

NeuroRythm Aug2025 on GitNexus

August 2025. 2,268 nodes. 5,036 edges. Around 40,000 lines of code. No error system yet. No debug system. No backup architecture. What you're looking at is the raw connective tissue of something that didn't exist six weeks earlier.

I had no idea what GitNexus was going to show me when I ran it the first time. I just knew I wanted to see it.

So I looked at it for a while. Then I wondered how newer builds would look in comparison.

December 2025

NeuroRythm Dec2025 on GitNexus

December 3rd, 2025. 3,246 nodes. 9,459 edges.

Same tool. Completely different picture.

The August graph was dense but anonymous -- a mass of connections without much visible structure. By December you can read the graph. Named systems sitting in the cluster. "checkin_system". "dialog_system". "conflict_system". "language_system". "timeblock_system". The flat pile of files from July had become something organised enough that GitNexus could show you where one system ended and another began.

978 new nodes. 4,423 new edges. In four months.

That's not lines of code added to a file. That's architecture being built. Systems talking to other systems through defined interfaces. The kind of growth that only happens when someone has stopped throwing code at a problem and started designing how the pieces fit together.

I didn't have a formal plan for that. I just knew when something felt wrong and pulled it apart until it felt right.

The graph confirmed the instinct was working.

January 2026

NeuroRythm Jan 2026 on GitNexus

January 5th, 2026. 5,525 nodes. 13,586 edges.

Something changed in the shape.

The December graph was a dense ball. January has these blue cluster masses forming around the edges -- systems that have grown complex enough to develop their own internal gravity. You can't read the folder names in the overview anymore. The graph is too dense.

Zoom in.

NeuroRythm Jan 2026 on GitNexus zoomed.

Now you can see them. "errorreport_system". "debug_system". "language_system". "patterns_insights_system". "graph_system". "sound_system". Systems that didn't exist at all in August. Some that didn't exist in December.

2,279 new nodes. 4,127 new edges. In one month.

That's what happens when an ADHD brain locks in.

March 2026

NeuroRythm Mar2026 on GitNexus

March 24th, 2026. 4,957 nodes. 17,168 edges.

Quick note on the numbers. Fewer nodes than January, more edges. That's not regression -- I finally buckled and put the code on git so I could use GitNexus properly, which meant a .gitignore finally existed. The logs folders, build artifacts, backups -- all excluded now. January's graph was counting that noise. This one isn't.

So the node count is cleaner. The edge count tells the real story. 17,168 edges. That's 3,582 more connections than January. More interconnection. More systems talking to more systems.

Zoom in.

NeuroRythm Mar2026 on GitNexus zoomed

You can't read this graph at full zoom. Too dense. But zoomed in you can see what it's actually tracking now -- not just folders and files but named classes. "MorningPlanningManager". "TaskReminderSystem". "DailyReflectionDialog". "MultiDeviceSyncManager". "TimeShiftManager". The architecture has gotten specific enough that the graph is mapping individual components.

And somewhere in the middle of all of it... GitNexus itself. "gitnexus-exploring". "gitnexus-debugging". "gitnexus-impact-analysis". The tool I used to analyse the codebase, sitting inside the graph of the codebase it analysed.

I thought that was worth pointing out.

The Sun in the Middle

Then I clicked on "handle_error".

NeuroRythm handle_error on GitNexus

Every line in that graph is something that calls it. Every single system in NeuroRythm has a direct connection to the error handling function. It looked like a sun. Everything orbiting a single point.

That's not an accident. That's a design principle made visible.

Error reporting is a feature. Fail loudly. No silent failures. No fallbacks that hide problems. I want to know about it through the right channel, not because someone left a "print('got here')" buried in a function three layers deep.

I baked that into 170,000 lines of code. The graph showed me I actually did it.

The Architecture Looks Like My Brain

The thing about building something this complex without a formal background is that you don't always know what you're doing while you're doing it.

I built instinctively. I knew what I wanted the system to do. I've lived inside my own brain long enough to understand what it needs. I knew what patterns felt wrong when AI suggested them. I knew when systems were getting too entangled and needed pulling apart.

What I didn't know was whether that instinct was producing something architecturally coherent or an absolute mess held together with wishful thinking.

The graphs answered that.

An ADHD brain builds like an ADHD brain thinks. Dense. Interconnected. Everything affecting everything else. No clean neat separation between systems -- because that's not how the real problems present themselves.

The architecture of NeuroRythm looks like my brain.

And instead of fighting that, I built something that works with it.

Seven months. A kid to raise, a bus to live in, about nineteen other projects running in parallel. Built this anyway.

Developers will get what those graphs mean. They know how hard it is to build something that dense and still have it hold together.

So I'll leave the images here and let the graph speak for itself.

NeuroRythm is currently in pre-beta. If you're neurodivergent or you suspect (we don't gatekeep), our private beta starts soon, and if you want early access, join us @ NeuroRythm Community.

GitNexus is a free, open-source tool for visualising codebase architecture available on Github. Discord Community. Created by Abhigyan Patwari