AI Prompts for Running Coaches: A Real Workflow for Endurance Programming

If you coach runners, you've probably tried ChatGPT and walked away with something useless. You typed "write a 16-week marathon plan for an intermediate runner" and got back a Hal Higdon clone with the mileage rounded to whole numbers and zero awareness of your athlete's actual fitness, race calendar, or history with injury. You could have copy-pasted the same plan off a search result.

Here's the thing: the AI didn't fail. You gave it a generic prompt, and it gave you a generic plan — the one that ranks first when somebody Googles "intermediate marathon training plan." Endurance coaching has a problem that strength sport doesn't: a huge amount of the public-facing content is written for runners self-coaching, not for coaches managing 20 or 30 athletes at different points in different cycles. Search any model for "marathon prompts" and you'll see what I mean — it'll happily talk to your client. It won't talk to you.

This guide is for coaches who actually want to use AI as a drafting layer for endurance programming. You bring the athlete history, the race date, the injury background, the realistic weekly window. AI builds the structure. You finish the plan.

Why generic AI advice breaks down for endurance

Strength programming is forgiving in one direction: if you write 4 sets of 8 instead of 4 sets of 10, your hypertrophy client still grows. Endurance programming is forgiving in a different direction — most healthy adults adapt to most reasonable mileage if you don't break them — but it's unforgiving about the variables that matter most. Specifically:

• Volume tolerance. Two runners with identical 10K times can have wildly different sustainable peak mileage. One handles 70 miles a week with no soft-tissue issues. The other gets a tibial flare at 45. The AI has no way to know which one you have.
• Intensity distribution. The polarized vs. pyramidal debate doesn't get solved with a default. Your athlete's history says which one is going to work.
• Race specificity. A flat road marathon, a hilly trail 50K, and a 1500m on the track look completely different in the last 8 weeks. Generic plans mash them together.
• Recovery floor. A 42-year-old parent with two kids and a stressful job does not adapt to back-to-back hard days the way a 24-year-old does. The AI will happily prescribe both the same.
• History with injury. Stress fracture two years ago, plantar fascia flare last summer, IT band issue when mileage gets above X. These are the constraints that should shape the plan from week one.

A model with none of this information will write something that looks like a plan. It will not be your athlete's plan. The fix isn't a better model. It's better inputs.

The four contexts the AI needs before it writes anything useful

Most coaches give ChatGPT half a sentence — "write me a marathon plan for a 3:30 goal" — and judge the output. Don't. Build a context block once per athlete and reuse it. Four chunks:

1. Athlete profile. Age, sex, training history (years running, lifetime peak mileage, lifetime peak weekly long run), current best times at relevant distances with dates, current fitness window (last 8–12 weeks of weekly mileage), terrain access (track, hills, treadmill, trails), and footwear/orthotic notes if relevant.

