I Vibe-Coded an AI Video Generator Into a SaaS Product

I did not build Video Studio by sitting down with a blank editor and writing every line of code myself. I built it by describing the outcome I wanted, having AI generate pieces of the system, testing what came back, finding the parts that were weak or expensive, and tightening the instructions until the product started behaving like something people could actually use.

That is basically vibe coding, except with considerably more arguing.

The original problem was bigger than “generate a video”

Most AI video tools are good at one part of the job: generating a clip. That is useful, but it still leaves a surprising amount of work sitting on the user’s desk.

You still have to decide what scenes you need, write prompts for each shot, keep the visual direction consistent, regenerate bad scenes, assemble the clips, add captions, write publishing copy, and keep an eye on cost while the model cheerfully burns through credits.

I wanted a different workflow.

The idea behind Video Studio was simple: give the system a product URL, affiliate link, business URL, product description, or creative brief and have it move much closer to a finished marketing video instead of handing the user another complicated machine to operate.

The product became a pipeline

The first useful shift was to stop thinking about video generation as one action.

The product needed a production pipeline:

• Take in the user’s product or brief.
• Plan the video and storyboard the scenes.
• Write structured prompts for individual shots.
• Generate each scene.
• Inspect the outputs.
• Repair only the scenes that failed.
• Assemble the final video.
• Prepare captions and publishing copy.

That architecture was not something I carefully typed out from memory because I had spent twenty years building video infrastructure. I kept describing the behavior I wanted, looking at what the AI built, and asking what was missing.

The interesting part of this kind of development is that you can move very quickly, but speed exposes bad decisions just as quickly as good ones.

Cost control changed the architecture

Video generation is expensive enough that sloppy architecture can become a business problem almost immediately.

One obvious example is retries. If a five-scene video contains one bad shot, regenerating the entire video is wasteful. The better approach is to evaluate scenes individually and repair only the failed one.

That sounds like a quality-control feature, and it is. But it is also a cost-control feature.

That became one of the core ideas behind the product: quality and cost should be managed by the system instead of dumped on the user.

So Video Studio started getting guardrails around generation budgets, scene-level QA, targeted retries, credit usage, and hard spending limits.

Then the fun AI project turned into SaaS

Generating a video is the flashy part. Turning the thing into a product people can actually pay for is where the less glamorous work arrives with a clipboard.

A real SaaS product needed:

• User accounts and authentication.
• Subscription billing.
• A credit ledger and usage tracking.
• Payment updates and cancellation.
• Failure handling.
• Support flows.
• Referral logic.
• Legal and privacy pages.
• Admin tools.
• Spend circuit breakers so one bad generation cannot run wild.

This was the point where Video Studio stopped being “an AI generator I built” and started becoming a small software business.

What vibe coding actually looked like

I want to be clear about how I built this because pretending I manually engineered every layer would make the story less interesting, not more.

I would describe a feature or a problem. AI would inspect the existing system, write or modify code, wire services together, and return a result. I would test that result, decide whether it matched what I was trying to build, and then push the system again.

Sometimes the AI produced something useful immediately.

Sometimes it produced something technically functional but commercially ridiculous.

Sometimes a workflow failed because one field was wrong, a webhook was missing, a route returned a 404, or two pieces of the stack disagreed about what a user was supposed to be allowed to do.

That is the part of vibe coding that gets left out of the magic-demo version. AI can generate a remarkable amount of software, but somebody still has to decide what the software should do and whether the result makes any sense.

The human job becomes judgment

I did not need to be the person typing every function to make the important product decisions.

I still had to decide:

• What problem the product should solve.
• What should be automated.
• What the user should never have to think about.
• What level of output is acceptable.
• Where costs become dangerous.
• What should happen when generation fails.
• How much complexity belongs behind the interface instead of in front of the customer.

That is increasingly what building with AI feels like to me. Less time translating an idea into syntax and more time deciding whether the idea, architecture, workflow, and result are actually good.

The product philosophy that came out of it

The Tool Shed has gradually settled around one principle: software should make the outcome easier, not hand the user more knobs.

Video Studio is a good example of that.

The user should not need to understand model routing, scene repair logic, retry budgets, workflow orchestration, or the machinery behind a generation. They should be able to describe what they want and let the system carry the production work.

The complicated part belongs inside the tool.

Where Video Studio stands now

As of August 24, 2026, Video Studio is still being hardened before public paid generation is switched on. The core product, account structure, billing infrastructure, generation pipeline, QA direction, and cost controls are being assembled into a production-ready system.

That means it is not finished, and that is part of why I wanted to document it now.

This project did not begin with a giant engineering plan. It began with a practical frustration and a prompt. From there, the product grew one requirement, failure, correction, and decision at a time.

If this way of building continues to improve, I think that is going to matter far beyond this one product. People who can clearly define problems, judge outputs, and keep directing AI toward a useful result are going to be able to build software that would have required a much larger technical team not very long ago.

Video Studio is my attempt to see how far that can go.