How To Start A Faceless YouTube Channel With AI

Most people trying to start a faceless channel begin with the wrong question. They ask which AI tool makes the video. The channels that actually work started somewhere else entirely: they copied the two repeatable assets behind a channel that was already winning, and then produced episode after episode from those two assets. Everything below is that process, run end to end in Claude Code.

The reference channel for this build is called Zen. It had posted for two months, put out 19 videos, and had 156,000 subscribers, with its most popular video sitting above 7 million views. The estimated ad revenue was close to $12,000 a month. The illustrations look like something a child drew with a marker. That is not an accident, and it is not a shortcut. It is the whole point.

A second channel, Nick Invest, runs the same simple animation style with 185,000 subscribers and earns less from ads but routes traffic into a paid community. Two channels, one visual language, two different money models. The style is proven, so you are not gambling on whether the format works, only on whether you can reproduce it.

Watch one of those videos with the intent of taking it apart and you find only two components that matter. The script, and the images. That is it. There is no editing craft hidden in there, no motion design, no on-camera presence. Once you can reproduce those two things reliably, you have a channel.

Do not describe the style from memory and do not ask an image model to guess. Take five screenshots from the reference channel, chosen to cover different kinds of subject matter, and hand them to Claude Code as a set. In this build that meant an abstract object like a light switch, a group of people, and a simple chart. Different subjects, same style, so the analysis has to isolate what is constant.

What you ask for is two things, not one. First, a short positive style description you can paste straight into an image generator. Second, a list of negative prompts that stop the generator drifting toward polished or photorealistic output. Then add the instruction that does the actual work: focus on style characteristics only, not subject matter.

That last line is what makes the result reusable. Without it you get a description of a fire, an elephant, or a crowd, and the string is useless the moment your topic changes. With it you get something like hand-drawn marker doodle illustration with thick uneven black felt-tip outlines, plus an explicit list of what it is not: not a 3D render, not a photograph, not photorealistic. That pair of strings is the asset. Save it in the project folder and every future episode inherits it.

Before committing credits to a full episode, ask for a prompt for one throwaway scene in the locked style and generate exactly that one image. In this build the test scene was an elephant going to the watering hole. It came back correct on the first try, which is the only signal you need to move on.

The test generation ran through Higgsfield on GPT Image 2 at low quality and 1K resolution, and it cost half a credit. That is the right setting for a test and the wrong setting for a real episode. For anything going on YouTube, bump the resolution to at least 2K. A 1K image scaled up to fill a 1080p or 4K frame looks soft in a way viewers register as cheap even when they cannot name it.

• Testing a style: lowest quality, 1K, one image. You are checking the style string, not the output.
• Real episode: 2K or higher, since these images fill the entire frame for several seconds each.
• Thumbnail: highest quality you can afford, because it is the only image that has to work at postage-stamp size and full size at once.
• Re-tests after a style tweak: back to the cheap setting. Only the final run pays for quality.

Take the highest-performing video on your reference channel, copy the URL, and hand it to Claude Code with yt-dlp, which is a free tool for pulling transcripts from any YouTube video. Then ask for a structural breakdown rather than a summary: the hook, the intro, the shape of the body, the transition sentences, and the overall length.

On the 7 million view video, that breakdown came back with the hook broken into four separate beats, the core promise of the video stated in one line, and the three pillars the body was built on. That document is worth more than any individual script, because you are extracting the container, not the contents. One container produces every future episode.

Keep this in the same project folder as the style strings. Working in one folder is what lets separate Claude Code sessions reference each other's output without you copying anything between them. The script breakdown, the style pair, the audio, the images, and the final video all end up in the same place.

This is the fork that separates people who make one faceless video from people who run a channel. You can write each script in a fresh chat and re-explain the format every time, or you can turn the format into a skill once and then hand it a topic. The skill is the actual product of this build. The first video is just proof it works.

When you ask Claude Code to build the skill, it will ask you questions before it writes anything. Answer them deliberately, because these answers get baked in:

• Whose voice should the scripts be in? Match the reference channel's style rather than your own brand voice. You are reproducing what already works, and your voice arrives later once the format is earning.
• Should the skill research first or just build the structure? Research. The format's authority comes from real named studies, dates, and hard statistics, and a script without them reads hollow.
• Should it output visual direction alongside the script, or just the clean script? Just the clean script. The images come from timestamps later, and mixing visual notes into the script makes it harder to read aloud.

The skill built here has four stages: write the script, wait for and transcribe the recording, generate the images, and stitch the final video. Build stage one first and test it before adding the rest. The test run in this build generated a script on the topic of why we dream, opening with the line about your brain building an entire world tonight when you close your eyes, and it was immediately clear the container had transferred.

This is a real decision point with a real downside on one branch. An AI voice generator is faster and needs no recording setup. It also risks getting flagged by YouTube, and a flag on a monetized channel can cost you the account. Recording yourself takes ten minutes per episode and removes the entire category of risk.

The setup is deliberately unimpressive. Voice Memos on a Mac, read the script, right click the recording, show in Finder, and drag the file into the project folder. No microphone purchase, no audio editing, no studio. Faceless channels in this style are carried by pacing and writing, not by broadcast-grade audio.

If you truly cannot record, the honest answer is that you are accepting platform risk in exchange for speed, and you should know you are making that trade rather than discovering it later. Recording is the branch worth taking, and it is the one used in this build.

