Skill

Pass

Audit score 90

video-to-gif

zc277584121/marketing-skills

Convert videos to multiple GIF variants with different quality/size tradeoffs for visual comparison.

What is video-to-gif?

This skill generates a set of GIF variants from a video file, each with different parameters (FPS, resolution, color depth) so you can visually compare and pick the best balance between file size and quality. Use it when you need a GIF but aren't sure what settings will work best.

Generate up to 18 GIF variants from a single video with different FPS, width, and color options
Create a sorted comparison table showing file size, FPS, width, and color count for each variant
Support four preset configurations (full, minimal, lossy, quality) for different use cases
Trim video segments using start/end timestamps before conversion
Apply optional lossy compression via gifsicle to reduce file sizes by 30-70%
Use FFmpeg's two-pass palette generation for optimal GIF quality

How to install video-to-gif

npx skills add https://github.com/zc277584121/marketing-skills --skill video-to-gif

Prerequisites

FFmpeg must be installed
uv (Python package manager) must be installed
gifsicle is optional but required for lossy compression variants

Claude Code

Cursor

Windsurf

Cline

How to use video-to-gif

1.Run the script with your video file: uv run --python 3.12 /path/to/video_to_gif.py input.mp4
2.Choose a preset if needed (full, minimal, lossy, or quality) or use default full preset
3.Optionally trim the video with --start and --end flags to specify a segment in seconds
4.Review the generated GIFs in the output directory (default: <input>_gifs/)
5.Compare the variants using the sorted table showing file size, FPS, width, and colors
6.Select the GIF that best balances quality and file size for your use case

Use cases

Good for

Create screen recording GIFs for documentation or tutorials with optimal file size
Generate multiple quality variants of a short video clip to find the best visual/size balance
Quickly compare how different resolutions and frame rates affect a GIF's appearance and file size
Produce small, shareable GIFs from longer videos by trimming and testing parameters
Create lossy-compressed GIFs for web embedding where file size is critical

Who it's for

Content creators making GIFs for social media or documentation
Developers optimizing animated content for web performance
Technical writers creating visual guides with screen recordings
Anyone needing to convert video clips to GIF format with quality control

video-to-gif FAQ

What's the difference between the presets?

full (~18 variants) is for general exploration, minimal (~4 variants) for quick comparison, lossy (~12 variants) for smallest files with gifsicle compression, and quality (~12 variants) for best visuals with higher resolution and dithering.

Can I customize the parameters instead of using presets?

Yes. Use flags like --fps, --width, --colors, and --lossy to override preset values. For example: --fps 10 15 --width 480 800 --colors 256.

What if my video is very long?

Consider trimming it first with --start and --end flags to specify a segment in seconds. GIFs over 10 seconds can become very large.

How much can lossy compression reduce file size?

Gifsicle lossy compression can reduce file size by 30-70% with minimal visual impact, typically at compression levels 30-60.

What's the recommended sweet spot for most GIFs?

For screen recordings, around 640px width, 15 FPS, and 256 colors usually provides a good balance between clarity and file size.

Full instructions (SKILL.md)

Source of truth, from zc277584121/marketing-skills.

name: video-to-gif description: Convert a video to multiple GIF variants with different quality/size tradeoffs. Generates a comparison set so the user can visually pick the best result.

Skill: Video to GIF

Convert a video file into multiple GIF variants with different parameters, so the user can visually compare and pick the best one.

Prerequisite: FFmpeg and uv must be installed. gifsicle is optional (enables lossy compression variants).

When to Use

The user wants to create a GIF from a video clip but isn't sure about the right parameters. GIF quality involves tradeoffs between:

File size — smaller is better for sharing/embedding
Color accuracy — fewer colors = smaller but may cause banding
Smoothness — higher FPS = smoother but larger
Resolution — wider = sharper detail but larger

Rather than guessing, this skill generates multiple variants and lets the user decide.

Default Workflow

When the user provides a video file:

uv run --python 3.12 /path/to/skills/video-to-gif/scripts/video_to_gif.py <input.mp4>

This generates GIFs in <input>_gifs/ directory with the full preset (18 variants):

3 FPS options: 10, 15, 20
3 widths: 480px, 640px, 800px
2 color counts: 128, 256

Output includes a sorted comparison table showing file size, FPS, width, and colors for each variant.

Presets

Preset	Variants	Best For
`full`	~18	General use — broad exploration of the parameter space
`minimal`	~4	Quick comparison — just a few key tradeoff points
`lossy`	~12	Smallest files — includes gifsicle lossy compression levels
`quality`	~12	Best visuals — higher res, includes bayer dithering

# Quick comparison with fewer variants
uv run --python 3.12 .../video_to_gif.py input.mp4 --presets minimal

# Include lossy compression (requires gifsicle)
uv run --python 3.12 .../video_to_gif.py input.mp4 --presets lossy

# Higher quality focus
uv run --python 3.12 .../video_to_gif.py input.mp4 --presets quality

Common Options

Flag	Default	Description
`-o`, `--output-dir`	`<input>_gifs/`	Output directory for all GIF variants
`--start`	none	Start time in seconds (trim source)
`--end`	none	End time in seconds (trim source)
`--presets`	`full`	Preset config: full, minimal, lossy, quality
`--fps`	preset	Override FPS values (e.g., `--fps 10 15 20`)
`--width`	preset	Override width values (e.g., `--width 480 640`)
`--colors`	preset	Override color counts (e.g., `--colors 128 256`)
`--lossy`	preset	Gifsicle lossy levels (e.g., `--lossy 0 30 80`)

Examples

# Convert first 10 seconds of a video
uv run --python 3.12 .../video_to_gif.py demo.mp4 --end 10

# Extract a specific segment
uv run --python 3.12 .../video_to_gif.py demo.mp4 --start 5 --end 15

# Custom parameter sweep
uv run --python 3.12 .../video_to_gif.py demo.mp4 --fps 12 15 --width 480 800 --colors 256

# Lossy compression comparison (needs gifsicle)
uv run --python 3.12 .../video_to_gif.py demo.mp4 --lossy 0 30 60 100

How to Choose

After running, open the output directory and compare:

Start with the smallest files — check if quality is acceptable
Look for color banding — if visible, try 256 colors or bayer dithering (quality preset)
Check smoothness — if too choppy, go up to 15 or 20 FPS
Check clarity — if text is unreadable, go up to 640 or 800px width

The sweet spot for most screen recordings is usually around 640px, 15fps, 256 colors.

Important Notes

Widths larger than the source video resolution are automatically skipped.
The script uses FFmpeg's two-pass palette generation for optimal GIF quality (much better than single-pass).
Lossy compression via gifsicle can reduce file size by 30-70% with minimal visual impact at level 30-60.
For very long clips, consider trimming with --start/--end first — GIFs over 10 seconds can get very large.