Designing a Program Builder for Real Training (Not Just Pretty Screenshots)

1. The gap between screenshots and reality

If you scroll through SaaS landing pages, almost every coaching app shows the same thing:

• Beautiful cards with a single “Workout of the day”.
• Clean typography, big numbers, minimal UI.

But if you’ve ever run serious programming for functional or performance clients, you know:

• You’re not just writing “Workout of the day”.
• You’re juggling cycles, testing weeks, deloads, multiple tracks, and individual tweaks.

The result is a gap:

• The UI looks nice in a single screenshot.
• It starts to crack the moment you try to live inside it every day as a coach.

2. What real training actually looks like

For modern performance coaches, a “simple” week can include:

• Strength progressions (squats, pulls, presses) with tempo and percentages.
• Conditioning pieces (EMOMs, AMRAPs, intervals, long metcons).
• Skill work (gymnastics, specific movement patterns).
• Accessory work to support the main lifts.

Sessions themselves are rarely “one block, one exercise”:

• Warm‑up → activation → main lift → secondary lift → conditioning → cool‑down.
• Or: strength piece → EMOM → accessory circuits.

Good programming is messy in structure but precise in intent. Any serious program builder has to embrace that complexity instead of pretending it doesn’t exist.

3. Principles for a real program builder

When we started working on Jimmy’s builder, we set a few design principles:

1. Weekly first, not daily
   Coaches think in weeks and blocks. The builder has to reflect that by default.
2. Blocks, not walls of text
   Programs are made of blocks (strength, conditioning, skill, etc.) that can be moved, duplicated, or edited quickly.
3. Flexible quantities
   The system must support reps, meters, calories, seconds, minutes, rounds — without forcing coaches into one rigid pattern.
4. Free‑text allowed everywhere it matters
   Coaching requires nuance: whiteboard notes, cues, context. There has to be room for that.
5. Recognize real‑world patterns
   EMOMs and similar structures are standard for modern coaches. The builder should understand and support them natively.

We didn’t want to “educate” coaches into a new style of programming. We wanted to build a tool that fits the style they already know works.

4. Weekly view: the coach’s cockpit

The first big decision: Jimmy’s builder is weekly by design.

Instead of:

• “Create a workout → assign to a day → repeat 7 times”,

we start with:

• “Here’s your week. Let’s build it.”

This gives coaches:

• A clear sense of load and density across days.
• A smoother way to create progressions and waves.
• Faster editing when something needs to move (e.g. a heavy day after a tough metcon).

A weekly view is not just a UX preference — it’s an expression of respect for how serious coaches actually plan.

5. Blocks you can drag, drop, and reuse

Within that weekly view, sessions in Jimmy are built from blocks:

• Strength block.
• Metcon / conditioning block.
• EMOM block.
• Skill / accessory block.

Each block can be:

• Reordered within the same session.
• Duplicated to another day or week.
• Edited without rewriting the entire workout.

This lets coaches:

• Build templates (e.g. “Monday strength + short metcon”, “Friday test workout”).
• Iterate quickly when feedback or performance indicates that something needs to change.

Compared to typing everything in one text box in a spreadsheet, blocks give structure without taking away freedom.

6. Flexible quantity fields that don’t fight you

Rigid quantity fields are one of the fastest ways to frustrate a coach.
If an app only accepts “sets x reps” or “time”, real sessions become a hackathon.

In Jimmy, quantity fields are designed to be coach‑friendly:

• Reps, meters, calories, seconds, minutes — all valid.
• You can write “5 x 400m”, “10 min EMOM”, “15 kcal” or “4 rounds” in ways that feel natural.

The system doesn’t try to over‑police how you express work. Instead, it:

• Gives you clear slots (exercise, prescription, notes).
• Lets you write in a way that your clients will understand.

7. EMOMs and structured prescriptions

For many modern coaches, EMOMs and similar formats are not “advanced extras” — they’re staples.

That’s why we’re designing Jimmy to:

• Support EMOMs as first‑class citizens.
• Use patterns like “every X for Y” to describe work (e.g. “Every 2:00 for 10:00”).

Instead of forcing coaches to:

• Either fake EMOMs as “5 sets of 2 minutes”, or
• Explain the entire structure in one giant text field,

we want the builder to:

• Understand that “every 2:00 for 10:00” means 5 intervals.
• Present the workout to clients in a clear, EMOM‑friendly layout.

This is where we see a lot of potential for intelligent parsing:

• If a coach writes a structured line in a certain way, Jimmy can help format it cleanly without changing the meaning.

8. Whiteboard blocks for the human part

Not everything in a workout should be “structured data”.
Sometimes coaches need to say:

• “Move smooth, stay aerobic.”
• “This is a test, don’t game it.”
• “Scale to something you can keep unbroken.”

If the builder doesn’t give them space for these notes, they will:

• Stuff them into exercise names.
• Write them in external messages.
• Or skip them entirely.

That’s why we added whiteboard‑style blocks in Jimmy:

• Pure free‑text zones inside the session.
• Perfect for complex pieces, context, or mindset cues.

This respects the reality that coaching is not just sets and reps; it’s communication.

9. Recognizing how coaches actually name things

Another small but important detail: language.

Coaches don’t always write exercise names the same way:

• “Rower” vs “rameur”.
• English vs local language.
• Abbreviations or slang.

We’re designing the builder to:

• Recognize common synonyms and variations (e.g. “rower” / “rameur”).
• Make it easy for coaches working in bilingual or multilingual contexts.

Again, the goal is not to force a single “perfect” naming convention, but to support what coaches already do in real life.

10. Why this level of detail matters

From the outside, a lot of these choices sound like “nice touches”.
From the inside, they are the difference between:

• A tool you endure because your clients are in it.
• A tool you actually enjoy using because it matches your brain.

For coaches, this means:

• Less time fighting the interface.
• More time thinking about athletes and clients.
• Easier scaling as client numbers grow.

For clients, it means:

• Clearer sessions.
• Fewer misunderstandings about what to do.
• More consistent programming week after week.

We don’t want Jimmy’s program builder to win “best UI on Twitter”.
We want it to win in the only place that matters: the everyday lives of coaches who program serious training.