playbooks

home / skills / git-fg / thecattoolkit / processing-media

processing-media skill

/plugins/sys-multimodal/skills/processing-media

This skill analyzes and edits video using ffmpeg, translating natural language commands into edits while ensuring quality.

npx playbooks add skill git-fg/thecattoolkit --skill processing-media

Review the files below or copy the command above to add this skill to your agents.

Files (7)
SKILL.md
1.5 KB
---
name: processing-media
description: "Handles video editing, ffmpeg processing, and visual analysis. Use when transforming raw footage into polished output or analyzing visual content."
allowed-tools: [Read, Write, Edit, Glob, Bash(ffmpeg:*), Bash(ffprobe:*)]
---

# Video Editing Protocol



## Standards & Styles

### 1. Cinematic Style
- **Color:** High contrast, teal/orange grading, 24fps.
- **Motion:** Smooth stabilization, slow motion (60fps -> 24fps).
- **Audio:** Music-driven cuts, immersive sound design.

### 2. Vlog / Social Style
- **Color:** Bright, saturated, natural skin tones.
- **Motion:** Fast cuts, jump cuts, handheld feel.
- **Audio:** Clear dialogue, background music ducking.

### 3. Corporate / Explainers
- **Color:** Clean, neutral, branded palette.
- **Motion:** Static shots, smooth transitions, screen recordings.
- **Audio:** Voiceover-dominant.

## Workflow
1.  **Analyze**: Use processing-media skill to understand video content (specs, visual content).
2.  **Translate**: Convert natural language command to edit parameters (EDL/FFMPEG).
3.  **Edit**: Apply changes using ffmpeg.
4.  **Verify**: Validate output quality programmatically (Self-Verification).



## Quality Standards
- No artifacts or quality degradation
- Clear dialogue, balanced audio levels
- Narrative flow enhancement
- Accurate intent interpretation

## Reference Library
- `references/edl-generation.md`: How to structure complex edits.
- `references/frame-analysis.md`: Visual inspection protocols.
- `references/ffmpeg-recipes.md`: (Common commands - *to be populated*)

Overview

This skill handles video editing, ffmpeg-based processing, and visual analysis to turn raw footage into polished deliverables. It encodes editing intents into reproducible workflows and enforces quality standards for color, motion, and audio. Use it to automate conversions, generate edit decision lists, and validate final outputs programmatically.

How this skill works

The skill inspects input media to extract specs (codec, frame rate, resolution) and performs frame-level visual analysis for shot detection, stabilization needs, and color grading cues. Natural language edit requests are translated into parameterized EDLs and ffmpeg command sequences which are executed to render edits. Outputs are verified with automated checks for artifacts, audio balance, and expected metadata.

When to use it

  • Converting multi-rate footage to a single target frame rate and codec
  • Applying style-driven color grading and stabilization across clips
  • Automating repetitive edits from a written edit plan or storyboard
  • Generating low-resolution proxies and final deliverables
  • Running automated visual QA to detect artifacts or incorrect renders

Best practices

  • Analyze source specs and create proxies before heavy processing
  • Translate commands into explicit EDLs to keep edits reproducible
  • Prefer lossless or high-bitrate intermediates for color work
  • Run self-verification checks for audio levels, frame integrity, and metadata
  • Keep style presets (cinematic, vlog, corporate) as parameter templates

Example use cases

  • Convert 60fps action footage to 24fps slow-motion with motion blur and stabilization
  • Batch grade a set of corporate training videos to a neutral branded palette while preserving dialogue clarity
  • Produce social clips with fast cuts, audio ducking, and bright, saturated color from long-form footage
  • Generate an EDL from a director’s text notes and render the timeline with ffmpeg commands
  • Detect dropped frames or compression artifacts in a delivered master and flag failures

FAQ

What input formats and frame rates are supported?

The skill reads common codecs and containers and normalizes varied frame rates into target timelines; uncommon formats may require pre-transcoding.

How does verification work?

Verification runs programmatic checks: artifact detection, audio loudness and ducking validation, frame-count consistency, and metadata comparison against expected values.

Can I customize style presets?

Yes. Styles are exposed as parameter templates (color curves, LUTs, stabilization settings, cut pacing) that you can modify and reuse.