Dysautonomia doesn't show up on your face, and it doesn't show up on most standard lab work either, which is why so many people spend years being told everything is normal while their body malfunctions daily. But there is a second layer to that invisibility that gets talked about less: you can't see the recovery either.

Recovery moves in months. You live it in days, and the days are noisy. A rough morning after three good weeks feels like proof that nothing is working, even when the underlying trend is still climbing.

Am I actually getting better?

One morning's reading can't answer that. The day-to-day noise is larger than the recovery signal, so every metric is charted against your own rolling baseline: the line underneath, not today's number.

"You can't see your nervous system. But it is measurable, and measured honestly, it becomes something you can watch."

I had already been answering that question for myself for three years, in a web app I built for my own use. It worked, and it is a large part of how I got to a much better place than I had been in for years. But it was mine alone: no live capture, no watch, nothing anyone else could install.

When I looked at what existed for everyone else, the gap was obvious. Visible owns pacing but requires a $160/yr proprietary armband. Bearable owns generalist symptom journaling with no HRV at all. Welltory is moving upmarket toward a general "AI health companion." The condition-specific apps are free hobby projects. Every serious competitor is cloud-first.

That leaves an empty cell: measurement-grade, condition-first, software-only, affordable and genuinely private. And privacy is not a nice-to-have for this audience. For people with real disability-insurance and employment anxieties, "no account, no cloud, and I can't lose or sell your data because I never have it" is a first-order feature. Nobody was saying it.

Every architectural decision traces back to a specific failure of the tools I had been using on myself.

This is the part that matters most for how I work now. The native app went from an empty directory to a store-ready build in a week, and every commit is co-authored by Claude. I did not write it by hand. What I did instead was considerably harder, and considerably more valuable.

The method that made it work is the same one I have been pushing at Realtor.com: define the structure and the standards in code, then have the model mimic them. Nothing about this is "describe an app and accept what comes out." The leverage comes from being extremely opinionated about the skeleton and then letting the model fill it in at a speed no human team can match.

• A living architecture document. The repo carries a project brief describing the state shape, the invariants and the conventions in enough detail that any session starts fully oriented. When a rule got violated twice, the fix was to write the rule down better, not to correct the output again.
• Invariants encoded as guardrails, not instructions. Every mutation flows through a single save(). Waveform arrays are physically forbidden from the journal blob, with a dev-build warning that fires if one ever leaks in. The constraint enforces itself, so neither I nor the model can quietly break it at 1am.
• Tests as the specification. The scoring framework is the product, because the thresholds ARE the value. It was ported verbatim from my web app, with unit tests asserting that known inputs produce the exact same categories. That suite is what let me refactor aggressively without ever wondering whether the grades had drifted.
• Review at the level of intent. My job shifted almost entirely to "is this the right design, is this honest about uncertainty, does this correctly handle the case where the strap slips." I stopped reviewing syntax and started reviewing judgment.
• Match the model to the task. Heavier reasoning models for the DSP pipeline and the state architecture; faster ones for UI work and mechanical refactors.

The honest caveat: AI made the code fast, but it did not make the decisions fast. Three years of living with the condition is what told me that box breathing and 4/7/8 had to be retired because they flatten RSA and break day-to-day comparability, and that "physiological age" had to be deleted because it is a device-proprietary estimate not derivable from an RR series. None of that got faster. Domain judgment is still the bottleneck, and it is still entirely mine.

The core bet was to build the hardest, least-fakeable thing first. If the HRV pipeline could not produce numbers I would trust about my own health, nothing else in the app was worth building.

