Redacta: Elevating Video Content with GitHub Copilot CLI

Source: Dev.to

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

Available Commands

How to Use It

Installation

npm install -g redacta

Configuration

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

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.

• Course Accelerator – Students can turn a semester’s worth of video lectures into a structured, illustrated study guide in minutes.
• Podcast Content Engine – Creators can transform audio episodes into SEO‑friendly blog posts and social‑media summaries with zero manual writing.
• Technical Documentation – Engineers can record a “brain dump” video of a complex architecture and let Redacta generate a formatted technical doc with diagrams.
• Meeting Archivist – Turn recorded town halls or technical syncs into searchable, structured summaries for team members who couldn’t attend.
• 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)       |
|                     |                        |                     |
+---------------------+                        +---------------------+

Generated outputs

• Formatted text: Intro_Large_Language_Model_LLM_talk_formatted.md
• Blog post: 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.

Generated outputs

• Formatted text: analisis_de_las_5_alegorias_formatted.md
• Blog post: analisis_de_las_5_alegorias_blog.md
• Summary: analisis_de_las_5_alegorias_summary.md

Repository

You can find the full project here:

• 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 any automation logic, I used the Copilot CLI to sketch ideas:

1. Explain the high‑level goal to the CLI.
2. Iterate on the suggested project structure and foundations.

This prevented over‑engineering. I only started building the actual script once I had manually verified the core logic (e.g., specific prompt outputs) within the CLI environment.

Pros of Using GitHub Copilot CLI

• Iterative Prompt Engineering – I could pipe a raw transcript to Copilot, apply a prompt, and see results in seconds. If punctuation was off, I adjusted the prompt and re‑ran instantly.
• Zero‑Boilerplate Prototyping – No need to set up unit tests or a full local environment just to see if an LLM could handle a formatting task. The CLI acted as a sandbox for rapid testing.
• Context‑Aware Scaffolding – When moving from a manual prompt to a script, the CLI read my project files and suggested automation logic that fit perfectly with existing patterns.

Seamless Integration with Copilot SDK

The Copilot SDK bridged the gap between experimentation and production. After finalising a prompt in the CLI, I embedded the exact same intelligence into my code via the SDK. This “Copy‑Paste Intelligence” approach dramatically reduced debugging time when integrating LLMs into the codebase.

High‑Impact Improvements

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

• TypeScript Migration – Assisted in migrating the entire codebase from JavaScript to TypeScript, suggesting types and handling boilerplate with precision.
• Testing Suite – Scaffolded a comprehensive Vitest suite, ensuring that prompt refinements never broke core functionality.