I can start the morning building a backend, move to the frontend to wire it up, then get a better idea halfway through.
The idea is usually related. Sometimes it is genuinely better. But it changes what I am building before the first version is finished.
That is the part of working as an ADHD builder that I rarely see discussed. The problem is not always losing focus. Sometimes I focus hard on a newer version of the same project.
I usually begin with a PRD or thesis that feels clear. It defines the problem, sketches the architecture, and tells me what "done" should look like.
Then implementation starts.
The backend exposes a constraint I did not see while writing the plan. The frontend makes an assumption feel wrong. A new idea appears while I am debugging, and suddenly I can see a cleaner path.
So I take it.
A few hours later, I have three versions of the project. There is the product described in the PRD, the decisions I made while building, and the code that currently exists.
None of them fully match.
Some of this is normal. Software changes when it meets reality. A document written before implementation should not control every decision forever.
The trouble begins when I never capture the decisions that replaced it. The code moved forward, but the reasoning stayed inside one session.
When I return, opening the repository is easy. Understanding which version is real takes longer.
I reread the PRD and find instructions the current build has already rejected. I inspect partial backend and frontend changes without the decision behind them. Then I search agent conversations, terminal output, and unfinished notes for the moment the direction changed.
Recovery usually takes me 15 to 45 minutes. Sometimes it takes hours. That is my own measurement, not a universal ADHD statistic.
A 2025 study surveyed 493 professional programmers. Of them, 239 self-reported diagnosed or self-diagnosed ADHD. Across the workplace challenges the researchers measured, the ADHD group had 1.8 to 4.4 times the odds of reporting more frequent difficulty. Time management and software design showed some of the largest gaps.
I recognize that shape. The code is not always what slows me down. Reconstructing why the code looks this way does.
My issue tracker can say "finish frontend integration." It rarely preserves which API shape I dropped, why the PRD is now wrong, or what I was about to test when another idea took over.
Writing more documentation sounds like the answer. In practice, it can create a fourth version of the project. Updating it requires me to notice the exact moment when the build crosses into a new interpretation of the idea.
This is where the standard workflow fails a solo builder like me. I am acting as product manager, backend engineer, and frontend engineer. A choice in one role changes the work waiting in the other two.
The new idea is not always the enemy. Losing the trail of decisions is.
My current fix is cognitiveOS, built around one habit: before I leave a session, I ask the agent to wrap it up.
The agent synthesizes what happened into the workspace. It records the current state, last handoff, blockers, decisions, and open loops. The goal is to preserve where the build actually ended, even when that place no longer matches the original PRD.
When I return, the next agent reads the workspace before touching the project. I ask what we last completed and which open loop remains.
That question has become my re-entry point.
New ideas still derail me. Backend and frontend still pull me in different directions. This is not ADHD treatment, and I do not know if the same workflow will fit every builder.
What it fixes for me is narrower: the reasoning behind the current build no longer lives only in my working memory.
The PRD tells me where I meant to go. The handoff tells me where the code actually went.
That gap is usually where tomorrow's work starts.
If your build keeps outrunning your plan, explore cognitiveOS at cognitiveos.0xdas.dev.
// the thinking is free. — 0xDas▋

