Build a Free Audio-to-Subtitle Tool in 5 Minutes with Codex: A Practical Alternative to JianYing SVIP

After JianYing (CapCut China) upgraded its subtitle recognition feature to SVIP-only, many creators started looking for alternatives. Rather than paying a monthly fee, why not build your own? Using OpenAI's Codex programming tool, one developer built a free audio-to-subtitle tool from scratch in just 5 minutes, with results nearly identical to JianYing. This article provides a complete breakdown of the development process, showing how AI programming tools enable anyone to quickly build practical software.

Why Build Your Own Subtitle Tool

JianYing is one of China's most popular video editing tools, and its automatic subtitle recognition feature has long been a favorite among creators. However, this feature now requires a SVIP subscription, and the monthly fee isn't worthwhile for occasional users or those on a tight budget.

In reality, Automatic Speech Recognition (ASR) technology is already very mature. ASR has undergone a long evolution from traditional Hidden Markov Models to deep learning end-to-end models, and has now reached a remarkably high level of industrial maturity. OpenAI's Whisper model, open-sourced in 2022, is a milestone achievement in this field — built on the Transformer architecture and trained on 680,000 hours of multilingual labeled data, it supports 99 languages including Chinese with impressive accuracy. Whisper offers multiple versions including tiny, base, small, medium, and large, with parameter counts ranging from 39M to 1550M, allowing users to choose flexibly based on hardware capabilities and accuracy requirements.

The real barrier isn't the technology itself, but how to assemble these technologies into a user-friendly tool. And this is precisely what AI programming tools like Codex excel at — turning your ideas into working code quickly.

Using Codex Plan Mode to Design the Development Approach

Step 1: Define Requirements and Let AI Think First

The entire development process began with Codex's Plan mode. OpenAI Codex is a cloud-based sandbox AI programming agent that can autonomously read and write code, install dependencies, execute commands, and verify results within an isolated virtual machine. Unlike directly asking AI to write code, Plan mode first helps you organize your implementation approach, providing clear step-by-step planning rather than jumping straight into coding. This mode draws from the "design-first" philosophy in software engineering — in large projects, fixing errors during the architecture design phase costs far less than during the coding phase. Plan mode uses multi-turn conversations to help users progressively clarify technology choices, feature boundaries, and implementation paths, essentially automating the requirements analysis and high-level design process. This "think first, act later" approach significantly reduces back-and-forth modifications later on.

The developer's initial instruction was remarkably concise:

Develop an audio-to-subtitle feature. Please help me think through the implementation steps and approach. My initial idea is to use a local model rather than an external API.

It's worth noting that choosing a local model over a cloud API was a deliberate decision. Cloud APIs (such as OpenAI's Whisper API, Google Speech-to-Text) require no local computing power and charge by API calls or audio duration, making them suitable for lightweight or production environments. Local deployment, on the other hand, runs the model on the user's own device, with advantages including zero marginal cost, no network dependency, and complete data privacy control. For subtitle generation — a one-time batch processing task where audio content may involve unpublished creative material — local processing eliminates privacy concerns about data uploads, making it the more reasonable choice.

Step 2: Interactive Q&A to Progressively Refine the Plan

Codex doesn't provide a fixed solution right away. Instead, it asks a series of questions to understand the developer's actual needs:

• Implementation format: Command-line tool or web application?
• Programming language: Python or something else?
• Model size: Whisper small, medium, or large version?
• Subtitle format: SRT, ASS, or other?

The developer chose the Whisper small model (approximately 244M parameters, runs smoothly on consumer-grade CPUs, with Chinese recognition accuracy sufficient for most daily scenarios — perfectly adequate as an initial attempt) and SRT format. SRT (SubRip Subtitle) is currently the most widely used subtitle file format, with an extremely simple structure: each subtitle entry consists of a sequence number, a timestamp (formatted as HH:MM:SS,mmm --> HH:MM:SS,mmm), and text content, with entries separated by blank lines. It's precisely because of this simple plain-text structure that SRT is supported by virtually all major players (VLC, PotPlayer), editing software (Premiere Pro, Final Cut Pro, JianYing), and streaming platforms (YouTube, Bilibili), making it the most universal subtitle format choice.

After reviewing the first draft of the plan, the developer agreed the overall technology stack was sound but removed the automated testing component — since this kind of small tool can be verified manually without issue.

This interactive process demonstrates the core value of Plan mode: It doesn't make decisions for you; it helps you transform vague ideas into executable plans. After two rounds of plan iteration, the developer confirmed the approach was viable and gave Codex the green light to start writing code.

