Filming a hardware build: the Hotline Claude video.

The premise: restore a 1950s rotary phone into a direct line to a cloud agent, then code live in production through a Bakelite handset. The absurdity is the hook, but the video works because the build is real. The thing on the desk actually ships software, and what it shipped became marketistats.com.

A build video is a different animal

A vlog borrows its structure from life. A build borrows it from the project. That single difference changes what you shoot, what you keep and where the tension comes from.

A vlog

Structure comes from the day.

• -Chronological by default
• -Tension from what happens to you
• -Coverage: wherever you are
• -A smooth day is still watchable
• -The viewer is a companion

A build

Structure comes from the problem.

• -Ordered by the promise, the obstacle, the moment it works
• -Tension from whether the thing will function
• -Coverage: hands, screen, and the object, legibly
• -A smooth build is an advert
• -The viewer is a witness

The writing job is deciding which failures earn screen time. Failure is where a build video keeps its credibility. A build that goes smoothly for eleven minutes is a product demo wearing a documentary coat, and technical audiences detect that instantly, because they have all had the evening where the thing did not work.

The rule I use: keep every failure that changed the approach, cut every failure that was just a delay. A wrong solder joint you fixed is a delay. A wrong assumption about how the dial encodes digits is a story.

Shooting something that has to stay legible

Builds demand coverage a vlog never needs: the hardware up close, the screen readable, the process honest.

Old telephone hardware is photogenic in a way modern electronics are not. The Bakelite, the dial and the coiled cord all read on camera instantly, which is half the reason the concept works as video at all. A build video about a featureless black box has to invent its visual interest; this one only had to point at the thing.

Two practical constraints came out of it. Screen footage needs to be captured at source rather than filmed off a monitor, or half your runtime is unreadable at phone size. And hands are the most reusable coverage in a build: close, slow, well lit, they cut into almost any gap and they never break continuity because nobody tracks which finger moved first.

Pacing for two audiences at once

Eleven minutes forty is long for the channel, and the length is spent on comprehension rather than spectacle. A viewer who codes should be able to follow what is actually happening between the handset and the agent. A viewer who does not should still feel the moment the phone answers.

The way through is to separate the two jobs rather than average them. Technical detail goes where it can be skipped without losing the thread, usually mid-section. The emotional beats, the moment of connection and the first working call, are shot and cut so they land without any explanation at all. Averaging instead produces a video that is slightly too slow for engineers and slightly too dense for everyone else, which is the most common way a technical video fails.

What carries over to client work

This is the format closest to what a technical product launch needs: a real thing, demonstrated honestly, with the demo woven into a story rather than bolted onto one.

Most product launch films get this backwards. They open with the brand promise, then demo the feature list as evidence. A build film does the opposite: it shows the thing struggling into existence, and the promise arrives as a conclusion the viewer reached themselves. That is a more expensive structure to shoot and a much cheaper one to believe.

If a rotary phone can carry an eleven-minute product narrative, your product can too.

Sources and further reading

• How to write a video script

  Vanpelt StudioThe scripting process behind a structure that has to hold a technical explanation and a story at the same time.

• Pre-edit story check for YouTube footage

  Vanpelt StudioChecking that the build still reads as a story before you commit to an eleven-minute timeline.

• ScreenCaptureKit

  Apple Developer DocumentationCapturing screen content at source on macOS, which is how the terminal stays readable at phone size.