An Honest Training Engine

At 6 a.m. in July I run the same easy loop I run every week, at the same effort, and my watch tells me I'm working too hard. It's muggier than it has any right to be at this hour, I slept badly, and my heart rate is riding ten beats above its winter self for exactly the reasons you'd expect. The run was easy. The app was wrong.

That gap — between what my body was doing and what the software said about it — is the reason Cadeo exists. Not a new coach, not another dashboard. An attempt to build a training app that tells you the truth about your own runs.

The lie is structural

Every mainstream training app inherits the same shortcut: heart-rate zones as fixed percentages of your max. Zone 2 is 60–70%, easy is under some line, and the line never moves. It's a table. It doesn't know it's hot. It doesn't know you slept five hours, or that you're three weeks into a build and carrying fatigue, or that you're simply fitter than you were in March. It compares today's heart rate to a version of you that doesn't exist today, and then it judges you against the gap.

Most of the time the error is small enough to ignore. But the times it matters are exactly the times you most need the truth: the hot morning, the under-slept week, the run that felt easy but pinged as hard. On those days the table doesn't just get it wrong — it tells you to distrust your own effort. It nudges you to slow down a run that was already correct, or to push one that was quietly digging a hole. Over a training block, a model that's wrong at the edges trains you wrong at the edges.

I didn't want a better table. I wanted software that prices in the day before it reads the number.

What "honest" means as a design constraint

"Honest" sounds like a vibe. In Cadeo it's an engineering constraint, and it turns out to be a demanding one. If the app's one job is to not lie to you about your body, then every feature has to answer a specific question: what lie does this prevent? Features that don't answer it don't get built. Features that do, get built properly, because a half-honest model is just a lie with more steps.

That framing organizes the whole system. There are three lies a training app can tell you, roughly in order of how much they cost you, and most of Cadeo is the machinery for refusing each one.

Lie #1: “That run was harder than it should have been”

This is the July-morning lie, and it's the one Cadeo was built to kill first.

Every runner knows the feeling: you go out easy, and your watch still reports zone 3. That's not you being unfit. It's a model comparing today's heat-loaded, sleep-deprived heart rate to a table that assumes a cool, rested morning. So instead of a fixed zone, Cadeo builds an expected heart rate for the run you're actually about to do — and adjusts it for the conditions that legitimately raise it. Heat costs you beats. Poor sleep costs you beats. Accumulated fatigue costs you beats. The engine prices each of those in as an explicit term, using your own recent history as the baseline rather than a population average.

Then it does the part that matters: it interprets the residual. Once you've accounted for the heat and the fatigue, whatever heart rate is left over is the real signal. If today's number is exactly what the conditions predict, the run was easy — and the app should say so, not scold you. If it's higher than even a hot, tired day can explain, that's worth flagging, because now it means something.

There's a second version of this lie the engine watches for over longer stretches: are you actually getting fitter, or just accumulating miles? For that it tracks the decoupling between your pace and your heart rate within a run — whether your heart rate drifts upward while your pace holds steady — against a rolling personal baseline. That drift is one of the more honest fitness signals in endurance running, and it's nearly invisible if all you're looking at is a zone chart.

None of this works from a single weather reading at the trailhead, so it doesn't use one. Cadeo samples conditions along your actual GPS track, so a run that started cool and finished in the sun is understood as the run it was.

Lie #2: “You feel good — do more”

This is the expensive one, because the failure mode isn't a bad recommendation. It's an injury.

The most dangerous thing an optimizing training app can do is chase a good day. You feel strong, the numbers look green, so it nudges the volume up, or converts an easy day into a quality session, and it does this right up to the point where your tissues can't absorb the load. Runners get hurt in the gap between "I feel fine" and "my body can handle this," and a naive engine lives in that gap.

So Cadeo accounts for load the way the sports-science literature actually models it — training stress scored per run, acute load measured against chronic load, the fitness-fatigue-form curves that let you see whether you're sharpening or digging. That part is table stakes for anyone serious. The part that makes it honest is what the engine is forbidden from doing with it.

Underneath the recommendations sits a small set of rules the engine is not allowed to break, no matter what the optimizer wants. Mechanical risk overrides everything — no goal, no green readiness score, no motivation can override a safety limit. Feeling good can permit the engine to use the day's ceiling; it can never authorize going above it. When you're behind on volume, the engine is barred from making up the gap with intensity — the cheap, tempting, injury-shaped shortcut — and is forced back toward aerobic work instead. No single adjustment is allowed to swing more than a capped fraction of the week.

These read like small print. They're the opposite. They're the software equivalent of a coach experienced enough to hold you back on the day you feel invincible — which is the day you're most likely to hurt yourself. An honest engine has to be willing to tell you no, and it has to be structurally incapable of talking itself out of that no when the numbers get exciting.

Lie #3: “Trust me”

The quietest lie is a recommendation you can't check.

Plenty of apps hand you a readiness score or a suggested workout with no way to see why. You either believe the black box or you don't, and when it's wrong you have no way to tell whether it's wrong about you or just wrong. That's not a relationship you can train on for months.

So every meaningful decision the engine makes writes down its reasoning — the signals it saw, the rule that fired, the version of the logic that produced it — as a record you (and I) can go back and inspect. Recommendations are traceable to the exact rules that made them. And when the engine doesn't have enough data to be confident, it's built to say so rather than fake a number. A new user's first weeks are a cold start — the personal baselines don't exist yet — and honesty means admitting that on the screen, not papering over it with a confident-looking score that's really a guess.

That last part is the whole ethic in miniature. It's easy to make software that always has an answer. It's harder, and more honest, to make software that knows the difference between what it has measured, what it has estimated, and what it doesn't yet know.

What it refuses to be

You can tell what an app values by the flattering lies it declines to tell.

Cadeo has no social feed, no kudos, no segments to chase. It has no body-battery cartoon or single-number "recovery" gauge that reduces your whole physiology to a mood ring. It won't gamify your training into streaks you keep for the app's sake instead of your own. Every one of those features is a small dishonesty — a way of making you feel something the data doesn't support — and each one left out is a lie the engine refuses to tell. The restraint isn't minimalism for its own sake. It's the same principle running the other direction: if it can't be honest, it doesn't ship.

Where this actually is

In the spirit of the thing: Cadeo is early. It's been built and dogfooded against real training — my own, mostly, through real races — and the physiological model underneath it is genuinely deep. But the hardest claim, that this interpretation actually trains you better than the table does, is something I'm still proving, honestly and slowly, against real outcomes. An honest training engine doesn't get to skip that step for itself either.

That's the bet, though, and it's the reason the whole thing is built the way it is. Your body already tells the truth about your training, every single run. Most software just isn't listening carefully enough to hear it. Cadeo is my attempt to build something that does — and that's willing to tell you what it hears, even when the honest answer is I don't know yet.