The coach that revises when you do.
Most plans are a PDF that judges you. This one is a living plan inside your chat. It builds a periodized block for any race from 10k to Ironman, then rewrites itself the moment you report what you actually did.
A plan is only as good as its next revision.
The model does the coaching conversation. The connector does what a model cannot do reliably: hold a structured plan, compute the delta when you log a session, and apply a codified ruleset to revise it. You talk. It re-plans.
What actually happened
No forms. Tell it in a sentence, the way you would tell a coach.
"Did 36 km in 1h30 instead of the easy spin, felt comfortable."
The plan moves
It flags ahead_of_base, bumps the long-ride target toward peak, and pulls your first brick session earlier.
Revision logged with a reason you can read: your base is ahead of the plan.
Assess. Build. Adapt. Repeat.
Three moves, one continuous loop. The plan is structure and targets; the model handles pace, feel, and nuance in conversation.
Assess
It turns your plain-language intro into a structured profile and asks only the one to three questions it still needs. Honest hours, real baselines, no quiz.
Build
A six-phase periodized plan: Foundation through Taper, a step-back every fourth week, a rest day every week, and a long session that grows toward a race-specific peak.
Adapt
Log a session and it surfaces a signal. Performance, missed, disruption, weight, or pain, each one maps to a rule that revises only what is ahead, never stacking lost work.
From a first 10k to a full Ironman.
Run-only for road races, full swim, bike, and run for triathlon. Each distance carries its own minimum block length, taper, and peak targets.
Everything the model needs, nothing it does not.
Tool calls only. No accounts, no database, no data at rest. The conversation carries the state; you can export it to a string and paste it back anytime.
The generator
Periodized phases, weekly session mix, step-backs, taper, and a weight path that reaches goal before peak load. The hard part, done in code.
The engine
Reads a trigger and the recent log, applies a tunable ruleset, revises only the upcoming sessions, and returns a reason for every change.
The intake
Plain language to a structured profile, plus the questions still missing.
The signal
Actual against prescribed, with flags raised for the model to act on.
The why
Purpose and cues for any session. Beginner swim guidance is first-class.
Fuelling and recovery
Eating around training, safe weight change, sleep, and race week, always guardrailed and never a crash deficit.
Portability
Save the whole plan as a string outside the chat, paste it back later, and pick up exactly where you left off. Stateless by design.
Five ways real life hits a plan.
Each trigger maps to a codified action with a reason the model speaks back to you. Tunable in config, enforced in code.
The plan will not let you hurt yourself to hit a number.
The guardrails run in code on every build and every revision. They are not suggestions to the model; they are limits the model cannot cross.
- Weekly volume jumps capped at 10 percent through the build phases.
- At least one full rest day in every single week.
- No weight deficit above 0.5 kg per week, and none during peak load.
- Taper volume is protected and never re-inflated by later logic.
- Any pain report strips intensity from the next sessions, automatically.
- Chest pain, sharp pain, or under-fuelling routes you to a professional.
Start where you are.
Add the connector in Claude or ChatGPT, say hello, and tell it what you are training for. The first plan lands in the same chat.
In Claude: Settings, Connectors, Add custom connector, paste the URL, auth none. In ChatGPT: enable Developer Mode, then add the app with the same URL.