Skill

Pass

Audit score 90

raw-video-processing

zc277584121/marketing-skills

Remove silent segments and speed up raw screen recordings with FFmpeg-based post-processing.

What is raw-video-processing?

Post-process raw screen recordings to improve pacing by automatically detecting and removing silent segments, then applying a speed boost. Uses FFmpeg and Python scripts optimized for screencasts with keyboard noise. Run when you have a raw recording that needs cleanup before publishing.

Detect and remove silent segments from video (threshold tuned for keyboard noise at -20dB)
Preserve non-silent content with configurable padding around speech boundaries
Apply playback speed multiplier (default 1.2x) to compressed video
Preview changes with dry-run mode before committing to file output
Support custom output paths and threshold/duration parameters for different cleanup aggressiveness

How to install raw-video-processing

npx skills add https://github.com/zc277584121/marketing-skills --skill raw-video-processing

Prerequisites

FFmpeg installed and available in PATH
uv (Python package manager) installed
Python 3.12 or compatible version

Claude Code

Cursor

Windsurf

Cline

How to use raw-video-processing

1.Run remove_silence.py on your input video: `uv run --python 3.12 /path/to/skills/raw-video-processing/scripts/remove_silence.py input.mp4 -t="-20dB" -d 0.5`
2.Review the printed summary of detected silent segments and kept content to confirm the result looks reasonable
3.Run speed_video.py on the silence-removed output: `uv run --python 3.12 /path/to/skills/raw-video-processing/scripts/speed_video.py input_nosilence.mp4`
4.Find your final processed video at `input_nosilence_1.2x.mp4` (or custom output path if specified)

Use cases

Good for

Clean up a raw screencast with long pauses and keyboard typing sounds before publishing
Speed up a verbose tutorial recording to improve viewer engagement without losing content
Remove dead air from a recorded demo while preserving all spoken narration
Batch process multiple screen recordings with consistent silence removal and speed settings
Preview silence detection results on a long video before committing to re-encoding

Who it's for

Content creators publishing screencasts or tutorials
Developers recording demo videos or technical walkthroughs
Educators preparing video lectures or training materials
Anyone with raw screen recordings that need pacing optimization

raw-video-processing FAQ

What threshold and duration should I use?

For screencasts with keyboard noise, always use `-t="-20dB" -d 0.5`. For conservative cleanup if too much speech is being cut, use `-t="-30dB" -d 0.8`. For aggressive cleanup, use `-t="-15dB" -d 0.3`.

Can I preview what will be removed before processing?

Yes, use the `--dry-run` flag on remove_silence.py to print detected segments without creating an output file.

Why must I run silence removal before speed adjustment?

Silence detection relies on audio characteristics of the original recording. Speeding up first would alter the audio and make silence detection less accurate.

How long does processing take?

For videos under 30 minutes, typically a few minutes. Longer videos may take longer as each segment is processed individually.

Does processing reduce video quality?

Silence removal uses stream copy (no re-encoding) to preserve quality. Speed adjustment re-encodes with FFmpeg defaults but maintains standard quality.

Full instructions (SKILL.md)

Source of truth, from zc277584121/marketing-skills.

name: raw-video-processing description: Post-process raw screen recordings by removing silent segments and applying speed adjustments. Uses FFmpeg-based Python scripts to optimize video pacing automatically.

Skill: Raw Video Processing

Post-process raw screen recordings to improve pacing — remove silent segments, then speed up the result.

Prerequisite: FFmpeg and uv must be installed.

When to Use

The user has recorded a screencast and wants to clean it up before publishing. Typical issues in raw recordings:

Long pauses / dead air while thinking or waiting for loading
Keyboard typing sounds and other low-level background noise that should be treated as silence
Overall pacing feels slow and could benefit from a slight speed boost

Default Workflow

When the user provides a raw video file, run both scripts in sequence by default:

Step 1: Remove Silent Segments

uv run --python 3.12 /path/to/skills/raw-video-processing/scripts/remove_silence.py <input.mp4> -t="-20dB" -d 0.5

This detects and cuts out silent portions (including keyboard sounds), producing <input>_nosilence.mp4.

Always pass these parameters (tuned for screen recordings with keyboard noise):

-t="-20dB" — aggressive threshold that filters out keyboard typing and background noise (use = syntax to avoid argparse treating negative values as flags)
-d 0.5 — remove short silences too (0.5s minimum)
-p 0.2 — seconds of breathing room kept around speech boundaries (default, usually no need to pass)

The script prints a detailed summary: number of silent segments found, total silence removed, and all kept segments with timestamps. Review this output to confirm the result looks reasonable.

Step 2: Speed Up the Video

uv run --python 3.12 /path/to/skills/raw-video-processing/scripts/speed_video.py <input>_nosilence.mp4

This applies a speed multiplier to the silence-removed video, producing <input>_nosilence_1.2x.mp4.

Default parameters:

--speed 1.2 — 1.2x playback speed (a subtle boost that doesn't feel rushed)

Script Options

remove_silence.py

Flag	Default	Description
`-o`, `--output`	`<input>_nosilence.mp4`	Custom output path
`-t`, `--threshold`	`-30dB`	Silence threshold in dB (higher = more aggressive). Always use `-20dB` for screencasts — pass as `-t="-20dB"` to avoid argparse issues with negative values
`-d`, `--duration`	`0.8`	Minimum silence duration in seconds to remove. Use `0.5` for screencasts
`-p`, `--padding`	`0.2`	Padding kept around non-silent segments
`--dry-run`	off	Only print detected segments, don't export

speed_video.py

Flag	Default	Description
`-o`, `--output`	`<input>_<speed>x.mp4`	Custom output path
`-s`, `--speed`	`1.2`	Playback speed multiplier

Custom Scenarios

Only remove silence — run just Step 1.
Only speed up — run just Step 2 directly on the input file.
Conservative cleanup — use -t="-30dB" -d 0.8 if the default is cutting too much speech.
Extra aggressive cleanup — use -t="-15dB" -d 0.3 and --speed 1.5 for maximum compression.
Preview before committing — use --dry-run on remove_silence.py to see what would be cut without creating a file.
Custom output name — use -o on either script to control the output path.

Important Notes

Always run remove_silence before speed_video. Silence detection works on the original audio; speeding up first would alter the audio characteristics and make silence detection less accurate.
For long videos (>30 min), the silence removal step may take a few minutes as it processes each segment individually.
Both scripts preserve video quality — remove_silence uses stream copy (no re-encoding), while speed_video re-encodes with FFmpeg defaults.