I Replaced My Product Hunt Launch Video Budget With an AI Agent

Every Product Hunt launch has one line item that gets approved weeks ahead and cannot change once the quote is signed: the video. For this launch I gave that line to a coding agent working inside CoAnimator, and this post covers exactly how it went.

The agent took over research, scene building, timing, captions and every revision. I kept the positioning, the claims on screen and the Product Hunt page, because those decide whether the video works.

The trade-off is control. The result follows the agent you connect and the brief you write, so a one-sentence brief gives you a generic video.

TL;DR

• The agent handled research, scenes, timing, captions and revisions, working from one structured brief.
• I kept the promise, the on-screen claims and the Product Hunt page.
• Five things needed attention: overdone edits from loose commands, agent-dependent quality, no analytics, a capped free export and manual fact-checking.
• A studio still wins for flagship brand films and for teams with nobody to direct.

What a Product Hunt Launch Video Usually Costs

I did not need a cinematic brand film. I needed a clear 45-second explanation that I could change the night before launch.

Product Hunt's guide to building a product page recommends a video, and it adds that a plain screen recording with your own voice can do more than a big-budget trailer. So the first question is how produced the video needs to be.

When a produced video is worth paying for, the launch video cost looks like this. These ranges come from a launch-video studio's price guide. The studio sells these videos, so read them as a reference point, not a quote.

• Freelancer-led animation: $1,500 to $5,000, with two revision rounds.
• Small studio: $5,000 to $15,000 for a 60-second animated video.
• Lead time: A standard timeline of four to six weeks, and rush work adds 25 to 50 percent.
• Extras: Revision rounds past the included ones cost $500 to $2,500 each, and every extra aspect ratio costs $500 to $1,500.

The last two lines pushed me to look at another route, because a launch video is almost never right on the first pass.

What I Needed Before Starting

Setup took one sitting. These are the five things I had ready before my first prompt.

• The studio: The CoAnimator desktop app for macOS, Windows or Linux.
• An agent: A coding agent I already used. CoAnimator works with Claude Code, Codex, Antigravity and OpenClaw, among others.
• Media tools: FFmpeg and FFprobe, which the app's media setup prepares for export.
• Footage: A screen recording of the product completing one task, made with a separate screen recorder, plus the logo, brand colors and font.
• A public home for the MP4: Product Hunt takes video by link, so the file needs a public URL. I used YouTube.

From there, the work was a loop of directing, reviewing and exporting.

Step-by-Step: How I Built the Launch Video

These are the nine steps in the order I ran them.

Step 1: Write the Promise and Beats First

I started in a plain text file, away from the studio. My rule is that nothing gets built until the promise fits in one sentence.

The promise is the line a viewer should be able to repeat after watching with the sound off. For the example brief in Step 5, it is: see every API key's rate-limit usage in one dashboard and get warned before a 429 reaches your users.

Then I wrote four beats: the problem, the product action, the result and the next step. For a 45-second cut, each beat got a time window.

An agent executes decisions quickly, but it cannot make them for you. Make them first.

Step 2: Collect the Assets Each Beat Needs

For each beat I listed what had to appear on screen. For the Quotabar example in Step 5, that comes to one screen recording of the dashboard, the logo, the brand font and colors, and a closing card with one destination.

I left a pause before and after each click while recording, so the agent had room to cut and time things. A demo account with sample data and notifications turned off kept the footage clean. Then I dragged the files into CoAnimator's media panel.

If an asset is missing, the agent fills the gap with something invented. Finish the list before you write the brief.

Step 3: Connect the Agent and Open a Template

I installed CoAnimator and followed the welcome guide, which has a checklist for connecting an agent, preparing the media tools and opening a project.

I connected Claude Code, then chose New and picked the Product Demo Video template, the one built to show off an app, SDK or launch in under a minute. Templates download on demand and ship with agent skills and documented effects, so the agent starts with the studio's conventions instead of guessing them.

For terminal rendering, I opened Settings → General → Command line & agent skill, installed the coa command and installed the agent skill. The walkthrough on connecting Claude Code to CoAnimator covers both installs and how to verify them with coa --help.

I start from a template, not a blank project. A first scene that already looks finished makes later notes sharper.

