I shipped eight short videos in one week. Here's the hour-by-hour journal.

Seven days. Eight episodes published across six platforms — forty-eight effective publications. Three hours twenty minutes of cumulative human work, excluding script writing. What follows is the exact hour-by-hour journal of the week of June 15-21, 2026, on the WhyFactory channel.

I'm telling this story for two reasons. First, because the headline numbers I usually quote ("eighty episodes per month", "a hundred and twenty hours of work") are smoothed averages that hide the daily reality. Second, because I wanted to verify for myself whether my pipeline held the cadence without breaking — empirical check of an assertion I've been repeating for six months.

Partial spoiler: it held, but with three friction moments I hadn't anticipated.

Monday June 16 — 1h45 cumulative

Up at 7:30. Coffee at 8. I spend twenty minutes reviewing the prioritized WhyFactory backlog in Notion. The production calendar called for seven episodes; the personal target was to ship eight to validate the higher cadence. I select subjects based on thematic rotation (alternating tech-object / everyday-symbol / common-word) and lock the list at 8:25.

Episodes selected for the week:

1. Why the snooze button is nine minutes (tech-object)
2. Why McDonald's has a yellow M (everyday-symbol)
3. Why we say "Hello" on the phone (common-word)
4. Why nuts are hexagonal (tech-object)
5. Why the Stop sign is red AND octagonal (everyday-symbol)
6. Why we say "OK" (common-word)
7. Why seven days in a week (time-object)
8. Why twenty-four hours in a day (time-object)

The first act of the day is writing the script for episode 02 (Pringles has been on hold since Friday). Fifty minutes to produce a locked script: eight segments, four hundred spoken words, two cascading twists in the first eight seconds. Kokoro iterations between each pass — nine full renders, three minutes of cumulative compute for the iteration loop.

At 9:50, the script is locked. I launch the F5 local render for montage validation, which runs in the background while I move on. Announced duration: 28 minutes.

In the meantime, I begin writing the script for episode 03 (snooze). Thirty-five minutes. Script locked at 10:30.

At 10:30, F5 has finished. I open the HyperFrames pre-edit to verify prosody. Only one touch-up needed in segment 4 — a comma to add to lighten a sentence that ran dense. Kokoro re-render on the isolated segment, ten seconds. F5 re-validation on the segment only, two minutes. Good.

11:00. I launch the ElevenLabs production pass on episode 02. One cycle, sixty seconds of render. Credits consumed: twelve cents.

