Terminal showing automated YouTube Shorts pipeline commands with fetch-fixtures, encode-short and upload-short output

Automating my son's YouTube with Python and FFmpeg

My son Ben is 12. Back in August he decided he wanted to start a YouTube channel. We talked about what it could be and he landed on Premier League score predictions. Every gameweek he'd predict the scores for all 10 matches, record himself talking through his picks, then after the weekend we'd see how he did and record a review.

Simple concept. He was into it. I was into it. Let's go.

The manual era

The first video was recorded in the car on the drive home from France. I'd knocked together a Keynote presentation on my iPad with the fixtures for Gameweek 1. Team names, badges, blank spaces for Ben to write his predictions with Apple Pencil while screen recording. It was rough, but it worked. He recorded his picks, we uploaded it, and Ben's PL Predictions was born.

The workflow went like this: I'd create the Keynote slides manually, Ben would screen record on the iPad, I'd trim the video in iMovie, adjust the audio levels and brightness, then upload to YouTube Studio and fill in the title, description, and tags by hand.

For the review video I'd do the same thing again, but this time with actual results filled in and a little thumbnail showing what he'd predicted, so viewers could see both side by side as he talked through each result.

It was taking me about an hour on a Friday evening or Saturday morning. Not terrible, but I could feel the fragility of it. Ben was being consistent, recording every week without fail, and I didn't want me to be the reason he couldn't get a video out. If I was busy, or forgot, or just didn't fancy spending an hour creating slides and editing video, his streak would break. That didn't sit right.

JSON and Python: the first automation

After a couple of weeks I rebuilt the system. Instead of manually creating Keynote slides, I set up a JSON data model for each gameweek (fixtures, predictions, results, points) and wrote a Python CLI using Click that generates PowerPoint presentations from the data. The slides get copied to iCloud so they appear on the iPad automatically.

{
  "league": "EPL",
  "season": "2025-26",
  "gameweek": 30,
  "matches": [
    {
      "home": "ars", "away": "eve",
      "prediction": {"home": 2, "away": 0},
      "result": {"home": 2, "away": 0},
      "points": 3
    }
  ]
}

The scoring is simple: three points for an exact score, one point for the correct result (home win, away win, or draw), zero for wrong. The CLI generates prediction slides with blank scores for Ben to write on, and review slides with actual results, points, and a thumbnail of his predictions.

This got my weekly time down from an hour to about thirty minutes. Create the JSON with fixtures, run the command, copy to iCloud. After matches, add results, run the review command. Better, but I was still manually typing fixtures, manually watching his video to work out what he'd predicted, manually looking up results, manually editing in iMovie, and manually uploading to YouTube. Five of those steps are things a computer should be doing.

Automating everything else

I've just finished building the next phase, removing every remaining manual step. It's ready to go from the Gameweek 31 review and Gameweek 32 onwards. Here's what the pipeline looks like.

Fixtures from the FPL API

No more manual data entry. The Fantasy Premier League website exposes an undocumented API that the community has been using for years. It provides fixture data per gameweek, free, no authentication required.

$ python cli.py fetch-fixtures -w 31
Fetched 8 fixtures for GW31

The CLI maps FPL's numeric team IDs to our registry, handles postponed matches and writes the gameweek JSON automatically. It's worth noting this is an unofficial API with no formal terms of use for developers. For a personal project making a handful of calls per week, the risk is negligible, but it's not something I'd build a commercial product on.

Video transcription with Whisper

This is the one that surprised me most. After Ben records his prediction video, OpenAI's Whisper runs locally to transcribe the audio, then a regex parser extracts his predicted scores by matching them to fixtures by team name.

$ python cli.py transcribe -w 31
 1 | Bournemouth  | Man United  | 1 - 1  | matched
 2 | Brighton     | Liverpool   | 2 - 1  | matched
 ...
Matched 8/8 fixtures
Save these predictions to the gameweek JSON? [y/N]: y

It handles colloquial names like "Spurs," "Palace," and "Forest", and works out which score belongs to home and away based on context. I run the Whisper medium model with an initial prompt containing all 20 Premier League team names, which dramatically improves recognition accuracy. I tested it against Ben's existing recordings and it matched all predictions correctly: 10/10 for GW30 and 8/8 for GW31.

It asks for confirmation before writing to the JSON, so there's always a human check.

Results from the API

Same FPL endpoint, different data. After the weekend's matches:

$ python cli.py fetch-results -w 31
Updated 8 matches with results
Total points: 11

Merges results into the existing JSON, preserving Ben's predictions, and calculates points automatically.

Encoding publish-ready Shorts

This replaces iMovie entirely. A single command takes the raw iPad screen recording and produces a YouTube-optimised Short:

$ python cli.py encode-short -w 31 -t predict -i RPReplay_Final.MP4

Under the hood it runs a single Whisper pass (reused for both trim detection and SRT caption generation), detects the speech start via FFmpeg's silencedetect filter, finds the closing phrase ("see you next time") in the transcript, then encodes with normalised audio, proportional scaling and YouTube-recommended H.264 settings.

The trim is tight, half a second after the closing phrase, so it cuts before Ben swipes up to stop the screen recording and you don't see the iOS Control Centre.

Upload to YouTube

The final piece. One command uploads the encoded Short as a private video with auto-generated metadata:

$ python cli.py upload-short -w 31 -t predict
Title: GW31 Premier League Predictions #PremierLeague #matchweek31
Tags: Premier League, EPL, GW31, Football...
Thumbnail set
Captions uploaded
Privacy: PRIVATE

It generates the title, description (including season accuracy stats and an engagement question), tags with relevant team names, extracts and sets a thumbnail from the title frame, and uploads the SRT captions for search indexing.

Everything uploads as private. Ben and I review it in YouTube Studio and he publishes when he's happy. This was a deliberate decision. It's a child's channel and I wanted a human gate before anything goes public.

The YouTube API OAuth credentials are pulled from 1Password at runtime via the op CLI, so nothing sensitive sits on disk.

The weekly routine from Gameweek 32

What used to be nine manual steps should now be a handful of CLI commands plus Ben's two recordings:

  1. fetch-fixtures then pptx-predict-table --icloud - pull fixtures, generate slides, send to iPad
  2. Ben records prediction video
  3. transcribe then encode-short then upload-short - process and publish
  4. fetch-results then pptx-review-table --icloud - pull results, generate review slides
  5. Ben records review video
  6. encode-short then upload-short - process and publish
  7. Review and publish manually in YouTube Studio

I'm looking forward to running it for the review once GW31's fixtures are all played, and both predictions and review for real in Gameweek 32 after the international break. If the numbers hold, my active time should go from an hour to under two minutes. And critically, none of those two minutes are things that block Ben. If I'm not around, someone else could run four commands, or I could do it from my phone over SSH. The next step is getting this set up on Ben's Chromebook so he can run the pipeline himself — once I work out why the option to enable Linux is disabled on his machine, he won't need me involved at all.

What I'm proud of

It's not the code. It's that Ben has stuck with it. He's at over a hundred subscribers, he's recorded every single gameweek this season, and he genuinely looks forward to it. He's learning that consistency matters more than virality, that showing up every week builds something, and that over a hundred people choosing to follow a 12-year-old's football predictions is pretty cool.

The automation exists to protect that consistency. Not to make the videos for him. He still records every one himself, writes his predictions by hand with Apple Pencil, and talks through his reasoning. The personality is all him. I just make sure the boring infrastructure never gets in the way.

If you're into Premier League predictions, or you want to support a kid who's been showing up every week, you can find Ben at youtube.com/@BensPLPredictions.