2. Race context. Goal race in absolute date terms (the week of), goal time or goal outcome (some runners just want to finish well — that's a different plan), course profile (elevation, terrain, climate), and any A/B/C race calendar around it. If there's a tune-up race in the build, the model needs to know.

3. Recovery floor and constraints. Sleep average, work intensity, parenting/caregiving load, willing weekly time investment (be honest — saying "10 hours" when the runner only ever does 6 is how plans collapse). Equipment access on each day. Whether they're cutting weight or stable.

4. Injury history and red flags. Past stress fractures (and where), tendon issues, recurring soft-tissue problems, what mileage threshold has previously preceded a flare. This is the most important chunk and the one most coaches skip. The AI cannot read tea leaves; you have to spell it out.

That's the input. Build it once in a Google Doc, or — if you're a Claude user — a saved project with that document permanently attached. Paste it into every prompt. Now the AI has something to work with.

A side note on tooling: for endurance work, I've found Claude handles long context (and the iterative back-and-forth of refining a plan over 16 weeks) noticeably better than ChatGPT, especially when you paste a multi-week training log mid-conversation and ask it to react. ChatGPT is fine for the first-pass skeleton. We covered the broader trade-offs in ChatGPT vs Claude for fitness coaches — the gist applies here.

Prompt 1: The macro structure

Use this when you're starting a new build. The goal isn't a finished plan — it's the skeleton: phases, peak weekly volume, where the long runs land, where workouts are clustered, and where you taper.

You are an endurance running coach designing a [N]-week build for the
following athlete. Output a week-by-week macro structure, not session-level
detail.

[Paste your athlete profile, race context, recovery floor, and injury
history from the four-chunk template.]

For each of the [N] weeks, output:
- Phase name and intent (base, build, race-specific, taper)
- Total weekly volume (mileage or time)
- Long run distance/duration
- Number of quality sessions and their general type (threshold, VO2,
  marathon-pace, hill, long-run progression)
- Easy mileage volume
- Whether it's a recovery/down week and the % reduction
- Any tune-up race or testing slot

Do NOT write individual sessions. I'll fill those in. Format as a table I
can paste into a spreadsheet.

What you get back is a structure. It'll be 75% right and 25% wrong. The wrong parts are usually: peak mileage set too high relative to the athlete's lifetime base, recovery weeks placed on a generic 3:1 pattern instead of around your athlete's actual rhythm, and quality sessions clustered too aggressively in race-specific weeks.

That's fine. Your job is to fix the 25%. The AI just saved you 90 minutes of staring at a blank spreadsheet.

Prompt 2: Weekly intensity distribution

Most endurance coaches think in zones — easy, steady, threshold, VO2, race-pace — even if they label them differently. The hard part of week-by-week planning isn't picking the workout. It's making sure the distribution across the week is sane: enough easy volume to drive aerobic adaptation, enough quality to drive specific adaptation, and enough recovery between hard efforts that the athlete shows up rested for the next one.

Use a prompt like this once the macro is locked:

Given the macro structure above and the athlete's profile, write the
specific session schedule for week [X]. The week's targets are:

- Total volume: [X] miles
- Long run: [X] miles at [pace or effort]
- Quality sessions: [N] — types: [threshold / VO2 / marathon-pace / etc.]
- Easy mileage to fill: [X] miles across remaining days

The athlete's days off and short-day constraints are:
[list]

For each day, output:
- Session type
- Duration or distance
- Target pace zones (use the athlete's current paces from the profile)
- Notes on terrain, surface, or effort cues

Respect a minimum of 48 hours between hard sessions. Honor the 80/20
easy/hard split unless the athlete profile indicates otherwise.

This one is high-leverage. Done well, it turns a 30-minute weekly planning task into 8 minutes of editing. Done poorly — i.e., without the constraints block — it gives you something that looks plausible but stacks a tempo on Friday and a long run on Saturday in a way that no real coach would do.

Prompt 3: The taper

Tapers are where AI is most useful and most dangerous. Useful because the principles are well-documented (drop volume by 30–50% over 2–3 weeks while preserving intensity, sharpen with race-pace work, prioritize sleep and freshness over fitness). Dangerous because if the AI doesn't know your athlete's history with tapering, it'll write a generic one — and tapers are personal.

Some runners feel terrible if you cut volume by 50% in the final week. Others need that cut to show up fresh. Some lose feel for goal pace without one final harder session 5 days out. Others sharpen perfectly on easy mileage alone. None of this is in the literature in a way a model can reason about. It's in your notes from the last taper.

Prompt template:

Design the final [2 or 3]-week taper for the athlete above, leading into
[race date] at [race distance and goal time].

Athlete's prior taper history:
- [Race + year]: tapered [N] weeks, volume reduction [X]%, kept/dropped
  goal-pace work, race outcome relative to fitness was [as expected /
  flat / sharp].
- [Repeat for any other relevant prior races.]

The taper must:
- Reduce volume progressively across the [2 or 3] weeks
- Preserve at least [1 or 2] sessions touching goal pace
- Keep easy runs short and frequent
- Include a final session [X] days out that gives the athlete confidence
  without accumulating fatigue
- Account for travel/time-zone if I flag it: [yes/no, details]

Output the daily session list for each taper week with the same format
as the weekly schedule prompt.

Honest disclaimer to give the model — and yourself: the taper is the place where the athlete's nervous system and self-perception matter more than the volume math. Use the output as a draft. The final call is yours.

Prompt 4: When the plan needs to change

A build never goes 16 weeks without something going sideways. A travel week appears. The athlete reports calf tightness that's been creeping in for 10 days. A scheduled tune-up race gets canceled. The hard skill is rebuilding the plan around the disruption without losing race readiness.

The mid-cycle adjustment prompt:

The athlete is currently in week [X] of the [N]-week build above. Here is
what's happened since the plan started:

- [Brief week-by-week summary: actual sessions completed, modifications,
  and any flags from check-ins.]

Current situation:
- [Describe disruption: injury flag, schedule change, missed workouts,
  fitness check result, etc.]

Reassess the remaining [N-X] weeks. Specifically:
- Adjust upcoming volume and intensity given the current situation.
- If the goal time needs to be revisited, say so and propose a new goal.
- If a planned session needs to be replaced, replace it and explain why.
- Flag anything you think I should bring up with the athlete.

Be conservative on the side of avoiding injury. Volume can always be
added back. A flared tendon takes 6 weeks.

This is where having the entire training history in the conversation context matters most. The model can only reason from what it's been shown. If you've been keeping a single document with the original plan, the weekly check-ins, and the actual mileage logged, this prompt becomes one of the most valuable things AI does for a coach. If you haven't, you're asking the model to invent context. Don't be surprised when it does, badly.

Where AI breaks down (and what you keep)

A few places to be clear-eyed about:

Reading an athlete who's struggling. A check-in that says "felt heavy on the long run, motivation dropping" needs a human read. Use AI for the math; keep the meaning to yourself. We wrote about where coaches actually lose time and which parts are worth automating — the meaning-reading parts aren't.

Niche populations. Pregnancy, post-partum, peri-menopausal, masters runners with cardiac history, athletes returning from a stress fracture. A general-purpose model is the wrong tool. Stay in your scope; refer when needed.

Race-day strategy. Pacing into hills, fueling under heat, choosing where to surge. The AI can write a generic pacing plan. It can't sit at the start line with the athlete. That's coaching.

The athlete's relationship to the plan. Some runners need to see every week. Others need to see two weeks at a time and trust the rest. That's a delivery question, not an AI question, and it depends on the human in front of you.

What AI does well, used right: it eats the 30 minutes of structural planning per athlete per week and gives you back the time you actually want — the time spent talking to runners.

Or grab the free AI Programming Playbook — 10 starter prompts and an intro to the SCRIPT framework, no email required for the basics.

Frequently Asked Questions

Will ChatGPT or Claude give me the same plan every time?

No, and that's part of the point. Same prompt, slightly different output. This is why you build the context block — to constrain the variability down to the things you don't care about (phrasing) while keeping the things you do care about (structure, volume, intensity) consistent. If you want exact reproducibility, write the plan in a spreadsheet.

Can I use AI to generate paces from a recent race result?

Yes, and it's better than most pace calculators because you can layer in fatigue context and terrain. Be explicit about the race conditions (heat, course profile) when you ask.

Is there a runner-specific AI tool I should use instead?

Some exist, and a few are good for athlete-facing self-coaching. They aren't built for a coach managing a roster. The general-purpose models, with your context block, will outperform them for the coaching workflow described here.

What about Strava data — can I paste that in?

You can paste activity summaries (distance, pace, heart rate averages, perceived effort). For privacy and signal-to-noise, don't dump the raw GPS data. A 4-line weekly summary per session is enough.

How long does this actually save me per athlete per week?

For a coach with a solid context block and a saved prompt library, it's typically 20–30 minutes per athlete per week — most of which gets spent on macro restructuring and mid-cycle adjustments. The session-level writing is where the biggest savings show up.