Case Study
A Life Roadmap
Software architecture applied to personal life management.
Every productivity system I tried failed within weeks. So I stopped looking for a better app and started designing a better architecture — one built for a brain that works differently.
2025 — Ongoing
changelog entries in week one
tracked through conversation
one data layer
mechanics by design
The Short Version
Diagnosed with ADHD at 41. Every productivity system failed. So I built one from scratch.
Using the same architecture patterns I apply to enterprise systems — version control, separation of concerns, autonomous agents — I built a personal life management system that generates data through natural conversation instead of demanding deliberate logging.
Git is the database. Three interfaces write to one data layer. An autonomous Telegram bot surfaces observations and accepts updates throughout the day. The system produced more structured life data in its first week than any previous tool produced in a month.
The Problem
Productivity tools are architecturally incompatible with ADHD
Traditional productivity tools are built on an assumption: the user will reliably perform a set of actions on a regular schedule. Open the app. Log your progress. Check your habits. Review your goals. Repeat daily.
For someone with ADHD, this is a trap. The tool works for a week, maybe two. Then a hyperfocus episode breaks the streak. The guilt of missed entries compounds. The app becomes a reminder of failure. It gets abandoned. A new tool gets adopted. The cycle repeats.
Compliance-Based Design
Every tool demands you feed it data deliberately. For ADHD brains, deliberate routine maintenance is the hardest possible task to sustain.
Guilt Mechanics
Streak counters, "you missed 3 days" notifications, visual indicators of failure. Designed to motivate neurotypical users. Devastating for ADHD.
Rigid Schedules
"Daily review at 9 AM" becomes a guilt trigger by day four. Predictable cadences lose novelty. Novelty is what ADHD brains need to sustain engagement.
The insight: what if the system generated its own data through natural interaction, instead of requiring the user to feed it?
The Architecture
Three interfaces. One data layer. Zero compliance required.
Git Is the Database
The entire system lives in a private Git repository of structured markdown files. No database, no API, no cloud dependency. Every change is diffable, attributed, and timestamped. The data format is intentionally technology-agnostic — plain text files that any tool can read, forever.
Every change reversible, every state recoverable
See exactly when and by which interface
Markdown will be readable in 50 years
Claude Code (CLI)
The most powerful interface. Used for deep planning, restructuring, and architectural work. When I need to think strategically about a life domain — not just log an update — this is where it happens.
Telegram Bot Agent
Key InnovationAn autonomous agent that proactively sends observations and prompts throughout the day. Instead of opening an app to log something, the bot starts conversations. Data is generated as a byproduct of natural interaction.
Electron Dashboard
A read-only display layer showing domain status, changelog entries, and agent health. Built from zero to signed .dmg in a single session. The dashboard reads but never writes — separation of concerns means the display layer can never corrupt the data.
Knowledge Architecture
Not all information has the same persistence needs
The system uses a four-layer hierarchy that prevents information overload while preserving the full record.
Changelog
What happened
Raw events, updates, observations. High volume, low curation. The stream.
Scratchpad
What to pick up
Active items, loose threads, things in progress. Medium volume, regularly pruned.
Observations
What it means
Patterns, correlations, insights surfaced from the data. The "hmm, interesting" moments invisible without structured tracking.
Tenets
What's confirmed true
Principles validated by the data over time. Durable truths about how I actually operate — as opposed to how productivity culture says I should.
ADHD-Aware Design
The accommodation is architectural, not cosmetic.
This isn't a productivity system with "ADHD-friendly features" bolted on. The entire architecture is designed around how the brain actually works.
No rigid schedules
Bot prompts are randomized. No "daily review at 9 AM" that becomes a guilt trigger. Unpredictable timing maintains novelty and engagement.
No guilt mechanics
No streak counters. No "you missed 3 days!" notifications. The system tracks what happens, not what didn't happen.
Conversation-driven data
The bot asks how your shoulder is doing. You respond naturally. A health domain update gets committed. Data as a byproduct, not a chore.
Hyperfocus-compatible
When the bot gets ignored for hours during deep work, nothing breaks. The system doesn't penalize focus. It captures what happened when you surface.
No notification spam
The bot is conversational, not demanding. It surfaces observations and asks questions. No response? No escalation. It tries later with a different prompt.
The broader insight
These aren't niche accommodations. Every enterprise tool that gets deployed and then abandoned by half the users fails for the same reasons these design decisions address.
Methodology
Pass@1: Documentation-first AI development
The Electron dashboard was built from zero to a signed macOS .dmg in a single session. Not because of speed-coding — because the architecture documents were thorough enough that the AI generated a correct implementation on the first attempt.
This isn't prompt engineering. It's software architecture applied to AI-assisted development. The quality of the output is determined by the quality of the specification. The same approach that makes a requirements document useful to a human developer makes it useful to an AI developer — except the AI can execute on the full spec in a single pass.
Data models, component responsibilities, interaction patterns, edge cases, design constraints
Coding patterns, error handling, naming conventions — the full specification
Complete context produces correct first-pass implementations
The architecture work happens upfront. The implementation is execution, not exploration.
Outcomes
More data in one week than any previous tool produced in a month
Pattern discoveries
Career stress amplifying financial anxiety — a correlation I felt but couldn't see until the data showed it. The impact of AI-assisted execution on stress levels. Insights invisible without structured tracking.
One confirmed tenet
Surfaced from the data, not invented aspirationally: "I build systems that turn chaos into clarity." Validated by the pattern across all six domains — every improvement used the same mechanism.
Sustained engagement
No abandonment. No guilt spiral. The system adapts to availability instead of demanding compliance — and the data keeps flowing.
What I'd Do Differently
Build the bot first, not the dashboard
The bot is the highest-value interface — it generates data conversationally. The dashboard is nice to have but secondary. Get the data flowing before you worry about displaying it.
Define the four-layer hierarchy earlier
The Changelog / Scratchpad / Observations / Tenets structure emerged during the first week. Building it into the architecture from day one would have saved restructuring.
More aggressive prompt randomization
Even "random" timing had patterns initially. True novelty maintenance for ADHD requires more deliberate entropy in the interaction design.
The Design Insight
Design for how people actually behave — not how you wish they would.
Productivity tools fail ADHD users not because ADHD people are undisciplined, but because the tools are architecturally incompatible with how ADHD brains process information and maintain habits. The solution isn't a "simpler" tool. It's a fundamentally different architecture.
The broader insight extends beyond ADHD: any system designed for humans should account for how humans actually behave. This is true for personal productivity tools. It's also true for enterprise software, CRM implementations, and every system that depends on human adoption to deliver value.
Technical Stack
More case studies
See how I approach different kinds of problems — from AI-governed development to crisis infrastructure rescue.