Step 4: Let the Agent Research Before It Builds

Before any scene existed, I had the agent do the research. It searched the web on the product and on how launch videos are framed. It also researched keywords and tags, so the video title, description and Product Hunt launch tags (you pick up to three) were settled before building started.

CoAnimator also lets you paste a link to your docs or a blog post so the agent works from your own material. That works when your connected agent can fetch web pages.

Ask for the research as a written plan and approve it before building. Correcting a plan costs a sentence, while correcting a render costs a pass.

Step 5: Give the Agent a Structured Brief

This step decided my result. I use the same six-part shape for every video. Here it is filled in for Quotabar, a made-up API rate-limit dashboard, so you can see the shape without a real product in the way. Copy it and swap in your own.

Goal: A 45-second, 16:9 launch video for Quotabar, an API rate-limit dashboard, aimed at backend developers and platform teams who run APIs with per-key limits.
Promise: See every API key's rate-limit usage in one dashboard and get warned before a 429 reaches your users.
Beats:
  Problem (0-8s): A key hits its limit, the API starts returning 429 errors, and users notice before you do.
  Product action (8-30s): Connect an API gateway, then watch a usage bar fill for each key and an alert fire at 80 percent of the limit.
  Result (30-40s): The alert reaches Slack before the limit is hit, so you raise the quota instead of apologizing to customers.
  Next step (40-45s): Connect your first API key.
Assets: Quotabar logo, one screen recording of the dashboard showing the usage bars and the 80 percent alert, brand colors and font, and a closing card with the product URL.
Rules: Captions on. No numbers, claims or logos I did not supply. List missing assets before building.
Revisions: Change only the scene I name. Leave approved scenes untouched.

If I could keep only one rule, it would be "list missing assets before building." It turns silent gaps into questions I can answer.

With a brief this specific, the first draft needed direction, not rescue.

Step 6: Review Scene by Scene on the Live Stage

While the agent built, the stage updated in front of me. I reviewed in three passes, always in this order, because each pass catches a different kind of mistake.

• Pass one: Is the key detail obvious in every frame?
• Pass two: Is there time to read each label before the next change?
• Pass three: Do captions, music and any voice follow one rhythm?

This is also where the agent sometimes overdid it. When my command was not specific enough, it changed more than I asked, because it did not read my intent the way I meant it. From then on, every note named the scene and what had to stay untouched.

When something looked wrong, I paused the stage and used Copy frame, Copy timestamp or Annotation capture, which sends the agent the exact moment instead of my description of it. A good note names the moment, the problem and the fix.

A note that names a moment costs one sentence, while a vague note costs a rebuild.

Step 7: Add Voice and Music After the Picture Works

Plugins add voice, music and publishing. I add sound last, every time. Judging audio against a picture that is still changing is how approved scenes get reopened.

AI providers and plugins have their own accounts or keys, so decide on voice and music deliberately instead of switching them on by default.

Step 8: Commit Each Approved State

Project files are plain and git-friendly, so I committed after every approved pass. A bolder opening became a branch, and undoing the agent's overreach meant reverting one commit.

Each commit also showed exactly what a pass had changed, which is the fastest way to review an agent's work.

Step 9: Export, Check and Ship to Product Hunt

I opened Export and checked the resolution, frame rate, quality and duration range. For review, I exported an In-Out range around the scene I had just changed, then switched back to the full timeline for the final file. Free exports are capped at a 720p short side with a watermark, and a paid license lifts both, so the final render has to wait for the license.

The same render runs headlessly, which suits a script or CI pipeline.

# Render a project at 1080p, 30 fps, to a named MP4
coa render my-demo --resolution 1080p --fps 30 --out launch.mp4

# Render a packaged project file
coa render launch-video.coa --out launch.mp4

The command accepts a project ID, a folder or a .coa file, and it returns standard exit codes for CI. Before uploading, I opened the MP4 outside the editor and checked it on a phone. I confirmed that every feature shown exists, that captions were correct and that no private data was visible.

Then came the Product Hunt side.