Once the audio is in the folder, the skill's second stage picks it up and transcribes it with Whisper, adding timestamps. Whisper runs locally on your machine, which means it is free and you can run it as many times as you want without watching a meter. Re-record a line, re-transcribe, no cost.

What comes back is not one block of text with a start and end time. Whisper produces a separate timestamp for every phrase, so each beat of the delivered script becomes its own entry with its own start point. In this build that produced 16 entries from a couple of paragraphs read aloud.

Here is the insight worth taking away even if you never make a faceless video. Nobody edits anything in this pipeline. The timestamp file is simultaneously the shot list, the image count, and the cut points. One timestamp equals one image equals one cut, so the edit is derived rather than performed.

That is why the whole thing can be automated in a way that a normal video edit cannot. Editing is a series of taste judgments about when to cut. Here the voice already made every one of those judgments while you were reading, and Whisper wrote them down. There is nothing left to decide.

The pattern applies far beyond YouTube. Any time you can get a machine-readable structure out of a human performance, you can build the rest of the artifact from that structure automatically. Timestamps drive slideshows and course modules the same way. Look for the file that is quietly the edit decision list, and the automation writes itself.

Connect your image generator to Claude Code so it can produce assets without you leaving the terminal. Higgsfield exposes an MCP endpoint, which is the standard way to give Claude Code access to an outside service. The setup runs once:

1. 1In Higgsfield, open the MCP and CLI section and copy the MCP link.
2. 2In Claude Code, click the plus, go to connectors, then manage connectors, then the plus again.
3. 3Choose add custom connector, name it Higgsfield, paste the link, and click add.
4. 4Sign in with your Higgsfield account when prompted.
5. 5Set the new tools to always allow, so you are not approving every single image by hand.

Then the instruction for stage three has two halves and both are load-bearing. Tell it to read the transcript carefully and create a separate image for each timestamp, showing it what a timestamp entry looks like so there is no ambiguity about the count. Then paste in the positive and negative style strings you extracted at the start, with the requirement that every image must match that styling.

At roughly two credits per image, 16 images cost about 32 credits. Whether that is cheap depends entirely on what the channel is earning, and early on it is a real cost against zero revenue. Budget per episode, not per image, and decide upfront how many episodes you are willing to fund before the channel has to pay for itself.

The final stage takes the images in timestamped order, holds each one until the next timestamp begins, and lays the voiceover underneath. FFmpeg does this and it is free. There is no timeline, no export queue, and no editing software involved at any point.

That is the whole pipeline. Style extracted once, script format extracted once, both turned into a skill, then a recording, a transcription, an image per timestamp, and a stitch. The output is a finished faceless video and, more importantly, a reusable pipeline you can point at any topic. Type the skill name, give it a topic like why cheetahs are so fast, and the four stages run.

Every one of these is cheaper to read now than to learn on episode four.

• Inventing your own visual style instead of extracting a proven one. You lose the only variable you had already de-risked.
• Extracting a style with no negative prompt list, which lets the images drift toward polish across a long batch.
• Generating a full episode at test-quality resolution. Half a credit per image is the right price for a test and the wrong look for YouTube.
• Rewriting the script format instead of reusing it. The container is what earned the views on the reference channel.
• Using an AI voice generator on a channel you intend to monetize, which risks a flag and the account.
• Working across scattered folders, so the style strings, the script breakdown, and the audio cannot see each other.
• Building all four stages of the skill before testing stage one. A broken script stage means every later stage is debugging the wrong thing.
• Making one video and stopping. The channels earning here posted 19 videos in two months, and the outlier was one of them.

This is the shortest honest path from reading this to having a real video file on your desktop. Give it an afternoon.

1. 1Find a faceless channel in a niche you can stand, with a video well above its own average. That outlier is your reference.
2. 2Screenshot five frames covering different subject matter, hand them over, and ask for a positive style description plus a negative prompt list, style only.
3. 3Generate one test image of any scene at the cheapest setting to confirm the style holds.
4. 4Give the reference channel's best video to Claude Code with yt-dlp and ask for the format breakdown: hook, intro, body structure, transitions, length.
5. 5Turn that breakdown into a skill that writes a script from any topic, then test it on one topic before adding anything else.
6. 6Read the script into Voice Memos and drop the file into the project folder.
7. 7Transcribe it locally with Whisper, with timestamps, and count the entries. That number is your image count.
8. 8Generate one image per timestamp at 2K in the locked style, then stitch everything with FFmpeg.

Do that once and you have a video plus a pipeline. Do it three more times and you have a channel, because from here every new episode costs one topic, ten minutes of reading aloud, and a batch of images.

The first episode proves the pipeline. It is unlikely to prove the channel. Volume is what finds the outlier, and the reference channel found its 7 million view video somewhere inside 19 uploads across two months. Plan for that shape rather than expecting the first one to land.

• Keep the style and the format fixed across the first ten episodes. Changing both at once means you learn nothing from the results.
• Vary the topic and the hook, since those are the two variables that actually move views on a format that already works.
• Watch which topics outperform and produce more from that cluster rather than spreading across unrelated subjects.
• Decide early whether ad revenue or traffic to something you own is the goal. The reference channels split on exactly this, and it changes what you say at the end of every video.

The framework above is the complete system and every stage of it can be run by hand today with free tools plus image credits. Running it by hand once is how you learn which stages actually carry the result, which is why the whole thing is written out here rather than held back.