What Actually Happens in the Linux Kernel When You Run docker run?

jeswin cyriac — Mon, 16 Mar 2026 14:01:38 +0000

Most explanations of containers stop at "it's like a lightweight VM." I wanted to go deeper about what actually happens in the Linux
kernel when you run docker run?

I built an interactive blog that walks through it step by step, with animations you can click through:

Filesystem isolation

How OverlayFS stacks read-only image layers with a writable layer using copy-on-write
How pivot_root() changes a process's root pointer so it can't escape the container

Network isolation

How veth pairs are just two net_device structs pointing at each other in kernel memory
How the docker0 bridge switches packets using a MAC address hash table
How NAT with iptables MASQUERADE and conntrack lets containers reach the internet

Process isolation

How nsproxy inside task_struct holds pointers to all 6 namespace types
How getpid() returns different PIDs depending on which namespace is asking

Resource control

How the OOM killer picks which process to kill using oom_badness scores
How CFS tracks vruntime per process to fairly share CPU

The runtime chain

How docker run chains through dockerd → containerd → runc, and runc fires clone(), unshare(), pivot_root() then exits

Each topic has interactive diagrams where you can step through what's happening at the kernel level.

Check it out here: https://devopsagents.co/blog/containers-from-scratch#sharing-problem

Would love to hear feedback. Especially if anything is inaccurate or could be explained better.

How I used Claude Code to reverse-engineer a SaaS promo video and build my own — frame by frame

jeswin cyriac — Sat, 07 Mar 2026 10:29:46 +0000

Who am I

I'm a solo founder building DevOps Agents — AI agents that deploy and manage your production infrastructure from a chat interface. You give it a GitHub repo, tell it where to deploy (AWS, DigitalOcean, any VPS), and the agents handle the rest — analyzing your repo, planning the architecture, running the deployment commands, and validating everything works. All with your approval at every step.

I've been building it solo for the past few months. Bootstrapped. Wearing every hat — backend, frontend, infra, and now apparently, video production.

I thought I needed to outsource my intro video. Turns out, doing it myself was better.

A few weeks ago I needed an intro video for my landing page.

As I don't have prior video creation experience, I thought it would be smart to outsource it. Went to Fiverr. Went to Upwork. Spent days filtering profiles, comparing portfolios, checking prices. Some were too expensive for a bootstrapped product. Some had the wrong style. Some had 3-week turnarounds.

After a few days of this, I still had nothing.

The "what if" moment

Then a thought hit me: what if claude code could just... make it?

I didn't have a plan. I didn't have a tool in mind. I opened Claude Code and typed something like: "I need a promo video for my SaaS. Are there any MCP servers for After Effects? Or any way you can create videos programmatically?"

Claude Code searched around and came back with Remotion — a React framework where every video frame is just a React component. I'd never heard of it.

But I know React. Claude Code knows React. So we went for it.

(For context — Claude Code was running on its default model, Claude Opus 4.6.)

Step 1: Reverse-engineering a reference video

I found a SaaS promo on YouTube — clean dark theme, animated UI mockups, smooth transitions. Exactly the vibe I wanted. But instead of just bookmarking it for "inspiration," I decided to systematically reverse-engineer it.

I gave Claude Code the YouTube link and said: "Download this. Extract the frames. Analyze it."

It handled everything. Downloaded the video with yt-dlp. Extracted 177 frames at 2fps with ffmpeg. Then it produced a 160-line analysis document.

Not a vague summary. A full breakdown:

Every scene with exact timestamps — "Act 1: Hook (0-7s), Act 2: Value Prop (7-15s)..."
The design language — fonts, colors, spacing, animation patterns
How transitions sync with audio beats
Composition rules — "never more than 4-5 words per text card," "generous padding," "text cards hold 2-3 seconds"

It basically reverse-engineered the entire visual language of a professional promo video into a structured, reusable document.

That alone was worth the experiment.

Step 2: From analysis to a production plan

Next I said: "Now plan a similar video for DevOps Agents."

Claude Code created a 415-line plan document. Not a generic outline — a detailed production blueprint:

9 scenes, each mapped to specific frame ranges
A comparison table: reference style vs our adaptation
Exact animation timing for every element
A phased build order

The plan adapted the reference flow to tell our product's story: user types "Deploy my GitHub app to Kubernetes" → agent analyzes requirements → plans architecture → executes deployment → success.

At this point I hadn't written a single line of code. But I had a complete creative direction grounded in something that already worked.

Step 3: The autonomous build loop (this surprised me)

Here's where it got wild.

I told Claude Code: "Build each scene, render the frames, review them yourself, fix whatever looks off, and keep looping until you think it's good enough."

And it did.

The cycle looked like this:

Write a React component for a scene
Render still frames at key moments
Analyze its own output — "spacing is too tight here," "that gradient needs to be more subtle," "stagger delay should be 15 frames, not 10"
Fix the code
Re-render
Analyze again
Repeat

I wasn't reviewing each iteration. Claude Code was its own designer, its own QA, its own creative director — building, rendering, critiquing, fixing. Dozens of cycles per scene. Spring physics for bouncy entrances. Typewriter character timing. Smooth terminal scrolling interpolated across 137 frames.

I'd check in occasionally, give a high-level note, and let it keep going.

The result: 2 hours, zero video editing

8 scenes with smooth transitions — typing effects, animated progress bars, terminal output, gradient animations
42 seconds at 1080p, 30fps
Background music synced to scene transitions
All React components. No After Effects. No Premiere. No video editing software touched.

Total time from "can you make a video?" to rendered MP4: about 2 hours.

Here's the final video:

Final thoughts

It has "Code" in the name, but it keeps surprising me with what it can do beyond coding. Video production wasn't something I'd ever think to throw at it. But here we are — it found the tool, analyzed the reference, planned the scenes, built the components, reviewed its own output, and iterated until it was good.

I keep discovering new things in my journey building devopsagents. I'm planning to share all my discoveries and experiences building DevOps Agents with Claude Code and other AI tools — follow me on Twitter/X if you're interested in that kind of thing.

DEV Community: jeswin cyriac