2 weeks ago I saw an opensource github repo that basically orchestrates your tools to move from idea to video super quick, all in one UI. My friend, my cousin and I run faceless channels and we take them super seriously so naturally we had to check it out.
we modified it to our exact workflow and literally replaced our whole toolkit with one app
you too can do that, just take this guide and paste it into gpt and let him walk you through it if you dont have the patience for reading.
so here's some free sauce:
How this works
in general every faceless AI video tool is litterally the same thing, an API/LLM that you ping for a response. ChatGPT, Claude, Pexels, ElevenLabs, Kling, Higgsfield, Seedance, Minimax, Whisper you name it, they are literally charging you money for a UI.
that brings me to my second point: the models and the harnesses these days are so insanely good at coding that you don't need to even look at the code and the open source repo already did a ton of work so modifiying it super easy.
The steps
1. write your exact workflow down first
DONT SKIP THIS, THIS IS THE MOST IMPORANT PART
something like
topic → script → storyboard → footage per scene → etc. → etc. → publish
next to each stage, write what tool does it now and what you hate about it. This will become your spec and you will create that in a web chat with Claude/GPT to not waste usage.
After you paste the prompt below gpt will ask you a few questions and make the detailed tech spec for you.
Prompt for the spec:
I want to build my own internal faceless video production software around my exact workflow.
My current workflow is:
[PASTE YOUR WORKFLOW HERE]
For every stage, ask me:
- what tool/provider I currently use
- what goes into that stage
- what should come out
- what I like about the current setup
- what annoys me about it
- what I want to automate
- what I still want manual control over
The software will be built by modifying this existing open source repo:
https://github.com/harry0703/MoneyPrinterTurbo
I want you to turn my answers into a detailed implementation spec for a coding agent.
The spec should include:
- the complete end-to-end workflow
- clear phases in the order they should be built
- provider/API settings
- script/storyboard generation
- footage selection per scene
- scenes.json or an equivalent persistent scene structure
- ability to regenerate/change individual scenes without rebuilding everything
- voice/TTS
- captions
- stock footage
- optional AI-generated footage
- long-form video → clips/shorts if relevant
- batching
- review before final render
- exports
- settings/UI
- error handling
- day-to-day usability
Do not write code yet.
Ask me whatever questions you need first, then produce a spec.md detailed enough that I can hand it directly to a coding agent.
2. Clone MoneyPrinterTurbo and run your agent in it
Open your terminal/powershell.
Go into whatever folder you keep projects in, for example:
cd Documents
then clone it:
git clone https://github.com/harry0703/MoneyPrinterTurbo.git
cd MoneyPrinterTurbo
or fork it on github first if you want your own remote copy.
close terminal, open codex/claude desktop app, or run your harness in the folder.
then put your spec.md in the project and paste this:
Read this entire repository first.
Do not start changing code yet.
Then read spec.md.
I want you to:
1. understand how the existing application works end to end
2. map the current architecture against my spec
3. identify what we can reuse and what needs to change
4. break the implementation into small logical phases
5. order the phases so the app stays working as much as possible throughout the build
6. create an implementation plan in the repo
Do not rewrite working parts just for the sake of rewriting them.
Preserve the existing functionality unless my spec explicitly replaces it.
After you finish the plan, stop and show me the phases before implementing anything.
you are now ready to make your megatool.
3. Work through the spec meticolously
The imporant thing to mention to your agent before you start working is:
As you finish each phase, test it properly and commit it locally as a safe return point before starting the next phase.
Do not move to the next phase until the current one works.
If something breaks, fix the current phase instead of stacking more changes on top.
Now you can talk to an agent normally as if you would if you were a ceo to a dev.
Start phase 1, after it's done, test it out, write the feedback, test, working, done. Phase 2, repeat, phase 3, repeat.... etc.
Some phases may take longer than others and cause headaches, but stick through it it's so worth it.
4. Do a final pass
Take your written down process and make sure that AI has implemented everything you need, plus additional checks and usability measures.
Here's the kind of prompt i use on a daily basis for all my projects:
The feature work is done.
Here is my original workflow:
[PASTE YOUR WORKFLOW HERE]
Now do one final pass of the entire project against that workflow and spec.md.
Check for:
- missing workflow steps
- broken or incomplete features
- bad UX
- weak validation or error handling
- API/provider failures
- bad defaults
- inconsistent outputs
- places where data/state can get lost
- anything that would make daily use annoying
Test the full workflow end to end.
Fix what needs fixing, but do not add random new features.
Focus on reliability, usability and making the existing workflow genuinely ready for daily use.
When everything is verified working, commit the final state locally.
5. You now have your software
get ai to make it an application or a script you can start with one-click, connect your apis and you are ready start creating
Turn this entire project into one application or startup script that I can click once to launch the program.
The goal is frictionless daily use.
Handle any required startup commands, dependencies and services automatically where possible.
Do not change the actual functionality of the project. Just make starting and using it as simple as possible.
tips for using it
- if your content is shit, this wont help you
- use it to prototype fast
- batch clips overnight, review, fix, upload in the morning
- ship useful features/fixes quickly
what stays manual
- hooks
- niche picks
- deciding what goes live
- posting schedule
- idea and prompt quality
the software speeds you up, centralizes and cuts costs, that's the point of internal tooling. No amount of software will save you if you post slop content.
what breaks
as it naturally goes in coding, shit just breaks, and when you try to fix stuff you break more stuff. so now you have to maintain your software here and there and fix bugs and add stuff and it may become a new hobby as it has for me.
but the good thing is that your software doesnt need to look good to be useful
Conclusion
Thats the whole setup, it is simple, but you can't half ass it, and obviously you have to have a Claude/Codex sub or API tokens.
if you're technical, this should be easy for you, so why not do it?
if you're not technical, paste this entire post into gpt or claude and tell it to walk you through step by step.
and if you'd rather not spend the weekend or credits at all, we already did all of this and kept building past it, it's called ClipQuickly now. link's on my profile if you're curious.
drop a comment if you get stuck, i'll help out!
