Redacta: Elevating Video Content with GitHub Copilot CLI

What I Built

Redacta is a personal solution born from a specific need: the desire to reclaim knowledge trapped in audio and video formats.

As someone with a strong visual memory, I’ve always found reading to be far more effective than watching a video or listening to a podcast. Phrases and images stick better in my mind when I can see them on a page. I can scan text to find concepts, refresh my memory on specific sections, or quickly identify the core message of a paragraph.

However, the world is full of incredible content delivered via video and audio. Unfortunately, I often feel I'm not getting the most out of it because it’s not written down. Searching within a video is a pain, and finding that one specific episode of a podcast I want to revisit is nearly impossible.

I tried reading raw transcriptions, but they are often unreadable—especially YouTube’s auto-generated captions, which lack punctuation, formatting, and proper structure.

Redacta was built to solve this. It takes a raw transcription and, using the power of GitHub Copilot and LLMs, transforms it into a well-redacted, properly punctuated document that remains strictly faithful to the original content.

Since its inception, I’ve expanded Redacta to:

Illustrate the text: Automatically adding images and schematics to aid visual learning.
Generate Summaries and Posts: Creating different formats tailored for quick reading or deep study.
Break Language Barriers: Translating content into other languages, allowing me to access knowledge originally shared in languages I don't speak fluently.
Redacta isn't just a tool; it's a bridge between the vast world of video/audio content and the way my brain actually processes knowledge.

Core Capabilities

• Semantic Redaction: Transforms disjointed, messy transcripts into cohesive, well-structured documents.
• Visual Enrichment: Automatically inserts relevant images and ASCII diagrams to illustrate complex concepts.
• Multilingual Intelligence: Processes transcripts and generates outputs in various languages seamlessly.
• Interactive TUI: A beautiful, real-time terminal interface using ink to monitor progress.
• Batch Mastery: Efficiently processes entire directories of transcripts in one go.

Available Commands

Redacta is designed to be flexible. Here are the primary ways to interact with it:

Command	Action
--blog	Generates a polished blog post (_blog.md)
--summary	Creates a concise executive summary (_summary.md)
--language=<lang>	Sets the target output language
--with-illustration	Adds key images and diagrams for clarity
--with-illustration-all	Deep illustration: adds comprehensive visual aids
--directory=<dir>	Batch process all .srt files in a folder
--model=<id>	Choose your preferred LLM model

How to Use It

Getting started with Redacta is straightforward.

1. Installation

npm install -g redacta

2. Configuration

export CUSTOM_SEARCH_KEY='your_key'
export CUSTOM_SEARCH_PROJECT='your_id'

3. Usage Examples

Basic cleanup in a specific language:

redacta tutorial.srt --language=spanish

Complete transformation (Blog + Summary + Diagrams):

redacta lecture.srt --blog --summary --with-illustration-all

---

Proposing Use Cases

Redacta isn't just for cleaning text; it's for unlocking the value in your media library.

1. Course Accelerator: Students can take a semester's worth of video lectures and turn them into a structured, illustrated study guide in minutes.
2. Podcast Content Engine: Creators can transform their audio episodes into SEO-friendly blog posts and social media summaries with zero manual writing.
3. Technical Documentation: Engineers can record a "brain dump" video of a complex architecture and let Redacta generate a formatted technical doc with diagrams.
4. Meeting Archivist: Turn recorded town halls or technical syncs into searchable, structured summaries for team members who couldn't attend.
5. Cross-Border Learning: Understand high-quality technical content from global experts by translating and formatting transcripts from languages you don't speak.

---

Demo

To see Redacta in action, let's look at two very different scenarios that showcase its versatility.

1. High-Level Technical Education

The first example is a technical talk by Andrej Karpathy about Large Language Models.

Source: Intro to Large Language Models by Andrej Karpathy.

Command:

node ./dist/bin/redacta.js ./examples/Intro_Large_Language_Model_LLM_talk.srt --with-illustration --blog

For technical content, Redacta focuses on structural clarity and visual aids. It doesn't just clean the text; it identifies core architectural concepts and generates ASCII diagrams to bridge the gap between spoken word and visual understanding.

