Generate subtitles with CapCut? Expensive and error-prone. Here’s the solution.

Ever had this experience?

You drop a 40-minute video into CapCut, click auto subtitle recognition. Wait forever, and then you see: names wrong, terms wrong, English abbreviations wrong. A normal sentence gets split into three, and breaks don’t land where they should.

In the end, you sit there fixing one line at a time. By the time you get to line 80, it hits you: this isn’t auto-subtitling. It’s auto-generating a to-fix list.

And to make things worse, it keeps getting more expensive.

The problem isn’t CapCut

CapCut is fine for video editing – no complaints there.

But when it comes to subtitles, it’s awkward. You just want an SRT file, but it makes you open a whole app. You just want to fix a few terms, but it makes you click around in the timeline. You just want AI to proofread against a transcript, but there’s no workflow for that.

So the problem isn’t “is there a cheaper CapCut.”

The problem is: can subtitles be separated from the editing software and handled by AI and local tools?

Yes.

I built a skill called audio-to-text.

It’s not a CapCut alternative

It’s more like a subtitle worker for AI.

You don’t need to remember a bunch of commands. Just tell Claude Code or Codex:

Help me convert this video into subtitles.

It will call a local tool to turn the video into an SRT.

Then say:

Proofread these subtitles against this glossary.

It will extract the subtitle text, fix it line by line, and safely reassemble it back into the SRT.

Then say:

Burn the subtitles into the video.

It will use ffmpeg to generate a video with hardcoded subtitles.

That’s the key point. It’s not about how cool the CLI is or how complete the parameters are. It’s about offloading the dirty work of “generate subtitles, proofread subtitles, burn subtitles” to a skill.

How to download and install

The repository is here:

texthttps://github.com/panjiangyi/audio-to-text

Installation is straightforward:

bashgit clone https://github.com/panjiangyi/audio-to-text.git cd audio-to-text ./install.sh

The install script handles several things: checks and installs ffmpeg, installs uv, installs Python dependencies, and creates a global command att.

If you just installed it and the terminal can’t find att, open a new terminal or refresh your shell config.

If you don’t want a global command, you can run it directly from the project directory:

bashuv run att stt /path/to/video.mp4 –output srt

Once installed, the only command you really need to remember is:

bashatt

Generating subtitles, proofreading, burning – let the skill call it.

First, generate subtitles

Give the video path to AI, for example:

Help me convert /path/to/video.mp4 into Chinese subtitle SRT.

The skill will run locally:

bashatt stt /path/to/video.mp4 –output srt

And next to the video you’ll get:

textvideo.zh.srt

If you only need a transcript, you can also say:

Convert this recording to text.

It will run:

bashatt stt /path/to/audio.mp3

Under the hood, it uses faster-whisper. Audio extraction from video uses ffmpeg. Everything runs locally – no uploading files, no API key, no platform dependency.

Next, tell it the proper nouns ahead of time

The most common place CapCut fails isn’t standard Mandarin.

It’s names, brand names, technical terms. The words that keep appearing in your video but the generic model can’t understand.

For example: Kubernetes, etcd, CRD, controller.

You can simply tell AI:

Generate subtitles with terms including Kubernetes, etcd, CRD, controller.

The skill will put these terms into the recognition prompt:

bashatt stt video.mp4 –output srt –context “Kubernetes, etcd, CRD, controller”

This isn’t a magic bullet. It won’t guarantee perfect recognition across the whole clip. But it eliminates a lot of silly mistakes, especially in the beginning.

The most useful part is proofreading

Normal subtitle tools stop at generating an SRT.

That’s where the real pain begins.

For example, in a course video the instructor says “vector database” but the subtitles read “xiang liang database.” The instructor says “RAG” but it comes out as “Ah Ji.” The instructor says “Claude Code” but it writes “Claude’s code.”

You stare at it.

It stares back.

This is where the skill shines. Give AI the SRT and the glossary, then say:

Proofread subtitles against this glossary. Only fix recognition errors, don’t change timestamps.

The skill first extracts the subtitle text:

bashatt srt video.zh.srt

AI only modifies the text of each subtitle line. It doesn’t touch line numbers, timestamps, merge, or split.

Finally run:

bashatt srt video.zh.srt –apply /tmp/corpus.txt –output-path video.proofed.srt

There’s an important design choice here: AI does not directly modify the SRT.

Because if AI directly edits the SRT, it might break the timestamps. Delete one empty line too many, miss copying a line number, merge two lines into one. You only discover it later in the editing software – too late.

So this skill’s approach is: AI only edits text, the CLI rebuilds. If the line count doesn’t match, it refuses to write.

That’s called keeping AI in a cage.

Nice.

Finally, burn into video

Sometimes you don’t just need an SRT. You need a finished video.

You can continue:

Burn these subtitles into the video.

The skill will use ffmpeg to create hardcoded subtitles, outputting something like:

textvideo.subbed.mp4

For Chinese videos, it also specifies a Chinese font, like Noto Sans CJK SC. Otherwise you get that classic scene: subtitles generated, characters burned in, but all Chinese text shows as squares.

Everyone goes quiet.

It solves not transcription, but workflow

Before: Open CapCut, import video, click auto subtitles, wait, fix errors, keep fixing, export. Find more mistakes, open again, fix again.

Now: Tell AI to generate subtitles. Tell AI to proofread against glossary. Tell AI to burn into video.

The dirty work in between? The skill handles it.

What makes it better than CapCut is simple: no file upload, no per-minute charges, ability to fix subtitles based on context, and timestamps that aren’t wrecked by AI.

Each of these points alone isn’t sexy.

But if you’ve worked on long video subtitles, you know it’s enough.

Who should use it

People who regularly make knowledge-based videos. People who produce courses. People who edit interviews. People who transcribe podcasts. People who process meeting recordings. And people whose videos are full of technical terms.

If you only occasionally make a personal video, CapCut is fine.

But if you’re handling subtitles every week, you’ll quickly realize: the price is not the worst part.

The worst part is having to fix mistakes yourself.

audio-to-text is not another CapCut.

It’s a subtitle skill.

You just say:

Help me convert this video to subtitles and proofread them against the glossary.

Let it handle the rest.