Building a YouTube Channel in Public

Wed, 25 Feb 2026 10:00:00 -0500

Bootstrapping a YouTube Channel With Code

I decided to start a YouTube channel around one simple idea:

What is actually possible with code?

This project is mostly for fun. I want to explore YouTube as a platform and experiment with areas of coding I haven’t touched before. Instead of overthinking it, I’m learning by building in public.

And the first thing I’m building is the tooling for the channel itself.

Building the Tools First

The first series is focused entirely on bootstrapping the channel.

Instead of manually recording and editing everything, I’m creating small tools that help me produce better videos. I build the tools, use them to create videos, then improve them as I go.

Over time, I plan to make these tools available to others.

I’m also delegating as much of the coding as possible to AI tools. Part of this journey is exploring how far AI-assisted development can go, and where it still needs human input.

The First Attempt

I wanted to create a welcome video with a clean terminal-style look.

So I opened iTerm and recorded myself typing the text.

It looked… bad. Everything was off. The typing felt awkward. It wasn’t what I had imagined.

Here’s that first version:

Instead of trying to fix the recording setup, I decided to build something better.

A Simple Terminal Typer App

I wrote a small terminal-typer app that simulates typing and exports directly to video.

That way I can:

Control timing
Replay scripts consistently
Generate clean output every time

Here’s how it looks like:

Using it, I recreated the welcome video, and it turned out much closer to what I originally wanted.

Here is the current version of the welcome video:

This is just the beginning.

Right now, I’m focused on building the foundation.

If you’d like to follow the journey, consider subscribing And if there’s something you’d like to see me build, let me know.

If you watched the videos, you’ll notice they’re still silent. Adding audio is one of the next steps in this experiment.

A Declaration of Intent: Why I'm Writing

Tue, 18 Feb 2025 11:24:40 +0100

I should probably have started with this post before writing anything else, but who cares? Probably no one will ever read this, and that’s perfectly fine. I’m not writing this for others. This blog is just my personal collection of notes and documentation; something I should have been doing for years but never did.

Motivation

I wrote my first “Hello, World!” program in 8th grade using QBasic, and I was hooked. After a few small programs, I started experimenting with Visual Basic. When you’re new to programming; or anything, really, you want something visual. Visuals sell the product. There’s that saying: Rims sell the car.

Photo by Vlad Grebenyev on Unsplash

So, my friend and I created our first GUI program in Visual Basic: a periodic table of elements. Visually, it worked. The code? Absolutely terrible. Imagine spaghetti code, multiply it by 100, then multiply that by a rand(5, 10). It was that bad. I don’t have the code anymore, and that’s one of my motivations for writing this blog. But I remember it vividly: massive if-else chains for every element. Yes, for every single element, in multiple places.

Photo by Thomas Wavid Johns on Unsplash

Who would have thought that, years later, someone would actually pay me to write code professionally?

Fast forward 20 years. I’ve been writing code professionally for 12 or 13 years now. Hundreds of small projects, prototypes, interesting applications of design patterns, and problem-solving insights - gone. Never documented. Lost to time.

Fun fact: almost all the software I’ve written professionally is terminal-based, often running in the background without user interaction. Turns out, if you go fast enough, no one even notices the rims.

What Will Be Covered

From now on, I’m going to try to document as much as possible. I’ll cover topics I find interesting, reimplement old projects, explore tools, and maybe even suggest potential projects.

Here are some of the things I want to write about:

Compilation steps – understanding what happens when you compile code
Dear ImGui
Ugly and spaghetti code
File formats – exploring Mach-O and ELF
Linkers
Debuggers
Books – reviews, short or long, depending on the book
Package managers – how they work and why they matter
Meson build system – why you should care
Projects that are good for beginners
Test-Driven Development (TDD) – is it worth the hype?
Production-ready Hello World – making even the simplest programs production-grade
LLVM passes and codegen – digging into compiler internals
Assembly and syscalls – low-level programming insights
OpenCV experiments – exploring computer vision with POCs
OpenGL experiments
Exploring C++ projects – possibly a series, maybe weekly :)
Exception handling – what happens under the hood
Random industry thoughts – because this field is wild
Agile, Scrum, and Leadership – reflections on the way software teams work
Different personas in software development and management teams
Other rndthts …

This list will evolve over time, but the goal remains the same: document things I find useful, interesting, or just worth preserving. Also, the order of topics is completely random, and it’s far from complete.

If, by any chance, someone else stumbles upon this blog and actually finds it useful, well, that’s a happy accident! But really, this is just me making up for years of not writing things down. Let’s see where this random ride takes us.

Programming on rndthts.dev