The first time most people ask an AI to design a workout plan, the results are usually pretty solid. Give it your height, weight, training experience, and goals, and it quickly puts together a well-structured routine.
Training frequency, exercise selection, sets, reps, rest intervals, and even basic dietary advice—it covers all the bases.
The issue usually isn’t the quality of the initial plan. The problem is that, much like any generic cookie-cutter template online, it freezes in time the moment it’s generated.
Real training doesn’t work that way. A bad night of sleep turns an easy warm-up into a grind. A twinge in the knee during squats forces you to swap exercises for the next three weeks. After a few months of consistent lifting, some muscle groups progress rapidly while others don’t budge. A static plan is merely a starting line. A truly valuable coach continuously adjusts based on live feedback—and crucially, remembers what happened in the past.
Workout plans circulating on social media and typical AI chat sessions share the exact same flaw:
Warning They are entirely static.
For anyone using AI, starting a new chat session means re-explaining your body stats, lifting history, old injuries, and goals all over again. Even if your last chat went deep into periodization, the fresh instance is completely amnesic.
If you want an AI to function as a genuine fitness coach, the real challenge isn’t crafting a “god-tier” prompt or generating a fancier day-one routine. It’s building a system where the AI grows alongside your training and retains its contextual judgment across new conversations.
Define the Destination First
Terms like “cutting” and “bulking” sound straightforward, but they are notoriously vague when designing long-term programming. How lean? Which muscle groups need priority? What kind of silhouette are you actually aiming for? Without answers to these questions, an AI can only default to generic, broad-brush advice.
At first, I relied purely on text descriptions. But I quickly realized that visual references establish shared clarity much faster than abstract adjectives. So I put together a moodboard of sorts: my current physique, reference photos across different body fat percentages, and the aesthetic direction I wanted to move toward. Then, I had the AI synthesize a visual target based on these inputs.
The goal wasn’t just generating a cool image, nor was it believing that an AI image could predict my exact biological future. It acted more like an architectural blueprint—a reference point for evaluating where I wanted to go and ensuring the AI and I shared the exact same definition of “the goal.”
When the goal is just “I want to get in better shape,” almost any workout split can be justified. But once it is defined by specific body fat levels, proportional balance, and targeted muscle groups, every programming decision gains clear trade-offs.
For me, that meant maintaining low body fat while building lean mass—with a particular focus on upper chest development—rather than mindlessly chasing a lower scale weight or arbitrary 1RM numbers.
In other words, I don’t let the AI dictate what I should look like. I clearly define the destination first, then let it help me map the best route there.
Give the AI Full Context Before the Plan
So much discussion around AI fixates on prompt engineering, as if discovering the magical phrase will consistently unlock flawless answers. In practice, phrasing rarely makes or breaks the outcome—context does.
A real coach needs to understand the individual before prescribing a single set. AI is no different.
Beyond my height and weight, I fed the AI my age, training history, current physical baseline, previous injuries, available weekly schedule, and my target outcomes for body recomposition.
I specifically highlighted my intent to improve chest aesthetics while emphasizing that safety remained non-negotiable—no aggressive progression that risked aggravating prior injuries.
None of these variables exist in isolation. Age and recovery capacity dictate training frequency; previous injuries dictate exercise selection; real-world availability determines long-term adherence; and body recomposition means the scale alone can’t be the primary metric. Only when combined can an AI make decisions under realistic constraints.
This is why I stopped calling this “generating a workout plan with AI.” Spitting out a list of exercises is the easy part. The real value is getting the AI to make nuanced contextual judgments:
- Should we add weight today?
- Is this exercise still serving its purpose?
- Has cumulative volume exceeded recovery capacity?
- What is the primary bottleneck to address in the next block?
This isn’t prompt engineering; it’s context engineering. A prompt dictates how an AI answers a single query; context dictates whether it truly understands the problem.
Every Session Informs the Next Decision
An initial plan is merely an intention; workout logs reflect reality.
After every session, I log the details into Obsidian: exercises, weights, sets, and reps. Crucially, I capture the qualitative data numbers miss—which rep in a set felt close to technical failure, whether my knees felt achy during squats, how stable my bar path was, and my sleep quality or energy levels that day.
Then, I feed these logs to the AI for post-workout analysis, having it summarize the session and adjust the next workout based on accumulated history.
The loop is simple:
It’s a lightweight system, yet it completely shifts the AI’s role. Instead of being a one-off tool that generates a static routine you rarely change, the AI becomes an active participant in an ongoing feedback loop.
Logging matters not because the act of writing magically builds muscle, but because good decisions require data. Without logs, it’s easy to rely on gut feelings—assuming you’re recovering fine or believing a plateau exists when it doesn’t. With continuous data, AI can place any single workout within a macro trend, separating random noise from meaningful patterns.
Traditional fitness apps are great at storing numbers. They can tell you that you logged 57.5 kg × 10 on a Tuesday and plot a weight curve. But raw numbers don’t explain why things happen.
The exact same entry can mean completely different things depending on context:
Note If performance has climbed steadily over several sessions, it might be time to increase the load.
If reps drop on the same weight after a week of poor sleep and high arm volume, the real culprit is under-recovery.
If knee discomfort flares up consistently after a specific movement, the immediate priority is joint deloading and exercise substitution, not grinding through.
A standard fitness app sees:
57.5 kg × 10
An AI with historical context sees:
Recovery has been suboptimal over the last few sessions; hold off on adding arm volume today.
Monitor knee discomfort closely; temporarily swap out movements that trigger symptoms.
Pulling movements show steady progress; increase load slightly next week.
Both read the exact same numbers, but the latter mimics how an actual coach thinks: it doesn’t just record what happened, it decodes why it happened and what to do next.
Of course, AI analysis is not medical advice, nor can it replace in-person observation from an experienced trainer. It can misinterpret data or offer uncalibrated advice.
When persistent pain or injuries arise, safety and medical professionals come first. I explicitly prompt the AI to prioritize rehabilitation. But for day-to-day logging, autoregulation, and progressive overload, a complete history is more than enough to turn boilerplate advice into deeply personalized coaching.
This brings us to the core philosophy of this workflow:
Important Numbers describe what happened; memory gives those numbers meaning and intent.
Chats End, but Knowledge Must Persist
As workout logs accumulate, any single AI chat session inevitably degrades under token limits and context bloat. The issue isn’t just thread length—it’s that critical signals get buried under hundreds of back-and-forth messages.
Key adjustments, injury flags, and coaching heuristics developed over weeks get lost in the scrollback.
Instead of forcing everything into one infinite chat, I generate a monthly review report at the end of each block, distilling essential takeaways to hand off to a fresh AI session.
This report isn’t a vanity stat sheet of “workouts completed.” It synthesizes the durable context: physique changes, strength progression on main lifts, recovery trends, joint flares, adjustments that worked (or didn’t), and key focus areas for the upcoming month.
At the start of a new month, I spin up a brand-new chat instance, pass in my core profile and the previous month’s summary, and pick up right where I left off. The new session inherits the accumulated wisdom of the old one—much like a coach reviewing a client’s handover notes.
The entire process looks like this:
I think of this as memory transfer. A chat thread terminates, but the intelligence it produced survives. Monthly digests compress history while preserving continuity, saving you from having to re-introduce yourself from scratch.
Without this step, opening a new chat is like hiring a substitute coach who knows nothing about you. With these milestone summaries, it’s like a seamless staff handover: the coach is new, but the playbook remains intact.
Why I Choose Obsidian and Plaintext Markdown
I don’t use Obsidian because of any built-in AI magic. I use it because it runs on local Markdown files.
Plaintext Markdown is lightweight, human-readable, and machine-parseable. My workout logs, monthly reviews, and long-term targets live locally on my own drive—free from proprietary app databases and immune to platform shutdowns. Even if I abandon Obsidian tomorrow, any text editor or future AI model can parse these files effortlessly.
Data ownership is paramount here. Most fitness apps lock your data behind walled gardens. Even if they offer CSV exports, they rarely capture qualitative notes or coaching rationales cleanly. Markdown imposes no vendor lock-in: I can link, search, refactor, and curate exactly what context gets sent to the model.
In this architecture, Obsidian is not the coach, and the AI is not the database. They serve distinct roles:
- Markdown notes store objective facts and historical records;
- Obsidian organizes, connects, and retrieves this information;
- AI acts as the reasoning engine to extract patterns and assist in decision-making.
The local vault serves as permanent memory; the AI is simply a hot-swappable reasoning engine. Decoupling storage from inference means I don’t rely on a single SaaS product to handle logging, analysis, and interaction, nor do I trap my entire history inside a single chat window.
The System Outlives the Model
I originally processed my training logs inside Google AI Studio, but have since transitioned to using WorkBuddy to read local Obsidian notes and analyze them across different LLMs. Each model has its own reasoning quirks, context window strengths, and analysis style. But because the training history remains in my hands, switching models never means starting over.
This shifted my perspective on what truly matters in long-term AI workflows.
Frontier models evolve at breakneck speed. Today’s top-tier model gets superseded in a matter of months or weeks. SaaS tools frequently alter pricing, rate-limit features, or tweak data policies. If your personal system is anchored to a specific platform’s chat history, migration is excruciatingly painful.
But when memory lives independently, models become interchangeable lenses. A new LLM can ingest the same Markdown archive, grasp months of training history, and resume analysis seamlessly. It might provide fresh perspectives, but you never have to re-explain who you are or risk losing key training insights.
The real moat isn’t the model you use—it’s the curated personal context you build over time.
Important Models are replaceable; memory should be permanent.
This principle extends far beyond fitness. Any domain requiring long-term compounding feedback—learning, writing, health management, or personal projects—faces the exact same bottleneck:
Important A one-off prompt can produce a clever answer. But if you have to re-explain the entire premise every time, AI remains a temporary assistant. Only when context compounds over time can AI participate in higher-order, long-horizon decision-making.
The Semi-Automated Reality
While this setup works smoothly, it is not yet 100% automated.
Post-workout, I organize my notes in Obsidian and paste relevant snippets into the AI prompt. At the end of each month, I prompt the AI to generate a retrospective report and save the output back into my vault.
The ideal workflow would be more frictionless:
Moving forward, I plan to leverage plugins, local scripts, or APIs to automate the copy-pasting so that newly logged workouts flow directly into analysis pipelines upon saving. However, full automation isn’t about surrendering all agency. In physical training, human intuition is irreplaceable—feeling daily fatigue, listening to joint feedback, and critically evaluating AI suggestions.
If logging requires too much friction, consistency falls apart. But if switching models requires re-formatting your entire history, context gets siloed. The goal of automation should simply be to let data flow effortlessly into long-term memory while keeping you firmly in control of the data, the conclusions, and the final decisions.
It Was Never Just a Workout Plan
When I started, I just wanted AI to write me a better workout routine. Over time, I realized that exercise splits and rep schemes are the least interesting parts of the equation.
AI excels at generating immediate answers, but those answers are ephemeral. If it has no concept of what happened yesterday or why you deloaded last month, it remains nothing more than a glorified, fast-typing chatbot.
Everything changes when every session is recorded, every training block is synthesized, and new models can inherit established context.
Each workout gains memory; each month builds history; experience compounds instead of resetting to zero.
That’s when it clicked: I hadn’t just engineered a better prompt. I had built a coach that actually remembers me.