Generated Snippet (Knowledge Scaffolding):

A large language model is just two files. For example: the Llama 2 70B model. It consists of the parameters file (weights) and the run file (code).

+---------------------+           uses         +---------------------+
|                     |----------------------->|                     |
|  PARAMETERS FILE    |                        |     RUN FILE        |
|  (140GB, float16    |                        |  (C/Python code,    |
|   weights)          |                        |   ~500 lines)       |
|                     |                        |                     |
+---------------------+                        +---------------------+

• This is the raw transcript (input):

  • transcript: Intro_Large_Language_Model_LLM_talk.srt

• And these are the generated texts (output):

  • formatted text: Intro_Large_Language_Model_LLM_talk_formatted.md
  • blog: Intro_Large_Language_Model_LLM_talk_blog.md

2. Art History & Analysis (Multilingual)

Source: Las 5 alegorías (Analysis of Baroque Art).
Command:

node ./dist/bin/redacta.js ./examples/analisis_de_las_5_alegorias.srt --with-illustration --summary --language=English --blog

This example highlights Redacta's ability to handle cross-language translation and precision image insertion. The tool translated the Spanish lecture into a structured English blog post while automatically finding the specific masterpieces being discussed.

Generated Snippet (Visual Context):

Claesz ingeniously weaves each sense into the composition:

• Hearing: Musical instruments evoke the sense of sound.
• Sight: The painting itself, along with a mirror reflecting a wine glass.

Image: Still Life with Musical Instruments - 1623

Redacta successfully identified the specific painting (Still Life with Musical Instruments) from the transcript context and embedded it exactly where the description occurs.

• This is the raw transcript (input):

  • transcript: analisis_de_las_5_alegorias.srt

• And these are the generated texts (output):

  • formatted text: analisis_de_las_5_alegorias_formatted.md
  • blog: analisis_de_las_5_alegorias_blog.md
  • summary: analisis_de_las_5_alegorias_summary.md

Repository

Here you can find the repository:

• Redacta

---

My Experience with GitHub Copilot CLI

I used GitHub Copilot CLI from the very first line of code. It wasn't just a helper; it was a fundamental partner in the architectural journey of Redacta.

Philosophical Approach: "CLI First, Automation Second"

My workflow followed a strict "CLI First" philosophy. Before writing a single line of automation logic, I used the GitHub Copilot CLI to "sketch" my ideas. I would explain my high-level goal to the CLI and work with it to set up the project structure and basic foundations.

This prevented over-engineering. I only started building the actual script once I had physically verified the core logic (like specific prompt outputs) manually within the CLI environment.

Pros of Using GitHub Copilot CLI

• Iterative Prompt Engineering: The biggest advantage was the speed of testing. I started with the 'Editor' prompt—the core of Redacta. In the CLI, I could pipe a raw transcript to Copilot, apply a prompt, and see results in seconds. If the punctuation was off, I'd adjust the prompt and re-run instantly.
• Zero-Boilerplate Prototyping: I didn't have to set up unit tests or local environments just to see if an LLM could handle a specific formatting task. The CLI provided a sandbox where I could test models and prompts as if they were simple shell commands.
• Context-Aware Scaffolding: When I was ready to move from a manual prompt to a script, I could ask the CLI to read my project files and suggest the automation logic, ensuring the new code fit perfectly with existing patterns.

Seamless Integration with Copilot SDK

The Copilot SDK was the secret weapon that bridged the gap between experimentation and production. Once I was happy with a prompt's performance in the CLI, I used the SDK to embed that exact intelligence into my code.

The transition was frictionless; the SDK allowed me to keep the same models and prompt structures I had already "stress-tested" in the CLI. This "Copy-Paste Intelligence" approach significantly reduced the debugging time usually associated with integrating LLMs into a codebase.

High-Impact Improvements

As Redacta grew, the CLI handled the "heavy lifting" that usually slows down a project:

• TypeScript Migration: It assisted in migrating the entire project from JavaScript to TypeScript, suggesting types and handling the boilerplate with precision.
• Testing Suite: It helped scaffold a comprehensive testing suite with Vitest, ensuring that as I refined the prompts, I wasn't breaking core functionality.