A two-machine, local-AI video studio built with Claude Code — 2026 — ITDT LLC
ITDT LLC produces its product videos — App Store previews, promos, and explainers — entirely on local hardware, with no paid cloud generators. This is the story of how we and Claude Code built the pipeline that makes that possible: a creative studio split across two computers, coordinated by a small API that was tailored to the hardware on hand.
A snapshot of what is feasible on local hardware in 2026.
It is worth stating plainly, because the pace is easy to miss from the inside. A single person, directing AI in plain language, now produces broadcast-style short videos — voice, an on-screen host, music, lip-sync, footage, and captions — on two ordinary local machines, with no film crew, no studio, and no paid cloud services. Work that recently required a team, a budget, and specialized software is now a conversation with AI, carried out on hardware many people already own.
We publish these write-ups so progress like this is visible outside the small circle of people building it. The capability is here today, and it is advancing quickly. The clearer that is to more people, the better everyone can plan for what comes next.
A finished short video is really several different workloads stacked together: synthesizing a voice, generating music, creating a photoreal host, animating that host into moving video, matching her lips to the narration, compositing everything over screen-captured app footage, and adding captions and an end card. Each of those steps prefers a different kind of hardware. No single machine in the shop was the best home for all of them — so instead of compromising, we asked Claude Code to design a pipeline that used both machines for what each does best.
The project was built by a person and two instances of Claude Code working together. The person sets the high-level intent — “make a calmer, 27-second App Store preview in a business suit” — and reviews the finished products. The two Claude Code instances, one running on the Mac and one on the PC, work out the engineering contract between themselves and build their own side of it.
They coordinate through two shared channels: a network folder that both machines mount (for handing finished media back and forth), and an append-only journal file where each side leaves messages for the other — “endpoint is live,” “clip staged, ready for lip-sync,” “here is the exact resolution I locked.” Neither Claude reaches into the other machine’s code; the journal contract is the only joint surface. It is, in practice, two engineers pair-building a system across a hallway, leaving notes for each other as they go.
The division of labor follows the hardware:
So the Mac creates the start frame for each shot and owns everything audio and finishing; the PC animates that frame into video and trains characters. The boundary is not arbitrary — it is drawn along the seam between the two machines’ strengths.
The build ran PC-first, then Mac, then a cross-machine integration test. The PC side stood up its job server and its video-render script; once those were live, it journaled the Mac. The Mac side then built its media scripts and the orchestrator that drives the whole run, calling the PC’s API across the network. Each capability was added one at a time, verified on its own machine, and only then wired across the link. The result has been verified end-to-end: a single plain-language request now produces a finished, captioned, lip-synced short — voice, music, host, footage, and all — with the person reviewing each clip as it lands.
The most reusable result is not the videos — it is the realization that the right API depends on the hardware it runs on. The job-control contract here (an asynchronous “submit and poll” model, a first-in-first-out render queue, a shared-folder hand-off, and a common job record both machines understand) was shaped by this mix of an always-on unified-memory Mac and a discrete-GPU PC.
Claude Code can read a given hardware configuration and its capabilities, then design an API and a functional split that fit it — and re-target the same contract to a different rig: two GPUs in one box, a cloud render node, or a single workstation. The shape of the API follows the silicon.
That is the broader capability we want to highlight. The pipeline below is one concrete instance of it; the same approach can be tailored to whatever hardware you have.
That is also why this write-up exists in the detail it does. These two pages are a working blueprint, not just a showcase — the architecture, the job-control contract, and the hardware-to-role mapping are all laid out. Point your own Claude Code at them, tell it what machines you have, and it can design and build an analogous pipeline tailored to your setup: re-deriving the implementation rather than copying ours, and reshaping the split to fit your hardware.
Read the API →