helper — an agent-authored operating system for executive function
I have ADHD. Every self-maintained productivity system I ever built died within weeks, because maintaining the system was itself the task my brain drops. helper inverts the ownership: I talk, a coding agent writes — and the system has survived daily use ever since.
Markdown vault / Agent skills (ZCode) / Jira / Confluence / git integrations / Confirm-first write gates
Context
I'm a senior engineer with executive dysfunction. The pattern is old and well documented — by me, in the failure analysis that precedes this system: incomplete handovers, rework, optimistic estimates, communication that arrives late. Classic ADHD tax, paid monthly.
I had tried to build my way out of it before. Three times, in fact. The evidence
is still sitting in my GitHub: harada-method, testimony, and human-vault
are all git init shells with zero commits. The insight that finally mattered:
every system that required me to maintain the artifact died at birth. The
problem was never the methodology. It was that methodology maintenance is
executive function, and executive function is the scarce resource.
Constraints
- The system must survive a brain that drops systems. Zero ongoing maintenance willpower budget.
- It must be grounded in real work data — Jira, pull requests, git history — because blank templates and aspirational plans are where these systems go to lie.
- It touches my work systems. An agent that can write to Jira needs rules, or it's a liability, not a helper.
- It must fail loudly and recoverably: an append-only audit trail, nothing silently overwritten.
Decisions
Invert the ownership. The one rule of the whole system: Nap talks, the agent writes. No blank template ever faces me. The agent authors every file from my spoken answers and the real data it can read. I spent my willpower budget once, on designing the countermeasures — not daily, on upkeep.
Map every known failure to a gate. The system opens with a criticism → countermeasure table: handovers get a checklist-gated handover skill drafted from real tickets; rework gets a definition-of-done gate that runs before anyone else sees the work; failed estimates get an estimation ledger with calibration against my own history; lateness gets a leave-by line computed every morning. Nothing in the system is aspirational — every piece answers a specific, documented failure.
Make the agent safe by constitution. An 11-rule constitution in AGENTS.md:
confirm-first write gates to work systems, append-contract audit trail,
Bullet-Journal migration semantics (nothing carries over without a conscious
decision), and an auto-regenerating INDEX.md so navigation never rots.
Keep the daily cost honest. Ten minutes at start of day, ten at shutdown. Everything else — capture, estimation, adversarial review, the mentor council — is on demand. A system that demands an hour a day is a system I'd abandon by Thursday.
What shipped
Seventeen skills covering the full working day: morning and shutdown anchors,
capture, done-gates, estimation, triage, a self-audit ("doctor"), weekly and
monthly rollups, and a council skill that runs adversarial mentor panels — a
finance brain, an engineering lead, a craftsman, an iconoclast — over any
decision I'm about to make.
The repo's design spec documents its own failure-mode analysis, which means the system carries the reasons for its shape inside it. And unlike its three predecessors, it lives: roughly 4,700 lines across daily files in its first three days, in active use ever since. This page is running on that rhythm.
What I'd do differently
The personal instance and the reusable pattern are still entangled. The skill contracts — the gate designs, the migration semantics — would work for anyone with a coding agent and a scattered brain; my Jira usernames shouldn't have to come along. I'd extract the core into a installable skill set with a clean separation from private data, and write the pattern up for other people who have already failed at three systems of their own.