Léo Bitencourt

I'm designing a local interface that gives a production company one screen for the whole life of a project, from the raw briefing to the delivered file. I build it alongside a real company, so every screen came from watching how they already work instead of from a wireframe. The spine turned out to be their own naming code, which already ties the client, the job and the proposal together. Register the job once and the code fills the spreadsheets and names the documents. Each stage of the pipeline carries buttons, and every button is an Anthropic agent loaded with that project's context: turning a WhatsApp voice note and a raw email into a structured brief, translating client feedback into an instruction the team can act on, checking a script against the brief, generating the proposal file. The piece I'm still chewing on is the overview screen, because the owner glances at 20 jobs and knows whether the week is tight, and a nice looking table doesn't do that. Nowhere near finished, and it's the most interesting thing on my desk.

I built a pipeline that reads a live site and returns a finished video on the other end. It pulls the real copy, the CSS palette, the computed fonts, the logo and the background pattern, then writes the shot list in numbers instead of prose: frame counts, camera positions, easing curves. Remotion renders it, so the motion graphics are React code and every scene is reproducible. First full run was a 15 second vertical reel for a bug reporting tool, every word on screen lifted verbatim off the site. Because the scenes are numbers, the canvas is a parameter, and that one master spits out 9:16, 16:9, 4:5, 1:1 and as many crops as I need without opening After Effects. The rule I learned the hard way is that fitting and working are different results. When the dominant axis flips, a stack has to become a row, and 2 of those 5 scenes needed real recomposing for 16:9. Under a cent per video, and I still look at every format one by one.

The piece I'm assembling right now is a campaign engine that lives inside Claude Code and never opens a browser tab. A campaign brief goes in. Claude reads it against the brand's own material, the tone of voice, the palette, the way they name things, and writes the creative direction out of that: the concepts, the key visual, the copy per piece, the shot description for each video. From there it calls the image and video engines straight through their APIs, Magnific for the stills and Higgsfield for the motion, so one brand sheet feeds every asset and the campaign still holds together across 20 pieces. What I care about there is the context travelling: the tone the client signed off on in the brief is the same tone in the caption of the last static. Half of it runs today. The other half is me finding out where a human has to stay in the loop.

I run my work through Claude Code and write my own agent skills, one per job that keeps coming back. A tracker that sweeps the web every morning for the brand moments worth turning into a video. A skill that reads a company's site and writes the design document another agent needs to build anything in that brand. One that drafts client emails in my voice. One that files a finished job where I'll find it again. Each skill is a text file of rules I wrote after getting that same job wrong by hand. The line I hold is that the step gets automated and the judgement doesn't: my video pipeline runs in 5 phases and stops for a human at every one, because each of those stops exists thanks to a rerun it once cost me.

One of my longest running clients is an educational YouTube channel with over 1 million subscribers, and every video arrives the same way: a script in a Google Docs table with the footage and images linked row by row. I wrote the whole path. One script reads that table, splits it into chapters and scenes, builds the project folder from the template, downloads every linked asset, converts the footage and hands me a Photoshop file plus an After Effects project with everything imported and named. If it dies halfway it picks up where it stopped. Then I built my own panel inside After Effects: one tab assembles the edit in five clicks, the other holds the moves I repeat daily, like next scene, camera rig, my expressions, transitions, and the brand palette where clicking a swatch fills the layer and copies the hex. Two Photoshop scripts sit next to it, one writing math formulas with every term on its own layer so the equation solves itself on screen, another building data tables out of pasted spreadsheet rows. Prep used to eat two days per video. It's around four hours now, and none of them go into renaming files.

At Lunair I work on a platform that turns a URL or a prompt into a finished video, which means I see generative tooling before it's polished, including the parts that don't work. The first thing I took from it is how much of the work around a video repeats itself, so I ended up writing internal automations for what nobody should be doing by hand: research, tracking, collecting brand assets. The second one changed how I write prompts. A good prompt for an animation engine is a long, exact, boring document, and I'm slow at producing those by hand. So I stopped writing prompts and started building the thing that writes them: a skill that already knows the brand, the engine's quirks and the format, and hands the prompt back ready to fire. Giving an AI enough context to aim another AI is the most useful habit I picked up there.

Every finished job gets a card in an Obsidian vault: what it was, what broke, what I decided, and a link to the real files. Claude writes the card and cross-links it to the client, the people involved and the older jobs it touches, so the vault reads as a map of my work rather than a folder of it. Costs me about a minute per delivery. The payoff shows up months later, when a problem comes back and the fix is already written down in my own words with the reason attached. Most of the rules inside my agent skills started as a note in there, including the one about a wrong render looking exactly like a right one. It's the closest thing I have to a system that makes the next hundred videos better than the last hundred.