I've spent thirty years crawling through aircraft bellies, staring at fatigue cracks under harsh flashlights, and signing off work knowing it has to be perfect because people's lives depend on it. That kind of career rewires your brain. You develop an instinct for failure, an appreciation for iteration, and a deep hatred for things that can't hold tolerance.

So obviously, I'm building an automated short-form content pipeline.

Not because I love YouTube Shorts.
Not because I want to be an influencer.
But because this is my retirement exit strategy — and I'd prefer not to be inspecting turbine blades when I'm 70.

The goal isn't to make great Shorts.
The goal is to make Shorts automatically, with near-zero human intervention, until quality becomes the inevitable by-product.

Iteration One — The Machine Made a Video (Quality Not Included)

The first version of the pipeline produced videos that looked exactly like you'd expect from a fully automated system with no adult supervision.

Low-budget.
Awkward.
Occasionally existential.

And that was totally fine.

The real win was simple:
I pointed it at a repo, hit go, and minutes later it spit out a full short — script, visuals, voiceover, captions, timing, export. The whole stack built end-to-end without me touching a timeline.

Was the video good?
Absolutely not.

Did the automation work?
Absolutely yes.

That was the moment I knew this idea was viable.
Not because the output was impressive — but because I didn't build it manually.

Automation: 1
Human Labor: 0

Iteration Two — Tightening Bolts, Not Polishing Output

Right now, the automation is what's improving.
The videos themselves are still proudly "low-budget."

My time is spent building QA automation so the system stops making the obvious mistakes:

  • subtitles wandering off the frame like they're escaping
  • screenshots that don't match the narration
  • pacing that feels like it's late for a job interview
  • hooks written like someone dared the model to be weird

I still review each short before publishing, but the goal is to reduce that to checking for catastrophic failures.

Once the QA logic matures, viewers may start to notice a difference — not because I improved the artistry, but because the system finally stopped repeatedly tripping over the same cracks.

And trust me,
"the cracks appear on their own schedule — usually while I'm trying to do something else."

The Research Layer — Not for Perfection, Just for Less Chaos

Great content starts before anything is edited, so I built a research module that studies:

  • what style of hooks hold attention
  • what the algorithm is rewarding this month
  • retention curve patterns
  • pacing structures from top-performing videos
  • tones that work vs. tones that tank

It's not scraping secrets.
It's just noticing patterns and teaching the machine that "coherent" is better than "accidental surrealism."

Quality isn't the target here.
Predictability is.

I'm building the machine that will eventually make quality unavoidable, whether it wants to or not.

"You aren't doing it wrong if nobody knows what you're doing."
— Nietzsche (probably)

Quality as a Side Effect of a Smarter Machine

I'm not chasing quality directly.
I'm building a system where quality emerges naturally from the loop:

  • scrape analytics
  • convert videos into structured datasets
  • train and fine-tune models on real engagement behavior
  • update rules after every failure
  • close the loop and run it again

This isn't "content creation."
This is industrial-grade iteration applied to a stubborn machine that's still learning how not to confuse itself.

My role is basically:

  • inspector
  • pattern-spotter
  • rule-writer
  • designated adult in the room

Exactly what aviation trained me for — except nobody dies when the system misplaces a caption.

The Principles Behind the Lab

I don't sell courses.
I don't promise passive income.
I'm not chasing algorithm clout.

I build infrastructure.
And then I refine it until it stops being embarrassing.

Here's the rulebook:

1. Automation first, aesthetics later.
Polish without automation is manual labor wearing a wig.

2. Fix systems, not symptoms.
If one short has a problem, future shorts shouldn't.

3. Human input should trend toward zero.
If I'm dragging files around, I failed.

4. Redundancy is mandatory.
Aviation brain refuses to trust a single point of failure.

5. The pipeline is the product.
The actual videos are a side effect.

6. Every error is training data.
If the machine finds a new way to fail, I make sure it never fails that way again.

7. Predictability beats creativity.
The system can get fancy once it stops tripping over its own shoelaces.

Teaching the Machine How Attention Works

Anyone can automate editing.
Anyone can slap captions on a screenshot.

But very few people are:

  • scraping Shorts
  • converting them to JSON
  • extracting retention patterns
  • building datasets from real-world behavior
  • fine-tuning models to understand what the algorithm actually rewards

That's where the real work is.

This isn't a content pipeline — it's a feedback loop.

"They can't predict you if you haven't written the script yet."
— OnlyParams

AI Sovereignty Means Going Off-Script

I'm not trying to fit into Big Tech's predicted behaviors.
I want a system that thinks for itself — or at least behaves unpredictably enough that the algorithm can't pigeonhole it.

"AI sovereignty means building so far off-script Big Tech's predictive models throw a 502."
— OnlyParams

This entire project is built on that principle:
independence through automation.

Where It's Heading

I'm still under the hood.
Still patching rules.
Still building the QA scaffolding.
Still watching the automation mature faster than the videos do.

Next up:

  • deeper analytics scraping
  • sharper dataset generation
  • more consistent pacing logic
  • automated hook evaluation
  • and eventually long-form support

This isn't a sprint to create "great content."
It's a long-term engineering effort to build the machine that will.

If You Want to Watch This Thing Evolve (or Explode)

If you want to see whether this system eventually graduates from "functional chaos" to "consistently good,"
comment, like, and subscribe to follow the journey.

You can also follow me on X for the unfiltered version — the experiments, the failures, the breakthroughs, and the moments I accidentally teach the machine something horrifying by mistake.

In the End

I'm not building videos.
I'm building the factory that will eventually build good videos — automatically.

Right now, the shorts look low-budget.
But the automation behind them is evolving fast, and every new crack becomes another rule, another fix, another step toward a system that won't need me at all.

This is an iterative engineering project wearing the costume of a content channel.

And this is just the beginning.