The Complete Process from Code Generation to Debugging

Codex Automatically Generates a Complete Project Structure

Codex completed the entire thinking and code generation process in approximately 4-5 minutes, outputting a complete project structure including:

• pip commands for installing dependencies
• A Whisper-based audio conversion core script
• README documentation (with installation steps and usage instructions)

Notably, the generated README included a "keyword" parameter, but the developer hadn't requested a keyword matching feature. The solution was simple — just ask Codex directly. This cycle of "discover issue → ask → understand" is the normal state of collaborating with AI programming tools.

Encountering Errors? Just Hand Them to Codex

The first execution of the conversion command predictably resulted in an error. The handling approach was straightforward: copy the terminal error message directly to Codex, which analyzes the cause and provides the corrected command. In this case, the issue was simply a command parameter format error — re-executing with the corrected command resolved it immediately.

Reusing a Local Whisper Model to Avoid Redundant Downloads

After correcting the command, the program appeared to "hang" — with no progress indication whatsoever. After reporting this to Codex, the developer learned that the tool was downloading the local Whisper ASR model, expected to take 5-15 minutes.

But the developer already had the Whisper model files locally and didn't want to waste time and disk space on a redundant download. So they told Codex: "Use my existing local model directly." Codex then automatically searched the local file system, found the existing model file, and modified the code to point to that path. The Whisper small model typically processes a 10-minute audio clip in 1-3 minutes on a modern laptop CPU, which is entirely acceptable. Reusing existing model files lets you skip the download wait and start converting immediately.

The entire process required no manual path searching — just one instruction, and Codex automatically handled the search and replacement. This is especially friendly for users unfamiliar with file system structures.

Subtitle Quality Verification and Web Interface Upgrade

SRT Subtitle Results in Practice

After importing the generated SRT subtitle file into JianYing, the results were satisfying:

• Accurate timestamp matching: Subtitles synced perfectly with audio, with no noticeable delay
• Natural segmentation: Sentence breaks were reasonable, with no instances of a single sentence being split across segments
• Accurate recognition: The transcribed text was highly consistent with the original audio

For a free tool developed in 5 minutes, these results fully meet daily use standards and are sufficient to replace JianYing's SVIP subtitle feature.

Upgrading from Command Line to a Web Visual Interface

While the command-line tool was fully functional, it wasn't intuitive to operate. To lower the usage barrier, the developer further requested that Codex develop a simple web page supporting the following features:

• Drag-and-drop or click-to-upload audio files
• A "Start Processing" button to initiate conversion
• Real-time progress bar display
• One-click download of the generated SRT subtitle file

For Codex, implementing this requirement was straightforward. The resulting web interface had a clear workflow: upload audio → click process → wait for progress bar to complete → download SRT file. With that, a complete audio-to-subtitle product — from command line to visual interface — was fully developed.

Practical Lessons from AI Programming Tools

Four Principles for Effective Collaboration with Codex

From this audio-to-subtitle development case, we can extract several key principles for collaborating with AI programming tools:

1. Plan before executing: Use Plan mode to let AI clarify the approach before writing code, avoiding rework
2. Continuous feedback: When encountering errors, don't struggle alone — feed error messages and anomalies directly to the AI
3. Incremental development: Implement core functionality first (command-line audio-to-subtitle), then gradually enhance (web interface, progress bar)
4. Maintain control: Review plans, cut unnecessary features, specify local resources — humans remain the decision-makers

Incremental Development is one of the core practices in agile software development. Its central idea is to break a product into multiple independently deliverable increments, each being a runnable, verifiable version. In this case, the developer first delivered the command-line version as a Minimum Viable Product (MVP), verified core functionality was correct, and then layered on the web interface. The advantage of this strategy is that each step provides immediate feedback, with risk distributed across iterations rather than being discovered only during final integration. AI programming tools are naturally suited to this workflow — each conversation is an iteration cycle, allowing users to complete the full loop of "state requirements → generate code → test and verify → provide feedback" within minutes.

Redefining What It Means to "Know Programming"

The most inspiring aspect of this case is that the developer didn't need to be proficient in Python, understand the details of Whisper's API, or even know SRT file format specifications. They only needed to clearly know what they wanted, then collaborate with Codex through natural language to get a fully functional product.

The next time we encounter software that charges a fee or a feature that's been restricted, it's worth asking: Can I build my own version with an AI programming tool? Taking Codex paired with Whisper as an example, from audio-to-subtitle conversion to generating SRT files, the entire process takes no more than 5 minutes at zero cost. The answer may be more optimistic than you'd expect.