Scope

Vibe code with Scope: introducing the Scope Developer Skill for Claude Code

We're launching the Scope Developer Skill for Claude Code. It gives your coding agent verified knowledge of Scope's REST API, WebRTC streaming, node system, and pipeline architecture so you can build custom nodes, integrations, and creative tools with working code on the first try.

• 6 min read
Vibe code with Scope: introducing the Scope Developer Skill for Claude Code

Scope is open source, and we're seeing more and more people build around it.

Some are writing custom nodes that bring new visual effects into their generation pipeline. Others are connecting Scope to TouchDesigner and Resolume for interactive installations, or scripting their lighting desks to drive AI video generation during live shows. A few have built full applications that stream Scope's real-time AI video into their own web experiences, Unity projects, or interactive kiosks using WebRTC.

A lot of this development happens with AI coding agents now, and that's where things get challenging. Coding agents can still sometimes hallucinate. They guess at endpoint names that look plausible but don't exist. They generate import paths that fail silently. When you're building against a codebase that moves as fast as Scope does, your agent's training data is almost always behind.

We want to change that and help out.

Today, we're launching the Scope Developer Skill, a purpose-built reference for Claude Code (and likely can be used with Codex and other agentic platforms supporting skills) that gives your coding agent deep knowledge of the Scope platform. It's one of our first steps toward making AI-assisted development around Scope a first-class experience, and it builds on our LLM-friendly docs we introduced a while ago. More on both in this post.

Reasons for building this

A lot of people use Scope through the graph editor and the visual controls, and that's great. But we're also seeing people who want to go further: writing their own nodes, building custom applications, integrating Scope into larger production setups for live shows and installations. Those people are, in most cases, working with the API, the node system, the WebRTC signaling layer, and their coding agents need to know how all of that works.

Several of our previous cohort participants have already been building custom nodes using our vibe coding tutorial.

The skill takes that further. Instead of spending time figuring out which import path works or what the WebRTC response format looks like, your agent already knows. You describe what you want to build, and the code it produces actually runs.

What the Scope Developer Skill is

In simplest terms, Claude Code skills are markdown files that give Claude domain-specific expertise. That's it.

When you install a skill, Claude automatically loads it whenever the conversation topic matches. You don't need to remember to paste documentation into context or point your agent at the right files. The skill loads on its own, and it's structured for code generation rather than human reading: working code examples, exact field names, verified import paths, and cross-cutting patterns like the full WebRTC flow that spans multiple endpoints and models. Copying a docs page gives your agent information about one topic. The skill gives it a connected understanding of how the pieces fit together.

The Scope Developer Skill covers a wide range of the Scope platform:

  • REST API endpoints (67 at the time of writing) with HTTP methods, paths, and request/response formats
  • WebRTC signaling flow with working JavaScript examples for text-to-video and video-to-video connections
  • Node and pipeline development with a working pyproject.toml, the build system, the pipeline base class, config schemas, and the plugin registration pattern
  • MCP tools (39 currently) for headless pipeline control
  • Runtime parameter reference with field names, types, ranges, and defaults for real-time control
  • Graph execution schema for multi-pipeline workflows
  • OSC, MIDI, and DMX endpoint formats for show control integration
  • Source code map pointing to backend and frontend files so Claude knows where to look

We built this by cross-referencing against the actual Scope source code, testing import paths, verifying endpoint methods, and checking field names against the codebase.

As Scope itself, the skill is open source on GitHub.

Building with Scope and our dev skill

Scenarios are almost endless, but some of the use cases we already observed are listed here. We hope to see even more and beyond these!

Custom visual effects for your set. You want a chromatic aberration effect or a CRT scanline look for your VJ performance. Describe the effect, and Claude generates a working plugin you can install and tweak in real time. The skill handles the boilerplate: the build configuration, the plugin registration, the input/output contracts. You focus on the creative part.

New pipeline support. Maybe there's a new audio or video diffusion model or a specialized depth estimation architecture you want to bring into Scope that isn't supported out of the box. The skill knows the pipeline interface, the config schema, how model artifacts and downloads work, and how to register everything through the plugin system.

Your agent can scaffold the full pipeline node with the right structure, and you focus on the model-specific inference logic. This is the kind of task where coding agents typically fail without proper context, and it's where the skill helps the most.

Your own applications powered by Scope. Bring real-time AI video into your Unity project, your web experience, your installation kiosk, or your own custom interface. The skill covers the WebRTC signaling details that agents typically get wrong: the field name casing, the ICE candidate format, the data channel protocol. So, instead of reverse-engineering the connection flow from source code, you describe what you want and get working integration code.

Show control from your existing rig. Your TouchOSC surface talks to Scope over OSC. Your lighting console drives AI generation over DMX. Your MIDI controller maps to generation parameters. The skill knows these protocol formats and endpoint contracts, so the code your agent writes actually connects to Scope instead of targeting an API surface that doesn't exist.

Custom solutions on top of Scope's engine. Build your own automation: load pipelines, update prompts with smooth transitions, capture frames, read performance metrics. If you want to build tools that treat Scope as an inference backend rather than a standalone application, the session API is how you do it, and the skill covers it.

Installing the skill in Claude Code

Installation takes about 30 seconds. You have two options depending on whether you want the skill available across all your projects or just one.

For all your projects (personal installation):

git clone https://github.com/daydreamlive/scope-dev-skill.git
cp -r scope-dev-skill/skills/scope-dev ~/.claude/skills/scope-dev

If you want it to stay up to date automatically when we push updates, use a symlink instead:

git clone https://github.com/daydreamlive/scope-dev-skill.git ~/scope-dev-skill
ln -s ~/scope-dev-skill/skills/scope-dev ~/.claude/skills/scope-dev

Then whenever we update the skill, a git pull in that directory is all you need.

For a single project:

mkdir -p .claude/skills
git clone https://github.com/daydreamlive/scope-dev-skill.git /tmp/scope-dev-skill
cp -r /tmp/scope-dev-skill/skills/scope-dev .claude/skills/scope-dev

Once installed, Claude Code picks it up automatically. You can verify by asking something like "How do I load a pipeline via the Scope API?" and checking that Claude references specific endpoints with correct request formats rather than guessing.

Getting started and using MCP for an even better experience

  1. Install the Scope Developer Skill using the instructions above
  2. For the latest docs on the fly, you can also add Context7, an MCP server from Upstash that lets your agent query Scope's documentation in real time. The skill gives your agent structure and patterns, MCP gives it freshness. They work well together, but the skill is where we'd start. Install it with: claude mcp add context7 -- npx -y @upstash/context7-mcp@latest
  3. Start building

If you want a guided walkthrough to see the skill in action, we have two tutorials that pair well with it:

We are aware that this is a V1 (if we are being generous about versioning), and we want it to get better with input from the people who actually use it.

If you build something with the skill, share it in the Discord. If something's wrong or missing, open an issue on GitHub.

Happy building, we are excited to see what you (vibe) code with Scope!