I asked an agent to make a hero video for Argus. I gave it the codebase, the landing pages, the documentation. I did not give it a creative direction, a shot list, a mood board, or a script. I said, more or less: make this work.
It made it work. The result is technically correct — right dimensions, right duration, music muxed in and provable with ffprobe. It got a C-B. Shelved, not published.
That's not a failure. That's the ceiling of the inputs.
What the agent found
The agent came back with four pillar clips structured around a vocabulary I hadn't mentioned: Observe, Focus, Radiate, Bloom. Those words live in the Argus design system — formalized in the project code as actual design direction. The agent didn't invent them. It read the codebase, found the philosophy sitting there, and used it to structure a video.
I didn't tell it to do that. The code told it.
This is different from what I usually write about. In A Hundred Commits and a Nap I talked about AI pair-programming as work compressing and in I Stopped Prompting AI and Started Managing It how much agentic work involves preparing inputs before execution begins. This video project ran that idea further: the handoff wasn't a prompt. It was the codebase itself.
What actually shipped
The stack worked. HyperFrames renders video from HTML on a deterministic, seek-safe timeline — an agent can author, lint, and re-render compositions as code, no human in an editor. Brand-locked design tokens gave near-zero visual drift across five clips. A 15-second vibe reel approved before committing to full renders saved at least one long wasted render and should be a permanent gate on any future video work. The local stack produced real MP4s with genuinely muxed audio. Provable with ffprobe. Not vibes.
The 80-second hero video got an honest C-B. The distance between technically correct and flagship-grade is taste, pacing, narrative punch — exactly the qualities that are hardest to specify in a prompt and impossible to verify from a transcript. The inputs weren't rich enough to produce anything creatively meaningful. No direction beyond "make this work." That's not an indictment of the pipeline. It's what happens when you don't give anyone — human or agent — enough to work with.
The brief problem
I think of myself as the creative director on these projects. The one asking which creative stones are still left unturned, what needs input from me or another source before the pipeline runs. The agent executes once those questions are answered. It can't supply creative meaning. I can.
The next pass is already in queue. Second-by-second beats. A voiceover script. A story arc. The kind of rich, specific brief that a human director would put together before handing a shot list to a cinematographer.
But the discovery from this first pass is stranger and more interesting than just "write a better brief." If the agent reads the codebase and surfaces the design vocabulary already living there — using it to structure a video without being asked — then what's in the codebase matters more than I'd thought. The vibe of a project, kept in structured data and design tokens and documented vocabulary, is becoming as important as the source code itself.
Where Argus fits
This is what Argus is built to do. Feed your media assets in — sketches, mood boards, reference photos, screenshots — and get expressive structured data back about the broad qualities of what you're working with: dominant colors, moods, use cases, textures, tags. That metadata becomes design-legible to an agent. Instead of an agent guessing at the aesthetic direction of your project, it can read it from a source of truth you've already built.
The Observe/Focus/Radiate/Bloom structure emerging from the codebase was a proof of concept for that idea. A richer Argus media catalog — tagged, described, organized — would have given the agent even more to work from before it wrote a single frame. That's the flywheel: the more meaning you put into your assets upfront, the more coherent the output when an agent draws from them.
What to do before your first pass
If you're thinking about trying agent-authored video: start with still images. Sketches, mood boards, reference photos, screenshots. Feed them into Argus and let it tell you what you're actually working with. Generate a design brief from that material before you build anything moving. That's how you develop a coherent look across everything you make — and how you give an agent something real to reach for.
An agent with no brief will do its best and produce something technically correct. Give it a brief built from the media itself and you'll start to see something that actually feels like yours.
More to report after the next pass.
Top comments (1)
The idea that the codebase itself can serve as a brief for an AI agent to generate content, such as the hero video, is fascinating. The fact that the agent was able to surface the design vocabulary from the codebase and use it to structure the video without being explicitly told to do so, highlights the importance of maintaining a consistent and well-documented design system. I've seen similar benefits in my own projects where a well-structured codebase has enabled automated tools to generate high-quality outputs. The notion that the "vibe of a project" can be encoded in the codebase and design tokens, and then used to inform generated content, raises interesting questions about the role of creative direction in AI-assisted content creation - how do you see this evolving in the future, particularly with regards to the balance between human creative input and AI-generated output?