Chethan typed one prompt, and the 72-second narrated video below came out of it. This post is for developers who want to turn a prompt into a finished video with code. The README of his video engine’s public case study calls the prompt the easy part. The rest of this post is about the workflow behind it: 35 rules, each written after something shipped broken according to the repo’s LESSONS.md, and 23 automated checks that must pass before anything renders. The engine itself is private; the case study publishes the video, the script, the checks’ real output and twelve of the rules.
The repo’s copy of the video is media/prompt-to-video.mp4, 5.44 MB, as GitHub lists it; the player above uses a smaller encode made for this site.
Nothing was run for this post, and the case study was read on 26 October 2026 (Eastern time), the day it was published. The engine is a personal project, built on his own time, as this site’s home page says of his projects.
What the engine does between the prompt and the render
The “How it works” table in the README splits the engine into seven stages and puts the checks before anything is drawn. The prompt, as the README gives it, is “Make a short video about my workflow: prompt, script, images, APIs, sites, effects, renderer, video. Keep it simple.” The narration speaks a shorter version.
In the README’s table, Claude turns the prompt into scenes, each with what is said and what is on screen, and picks search words so a free photo site can send a match. The script is read in Chethan’s cloned voice, or a phone recording of him is cleaned up, with retakes cut out automatically. A speech-to-text model times every word, but the spelling on screen comes from the script.
Next in the README’s flowchart come 23 automated checks, and if one fails, nothing renders. After a pass, a storyboard sheet is looked at, and the scenes are drawn one frame at a time, 30 frames a second.
The README sizes the video at 72 seconds and the engine at about 4,900 lines
The “By the numbers” table in the README gives the scale of the video and of the engine behind it. These are the README’s own figures, as it gives them.
| README row | Figure |
|---|---|
| This video | 72 s, 12 scenes, 1080×1920, 2,159 frames |
| Input | 1 prompt |
| Rules the engine follows | 35, each written after something shipped broken |
| Automated checks | 23, each broken on purpose once to prove it fires |
| The engine | about 4,900 lines across 43 files, private |
| Caption languages | English, Telugu, Hindi |
| Built with | Claude Code, Node.js, Remotion, ffmpeg, ElevenLabs, Whisper, Pexels |
Other public files show some of them: the script has 12 scenes, evidence/selftest.txt ends “all 23 guards fire.”, and evidence/check.txt reports 72.0 seconds and 1080x1920.
Four of the rules, and the failures that produced them
LESSONS.md publishes twelve of the 35 rules and says every rule came from something that shipped broken.
The narration promises “a whoosh on every cut”, and lesson 3 is why that whoosh is now measured. An earlier whoosh was generated from a noise source that came out at −57 dBFS, practically silent, yet it passed a check that only asked whether the file existed and was over 4 KB. Every cut in a finished video was silent. Now every effect is measured, and a quiet one fails the build.
In lesson 4, a manifest claimed 150 frames, but only 121 existed, and the render failed on every missing one. The rule’s name is the fix: trust the disk, not the manifest.
In lesson 6, a 54-second script took 82.6 seconds to say, because the script’s timings were guesses. Now every scene’s length is measured from the recording. Lesson 7 starts from the same 82.6 seconds: the first take was 31% silence, and trimming every pause to a fixed hold took it to 65.9 seconds.
The checks are broken on purpose before they are trusted
LESSONS.md says each rule also lives in code as a check, “because a rule that only lives in a document is a wish.” The first rule, written on day one, was broken in eight of thirteen shots because nothing checked it. Lesson 1 adds the next step, breaking every check once on purpose. One check had scanned for a pattern the code never contained, so it matched nothing, and passed everything, for three videos.
evidence/selftest.txt, dated 26 October 2026 and marked unedited, records that practice. After a passing baseline, it breaks each check on purpose, expects a failure, and ends “all 23 guards fire.” Two caught lines, tagged with the engine’s own rule numbers 35 and 5, match public lessons: “a sound effect too quiet to hear” is lesson 3’s whoosh, and “figure without source” is lesson 10, no number on screen without its source.
Ten of the self-test’s lines cite a rule number, covering nine rules, so rules and checks are not one to one. evidence/check.txt is the output of the check run on this video before rendering. It reports 12 beats, 72.0 seconds and 1080x1920, and ends “check passed”.
A storyboard sheet is looked at before every render
The storyboard is a single sheet with one still per scene and one per on-screen moment, which the README says is looked at before anything is rendered. The per-moment stills came from a near miss in lesson 11: a 3.5-second title inside an 8-second scene was missed by the one-still-per-scene sheet. It “could have shipped broken without anyone seeing it.”
Above is example/storyboard.jpg, which the README calls the sheet that gets checked before every render.
The public repo is a case study, and its scripts only print text
Anyone who clones the repo gets the case study, not the engine, as its README says. Its run-it-yourself section asks for Node 20 or newer, then npm install and node make.mjs. make.mjs only prints text: npm install runs it as a postinstall step that prints “installed 0 engines.”, and node make.mjs prints six ticked steps, then “engine not found”, then “Those ticks were fake.” Every script in package.json runs that file, so npm test prints “all 23 guards fire.” without testing anything. The real output is in evidence/selftest.txt and evidence/check.txt, and the engine stays on Chethan’s machine, “making the next video.”
Limits
Nothing was run for this post, so the engine’s size rests on the README alone, and the frame count on the README and the storyboard image. The public files show the 12 scenes and the 23 guards. LESSONS.md says every rule came from something that shipped broken, but lesson 10 names no incident, and lesson 11’s missed title only “could have shipped broken”. Lesson 12’s failure was a video “technically excellent and emotionally inert”, and the other 23 rules, and how each rule is enforced, are private.
The README does not say which tool times the words or draws the frames.