home / skills / athola / claude-night-market / vhs-recording

vhs-recording skill

This skill generates professional terminal recordings from VHS tape files, exporting animated GIFs to showcase command workflows.

npx playbooks add skill athola/claude-night-market --skill vhs-recording

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

Files (3)

SKILL.md

2.5 KB

---
name: vhs-recording
description: Generate terminal recordings using VHS tape files, produces GIF outputs.
category: media-generation
tags:
- vhs
- terminal
- recording
- gif
- demo
- tutorial
tools:
- Read
- Write
- Bash
complexity: medium
estimated_tokens: 600
progressive_loading: true
modules:
- tape-syntax
- execution
---

# VHS Recording Skill

Generate professional terminal recordings from VHS tape files.


## When To Use

- Recording terminal sessions with VHS tape scripts
- Creating terminal demo recordings for documentation

## When NOT To Use

- Browser-based workflows - use scry:browser-recording instead
- Non-terminal demos or GUI applications

## Overview

VHS converts declarative tape files into animated GIFs of terminal sessions. Tape files define commands, timing, and terminal appearance.

## Required TodoWrite Items

```
- Locate and validate tape file
- Check VHS installation status
- Execute VHS recording
- Verify output GIF creation
```

## Module Reference

- See `modules/tape-syntax.md` for VHS tape file directives
- See `modules/execution.md` for recording workflow details

## Workflow

### Phase 1: Validate Tape File

1. Confirm tape file exists at specified path
2. Read tape file contents
3. Verify required directives:
   - `Output` directive specifies GIF destination
   - At least one action command (Type, Enter, etc.)

### Phase 2: Check VHS Installation

```bash
which vhs && vhs --version
```

If not installed:
```bash
# Linux/WSL
go install github.com/charmbracelet/vhs@latest

# macOS
brew install charmbracelet/tap/vhs

# Also requires ttyd and ffmpeg
```

### Phase 3: Execute Recording

```bash
vhs <tape-file.tape>
```

VHS will:
1. Parse tape file directives
2. Launch virtual terminal (ttyd)
3. Execute commands with timing
4. Capture frames
5. Encode to GIF using ffmpeg

### Phase 4: Verify Output

1. Check GIF file exists at Output path
2. Verify file size is non-zero
3. Report success with output location

## Exit Criteria

- GIF file created at specified Output path
- File size indicates successful recording (typically >50KB)
- No error messages from VHS execution
## Troubleshooting

### Common Issues

If `vhs` is not found, verify that your Go bin directory is in your `PATH` (typically `~/go/bin`). If the recording fails to start, ensure `ttyd` and `ffmpeg` are installed, as VHS depends on them for terminal emulation and video encoding. For "permission denied" errors when writing the GIF, check that the output directory exists and is writable.

Overview

This skill generates professional terminal recordings by converting VHS tape files into animated GIFs. It automates validation, recording, and verification steps so you get reproducible, high-quality terminal demos for documentation and tutorials. The workflow focuses on tape syntax, VHS availability, and reliable output checks.

How this skill works

The skill inspects a VHS tape file to confirm required directives (Output path, action commands, timings) and checks that vhs, ttyd, and ffmpeg are installed. It runs the vhs command to replay the tape, captures frames, and encodes the recording to a GIF. Finally, it verifies the GIF exists and has a reasonable file size to confirm success.

When to use it

Create short terminal demo GIFs for docs or READMEs
Automate generation of terminal walkthroughs from declarative tape scripts
Validate that a tape file renders correctly before publishing a tutorial
Produce reproducible command-line examples for bug reports or onboarding materials

Best practices

Keep tape files small and focused to limit GIF size and duration
Specify the Output directive with a full path and writable directory
Verify vhs, ttyd, and ffmpeg are installed before running recordings
Run recordings in a CI step or sandboxed environment to catch errors early
Aim for simple timing and clear commands to improve readability in GIFs

Example use cases

Documenting an install or setup flow with step-by-step terminal actions
Creating a visual bug report that shows command output over time
Generating demo GIFs for a library’s quickstart section
Converting recorded terminal sessions into shareable assets for social or training materials

FAQ

What if vhs is not installed?

Install vhs via Go (go install github.com/charmbracelet/vhs@latest) or Homebrew on macOS, and ensure your Go bin directory is in PATH.

Why did the GIF not produce or is zero bytes?

Check that vhs ran without errors and that ttyd and ffmpeg are available. Also confirm the Output directory exists and is writable.

How large should a successful GIF be?

Successful recordings are typically larger than ~50KB depending on duration and frame rate; use that as a quick sanity check.