• Port the scoring engine verbatim. Start from thresholds I had already validated on myself over three years, with tests locking them in place. No threshold was quietly "fixed" during the port, even where one looked odd.
• Prove the signal chain. Get real RR intervals off a Bluetooth strap, through artifact correction, into time-domain, frequency-domain and coherence metrics, all on-device, before building a single screen around them.
• Lower the hardware barrier. Add Apple Watch and camera PPG as capture sources once the pipeline was trustworthy, so the app works with nothing but a phone.
• Go wide only after the core was solid. The SwiftUI watch app, home-screen widgets, Health Connect parity on Android and the AI report builder all came after the measurement core was tested and stable.
• Ship to both stores. Real review processes, real entitlements, real IAP, real Android minification. The unglamorous work that separates a demo from a product.

Every layer was chosen to keep the app trustworthy, private and fast on hardware I do not control.

Autonomic is live on the App Store and Google Play, now at version 1.18, with a free journal tier and a Pro subscription at $7.99/mo or $49.99/yr.

It is early, and 100 downloads is a first week, not a business. What makes it worth reporting is that every one of them arrived with zero marketing, purely from store search in a category where the competing terms are contested only by hobby projects. That is the signal I was testing for, and it says the positioning is right even before any of the real distribution work has started.

The result I care about most is not commercial anyway. I use it every day, on my own recovery. That is a much harder quality bar than a launch metric, and it is the reason the app refuses to grade a noisy reading instead of guessing.

I lead AI adoption for a large front end organization, and I am wary of the genre of claim this project sits inside. So here is what I think Autonomic actually demonstrates, stated carefully.

• The constraint has moved. Implementation speed is no longer what limits a small team. Architectural clarity is. The week was spent deciding things, not typing them.
• Guardrails beat instructions. Every convention I encoded structurally, such as one save() path, a forbidden data shape with a runtime warning, or tests pinning the scoring thresholds, held. Every convention I only described in prose eventually drifted. That is the single most transferable lesson.
• Verification is the new bottleneck, and it is domain-specific. A model will happily produce an HRV pipeline that looks entirely correct and silently reasons across a dropout. Catching that took knowing the physiology, not reading the diff.
• Prior art is an enormous multiplier. A week was only possible because three years of my own use had already settled the hard product questions. The thresholds, the scoring weights and the daily loop were decided long before the first commit.
• Scope that was previously irrational is now reachable. A SwiftUI watch app, widgets, two health platforms and a DSP pipeline would each have been a quarter of work for a team. Being able to say yes to all of them changed what the product could be.

What "reachable scope" actually looks like

A guided POTS stand test, running entirely on the watch: lie still, stand on cue, hold position while it tracks the rise, and get a scored result written straight back into the journal. A SwiftUI companion doing real protocol work like this would once have been its own quarter for a team. It shipped inside the same week as the phone app.

Three protocols

Rest

Stand

Hold

Result

This is the same operating model I brought to Oracle and the AI SDUI Studio, run without a safety net: define the structure and standards in code, then move at a speed that used to require a team. Autonomic is where I proved to myself it holds all the way to a shipped, paid, store-approved product.

The biggest surprise was how much of the work turned out to be editorial rather than technical. Deciding to delete "physiological age" because it is not derivable from an RR series. Retiring two breathing patterns because they flatten RSA and break comparability. Choosing to refuse a grade rather than publish a soft one. Every one of those made the app smaller and better, and not one of them was an engineering problem.

The second lesson is that building for yourself is a brutal, excellent quality bar. I cannot ship a metric I do not trust, because I will open it tomorrow morning and try to make a decision about my own health with it. That constraint killed more features than any roadmap review I have ever sat in.

• Earn distribution the way this niche actually rewards. Community trust and search, not ad spend. The paid-social math in this category is underwater by an order of magnitude.
• Deepen the doctor report. It is the strongest wedge in the product and still the least developed part of it.
• Keep the free tier genuinely useful. Every growth loop here runs through "which app do you use?" threads, and those recommend what people use daily.
• Hold the privacy line. The moment there is a backend, the core promise is gone. That constraint stays even where it costs features.

And to the POTS, dysautonomia and long COVID communities, whose public writing shaped what this app decided to measure.