> your AI agent picks dependencies from memory; give it dated facts — try starlog.dev ↗ vet your agent's deps ↗ vibe-coding is fine. vibe-importing isn’t. — try starlog.dev ↗ vibe-importing isn’t fine ↗ your agent has never seen your private packages — try starlog.dev ↗ facts for private packages ↗ a linter for the dependencies your AI agent picks — try starlog.dev ↗ a linter for agent deps ↗ whois is redacted, cdns mask the rest — get the real operator — try whoisgeni.us ↗ who really runs that domain ↗ domain attribution that shows its work — full evidence chain — try whoisgeni.us ↗ domain intel w/ evidence ↗

← Back to Articles

Brag: How Agent Skills Turn LLM Coding Assistants Into a Distribution Platform

[ View on GitHub ]

Brag: How Agent Skills Turn LLM Coding Assistants Into a Distribution Platform

Hook

What if your next CLI tool was just a markdown file that AI agents read and execute? No npm install, no pip, no binaries—just instructions that work across Claude, Codex, and future agents you've never heard of.

Context

Every developer has experienced this: you build something you're proud of, you want to share it, but creating a launch video means hiring an editor or spending hours in Premiere Pro. The gap between "I shipped code" and "I have something shareable on Twitter" is measured in days or dollars.

Brag emerged from the latent-spaces team as a solution to this launch friction, but its real innovation isn't the video generation—it's the delivery mechanism. Instead of building a traditional CLI tool that users install via package managers, brag distributes itself as an agent skill: a markdown file (SKILL.md) that LLM coding assistants like Claude Code read and execute directly. The agent interprets the instructions, analyzes your project directory, writes a creative brief, shells out to rendering tools, and orchestrates FFmpeg for final assembly. You don't install brag—your agent just knows how to do it. This architectural choice transforms LLM agents from coding assistants into a cross-platform distribution layer for developer tooling.

Technical Insight

Execution Models

Discovery Layer

invokes

agent checks

resolves to

reads & interprets

shells out

extracts features

composition spec

direct prompts

renders frames

generates video

encodes

cross-agent portability

User Command: brag

LLM Agent Runtime

SKILL.md Specification

Project Scanner

Creative Brief Generator

Hyperframes CLI

Opus 5.5 Native Video

FFmpeg Assembler

launch-video.mp4

Filesystem Conventions

Symlinked Skill Paths

plugin.json

System architecture — auto-generated

The core mechanism is deceptively simple: a SKILL.md file contains structured instructions that agents parse and execute in-context. Here's the actual skill definition structure:

# Brag: Launch Video Generator

## Capability
Analyze a project directory and generate a shareable launch video showcasing the product.

## Usage
`brag [--tone 'style description'] [--duration seconds]`

## Process
1. Scan project files (README, package.json, key source files)
2. Extract: product name, core features, tech stack, value proposition
3. Write creative brief for video narrative
4. Generate Hyperframes composition file
5. Execute: hyperframes render composition.json
6. Shell out to FFmpeg for final encoding
7. Output: launch-video.mp4

This isn't pseudocode—it's the actual specification the agent interprets. When you type brag in Claude Code, the agent reads this markdown, understands the workflow, and executes each step by writing and running code in your environment. The agent becomes the runtime.

Discovery uses filesystem conventions rather than package registries. The repository structure includes symlinks at multiple paths:

.claude/skills/brag -> ../../skill/
.agents/skills/brag -> ../../skill/
.opencode/skills/brag -> ../../skill/
skills/brag -> ../skill/

When an agent initializes, it checks these conventional locations. One canonical skill/ directory exposed via symlinks means git pull updates work across every agent without platform-specific builds. On Windows where symlinks require privileges, users manually copy—but the degraded experience reveals the elegance of the Unix approach.

The /brag vs /brag-slim split demonstrates pragmatic architecture hedging. The full version depends on Hyperframes CLI (another agent-native video tool) and bundles CC BY 4.0 licensed music and sound effects directly in the repository. This ensures deterministic output and offline execution:

# Pseudocode for /brag workflow
brief = agent.analyze_project(directory)
composition = agent.write_hyperframes_brief(brief, tone)
music_path = "./skill/assets/music/upbeat-tech.mp3"
composition['audio']['background'] = music_path
os.system(f"hyperframes render {composition}")
os.system(f"ffmpeg -i output.mp4 -i {music_path} -c copy final.mp4")

The /brag-slim variant eliminates external dependencies entirely, relying on Claude Opus 5.5's native video generation capabilities. Same creative logic for analyzing projects and writing narratives, but the rendering step becomes a direct model API call rather than shelling out to Hyperframes. The tradeoff: zero-dependency execution versus output consistency. Hyperframes provides templated transitions and predictable pacing; native generation offers more creative variance but less reliability across runs.

The tone parameter reveals sophisticated prompt engineering. Instead of exposing knobs for transitions, music selection, or pacing, users steer via cultural references:

brag --tone "fake Series A launch from 2016"
brag --tone "indie hacker building in public"
brag --tone "academic research paper made exciting"

The agent interprets these descriptions using its training data understanding of visual and narrative conventions. It's prompt engineering as UI—assuming the model already understands the semiotics of different launch video styles rather than parameterizing every creative decision.

Bundling assets directly in the repository sidesteps the typical "where do I get stock music" problem. The skill includes pre-cleared audio files, so offline execution works without API calls to stock media libraries or worrying about licensing. This is distribution thinking: optimize for works-out-of-the-box over flexibility.

The skills-calling-skills pattern emerges naturally: /brag delegates video rendering to Hyperframes, which itself is an agent-orchestrated video tool. Rather than implementing video generation in-process, brag agents orchestrate specialized agents. It's microservices architecture but for LLM workflows—each skill does one thing and composes via shell execution.

Gotcha

The Hyperframes dependency in /brag creates a single point of failure. If Hyperframes changes their API, deprecates features, or shuts down, the skill breaks. The /brag-slim variant mitigates this by depending only on model capabilities, but you're now trusting that future Claude versions maintain video generation quality. Neither approach has guaranteed long-term stability.

Output quality is fundamentally limited by the agent's project analysis. Brag scans README files and package.json, but it can't see your actual UI, understand visual design nuances, or capture the feeling of using your product. It generates narrative vibes about your project, not a demonstration of functionality. For many products, this abstraction loses what makes them compelling. There's also no handling of sensitive information—if your project directory contains API keys, internal URLs, or unannounced features, the agent might include them in the generated video copy. The Windows symlink requirement (Developer Mode or Admin privileges) is a non-starter in corporate environments where developers lack admin access. The manual copy workaround works but defeats the auto-update promise—you're back to manually syncing skill updates.

Verdict

Use if: you're building agent-native tooling and want to study cross-platform skill distribution patterns, you need quick demo videos for side projects where 'good enough' beats 'professional,' or you're researching how markdown-as-executable-spec can standardize LLM tool ecosystems across Claude, Codex, and future platforms. The real value is the distribution architecture, not the videos. Skip if: you're launching anything commercial where brand perception matters—the quality ceiling is automated competence, not compelling storytelling. Skip if you need deterministic, testable output—model updates can silently change video quality and narrative framing with no regression testing. Skip if you work in regulated environments where tooling requires security review—agent-executed markdown from GitHub repos won't pass compliance. For actual product launches, hire a video editor. For studying the future of developer tool distribution, brag is required reading.