• Hosting: Upload the MP4 somewhere with a public link, because video goes into the launch media box by link.
• Gallery: Add at least one image, since Product Hunt requires it. It recommends 1270x760 pixels and says three or more images make a stronger page.
• Draft first: Use Create draft, not Schedule launch, until everything works. Drafts are not reviewed, and incomplete scheduled launches can be removed.
• Playback test: Open the draft and play the video from the link inside it.

I ended with the draft test, because it shows embed problems while there is still time to fix them.

What Worked

The video came together smoothly, and each reason below is something you can copy.

• Research before creating: The agent searched the web first, so the plan rested on research instead of guesses.
• Keywords and tags settled up front: The title, description and launch tags matched how people search before any scene existed.
• Decisions finalized first: Script, beats, assets, title and tags were locked before building, so the build was execution instead of exploration.
• A brief with rules: Lines like "no claims I did not supply" left the agent little room to guess.
• A template as the starting point: The Product Demo Video template ships with agent skills and documented effects, so I could ask for an effect by name.
• Live stage review: A wrong scene got caught as a wrong scene, not as a finished export.
• Revisions as one sentence: One change aimed at one scene replaced a billing round that costs $500 to $2,500 on the studio route, and no CoAnimator credit system counted it.
• Git as a safety net: A bold idea lived on a branch, and one revert undid anything the agent overdid.
• A project that outlives the launch: After a UI change, I can swap the changed screens and re-render, or script the render with coa render for each release.

Together these turned the video from a one-time deliverable into something closer to source code, and that is the part I value most.

What Broke

Nothing failed badly, but five things deserve a plan before launch day.

• The agent sometimes overdid it: A command that was not specific enough led it to change more than I asked. Name the scene, state what must stay untouched, and use Copy timestamp so the target is exact.
• The agent sets the ceiling: CoAnimator works with the agent you connect, so results depend on that agent, the prompt quality and the direction you give.
• There are no built-in analytics: Completion and sign-ups have to come from your video host's stats and your product's own tracking.
• The free export is not launch-ready: The 720p cap and watermark mean you need the license before the final render.
• Truth stays manual: The agent can animate a feature, but it cannot confirm the feature exists. I checked every number, claim and screen before export.

None of these sent me back to a quote and a six-week wait.

What My Budget Line Looks Like Now

The invoice shrank, but the cost did not vanish. It moved.

• The studio: CoAnimator is free forever, with a one-time lifetime license if you want one.
• The agent: I already pay for a coding agent, so directing it is an existing cost.
• The plugins: Optional providers for voice or imagery bill separately, depending on what you add.
• My time: Writing the brief and reviewing each pass takes attention, and this is the largest remaining cost.

The old budget bought labor, while the new one mostly buys attention.

When I Would Still Hire a Studio

An agent is not the right answer to every launch. These are the cases where I would call a studio instead.

• A flagship brand film: CoAnimator builds animation and edits footage you provide. It does not replace a camera crew or a creative director.
• A team with no one to direct: If nobody can judge pacing, hierarchy and tone, a studio's creative direction is what the money buys.
• A one-time asset that never changes: If the video will sit untouched for a year, the editable project is worth less.

If your product keeps shipping updates after launch day, the agent route fits better than a one-time invoice.

Quick Answers

Does Product Hunt accept an uploaded video file?

Product Hunt's submission form adds video by link, so host the MP4 first and paste the public URL. Play it from a draft listing before you schedule.

Do I need to code to make a launch video this way?

You direct the agent in plain language, and the studio itself needs no terminal. The coa command is optional and only matters if you want scripted or CI renders.

How long was the launch video?

The example brief targets 45 seconds, split into four beats: the problem, the product action, the result and the next step. Pick a length your promise can fit in, not the other way around.

Treat the Next Launch Video Like a Release

The saved invoice turned out to be the smaller change. The bigger change is that the video stopped being a one-time purchase and became something I ship on a cadence, like a changelog.

The old budget bought one video. An editable project gives me the second, the third and the tenth for the price of a conversation with my agent. That points to a different habit: a new cut for each feature, a re-render when the interface changes, and a project folder that sits in the repo next to the code it describes.

If you want to try it, start with one scene. Open a template from CoAnimator's template library, give your agent the six-part brief from Step 5 and rebuild that scene around a screenshot of your own product.