11:05. The ElevenLabs render returns clean. I launch npx hyperframes render on the composition. Three minutes twenty of compute. While it spins, I start the script for episode 04 (McDonald's).

11:08. The final MP4 sits on disk: renders/ep10-pringles.mp4. I switch to Claude Code and launch the MCP publication sequence. Six minutes to prepare the six per-platform captions, create the publication, schedule the staggered times and approve. Effective publication scheduled for Tuesday 9 UTC on YouTube/TikTok/Threads, Tuesday 11 UTC on Instagram, Tuesday 14 UTC on Facebook, Tuesday 8 UTC on LinkedIn.

11:14. Episode 02 (Pringles) wrapped. First hour of the week officially productive. I return to the episode 04 script.

Monday cumulative: 1h45 of work, 1 episode shipped.

Tuesday June 17 — 3h30 cumulative

Up at 7:45. Coffee at 8:15. I spend thirty seconds verifying that episode 02 went live overnight across the six platforms. Statuses: all PUBLISHED. The six URLs are accessible in Claude Code via a simple get_publication_status query. No hitch.

8:20-9:00. I finish the episode 03 script (snooze) started yesterday. Four hundred ten words, seven segments. I break part of my standard protocol on this script — I forget to validate the token alignment between displayed and spoken text on segment 5 (which contains the number "nine minutes"). The Python generator will catch the error at generation time and I'll lose ten minutes correcting.

9:00. Launch the F5 render for episode 03. Move to the episode 04 script (McDonald's).

9:45. F5 finishes. Validation: prosody is correct, but a phantom "uh" in segment 2. I modify the script (eliding a filler word that was forcing the hesitation). F5 re-render on the isolated segment, two minutes. Good.

9:50. ElevenLabs production. Sixty seconds. This is where the Python generator throws a warning: "caption alignment mismatch on segment 5: 4 displayed tokens vs 2 spoken tokens; uniform distribution applied". I look at the script. Yes — I'd written "9 minutes" (2 tokens) displayed but requested "nine-minutes" (1 token) in TTS. Rookie mistake.

I correct: "nine" displayed, "nine" spoken. Aligned. Kokoro + F5 + ElevenLabs re-render on the segment, about eight minutes of cycle. Total extra cost: thirty cents of ElevenLabs.

10:00. Final MP4 is clean. HyperFrames render, MCP publication. Episode 03 (snooze) wrapped at 10:08.

10:08-12. Episode 04 (McDonald's) script locked at 11. Episode 05 (Hello) script locked at 12. No friction.

Afternoon: break. The morning's cadence is enough for the week; no need to do everything in one block.

Tuesday cumulative: 1h45 on the day, 3h30 on the week, 2 episodes shipped (snooze, McDonald's in progress).

Wednesday June 18 — 5h cumulative

Up at 8. Same routine. In the morning, I wrap episode 04 (McDonald's) in forty minutes, no surprise. MCP publication at 9:20. Episode 04 wrapped.

At 9:30, I start episode 05 (Hello). The script is already written (locked last night). I go straight to Kokoro for quick validation, then F5, then ElevenLabs. HyperFrames render, MCP publication. Episode 05 wrapped at 10:45.

Twenty-minute break. I step out for coffee.

11. I start episode 06 (hexagonal nuts). First serious friction of the week: the Python generator crashes mid-render with an incomprehensible error — KeyError: 'video_url' somewhere in the Pexels transfer layer. I debug for thirty minutes. Final cause: an upstream format change in the Pexels API response (key renamed from url to video_url on Pexels side). Quick fix in the code, venv redeploy. Twenty minutes erased without productive contribution.

12. I relaunch the render. Everything runs. Render + MCP publication. Episode 06 wrapped at 12:40.

Wednesday cumulative: 1h30 on the day + 30 min debug, 5h on the week, 5 episodes shipped.

Thursday June 19 — 6h45 cumulative

Quiet day. I write the script for episode 07 (Stop) in the morning, render it following the standard routine, publish it. No hitch. Ninety minutes of effective work. Episode 07 wrapped at 11.

In the afternoon, I move to the script for episode 08 (OK). Wikipedia source reading, iterative writing, lock. Forty-five minutes.

Thursday cumulative: 2h15 on the day, 6h45 on the week, 6 episodes shipped.

Friday June 20 — 8h30 cumulative

The moment the cadence becomes heavy. By this stage I start feeling the cumulative effect of having written five scripts in four days. Early-afternoon concentration slips: I re-read the episode 08 (OK) script three times without finding a problem, then validate it, then find an obvious problem ten minutes later. The script had a cadence flaw in segment 6 (a too-long sentence that was derailing before the twist).

I clear the flaw, re-render, publish. Episode 08 (OK) wrapped at 14.

15-16:45. I start episode 09 (seven days). Script locked. Render. Publication. Episode 09 wrapped at 16:45.

Friday cumulative: 1h45 on the day, 8h30 on the week, 8 episodes shipped.

Theoretically, the week's target is met. But I wanted to push eight publishable — so I continue on the eighth Sunday morning to lock the cadence just before attacking the next week.

Saturday June 21 — 8h30 cumulative (off day)

No work on the channel. Genuinely none. I noticed too late in my early production months that off days are as necessary as production days. I message friends, I walk, I read a book that has nothing to do with WhyFactory. If I skip this, the following Monday I drag.

Sunday June 22 — 10h cumulative

Up at 8. Coffee. I start the eighth episode of the week at 8:30 — the one that wasn't strictly necessary but that I wanted to ship to validate the eight-cadence.

Script locked at 9. Full pipeline in sustained mode: Kokoro → F5 → ElevenLabs → render → MCP publication. Episode 10 (twenty-four hours) wrapped at 10:30.

10:30. I close the terminal. Eight episodes shipped in seven days. Three hundred twenty minutes of cumulative human work. That's an average of forty minutes per episode.

What this week surfaced

First, the Wednesday Pexels friction. An upstream API change cost me thirty minutes of debug in the middle of the cadence. I hadn't set up automatic monitoring of API changes upstream of the pipeline. From now on, I have a daily smoke test that checks the health of each external dependency — Pexels, ElevenLabs, Shortflow MCP, Wikimedia. Five minutes per day to save thirty on incident day.

Then, Tuesday's token alignment error. Thirty cents of wasted ElevenLabs, ten minutes of correction. Negligible in absolute terms, but the symptom is interesting: across seven consecutive episodes on a sustained cadence, I skipped a step of my standard protocol. I now know that step must be an automated commit hook, not manual discipline.

Finally, Friday's concentration drop. That's the most important signal. The technical pipeline can hold eight episodes per week; the human creator probably can't, at least not indefinitely. My production plan for following weeks now caps at six episodes per channel per week, with two sanctuary off days per week. The risk I prefer to take is under-cadencing; the risk I no longer want to take is burning motivation.

The recap table

| Day | Episodes shipped | Effective work | Week cumulative | |---|---|---|---| | Monday | 1 | 1h45 | 1h45 | | Tuesday | 2 | 1h45 | 3h30 | | Wednesday | 3 | 1h30 + 30 min debug | 5h30 | | Thursday | 1 | 2h15 | 6h45 | | Friday | 1 | 1h45 | 8h30 | | Saturday | — | — | 8h30 | | Sunday | 1 | 1h30 | 10h |

Eight episodes, ten effective hours, six platforms, forty-eight scheduled publications without opening a single dashboard after the initial configs.

The lesson that outlasts the rest

The pipeline holds what it says. Forty minutes per episode is a number that has nothing of the marketing pitch about it: it's the median measured to the minute. But those forty minutes aren't constant. There are days at thirty minutes (Tuesday, Thursday), there are days at seventy-five minutes because an API breaks (Wednesday). Sustainable cadence isn't average cadence — it's the cadence that holds despite unpredictable friction.

In my measure, that's forty-two minutes in safety, sixty-five in stress. Plan accordingly.

---

To automate the multi-platform publication layer — the one that let me hold six platforms × eight episodes with no manual intervention after the initial configs — that's exactly what Shortflow does. Creating an account opens a seven-day free trial.