Vibe Code a Scope Plugin

In the Build a Video Effects Plugin tutorial you learned how every Scope plugin is put together - the project structure, schema, pipeline class, and effect functions. Now you are going to build one without writing most of the code yourself. This tutorial walks you through two ways to vibe code a complete Scope plugin using Claude Code. You will describe what you want in plain English and let Claude handle the scaffolding, schemas, and GPU effect code. By the end you will have a working Film Noir plugin installed in Scope - high-contrast black and white with vignette and grain. Watch the full walkthrough:

Prerequisites

Claude Code installed and authenticated
Daydream Scope installed and running (desktop app or local install)
Basic familiarity with the terminal
Completed (or at least read through) the Build a Video Effects Plugin tutorial

You do not need to know Python or PyTorch. That is the whole point. If you want to understand the plugin system in more depth before diving in, check out the Developing Plugins guide and the Plugin Architecture reference.

Choose your approach

Both approaches produce the same result: a fully functional Scope plugin with live UI controls. Pick the one that fits your style.

Context7 MCP

Explore and build. Claude fetches the latest Scope docs on-the-fly via an MCP server and generates your plugin from the official patterns. Most flexible - you can go off-script and explore any part of the API.

Plugin Skill

Answer questions and ship. A purpose-built Claude Code skill walks you through a structured flow - concept, specs, file generation, testing. Faster and more predictable, with the full plugin reference baked in.

Build your plugin

Context7 MCP
Plugin Skill

This approach uses Context7, an MCP server that gives Claude access to up-to-date library documentation. You point Claude at the Scope docs, describe the effect you want, and it generates everything from scratch using the official plugin patterns.

Why this approach?

Context7 pulls the latest Scope documentation into Claude’s context on-the-fly. This means Claude always works from the current plugin API - even if it has changed since Claude’s training data was last updated. It is the most flexible approach because you are not limited to a predefined workflow. You can ask Claude to build any kind of plugin, explore the docs interactively, and iterate on the design in conversation.

Setup

Install the Context7 MCP server

The fastest way to add Context7 to Claude Code is with a single CLI command:

claude mcp add context7 -- npx -y @upstash/context7-mcp@latest

For higher rate limits, grab a free API key from context7.com/dashboard and pass it in:

claude mcp add context7 -- npx -y @upstash/context7-mcp@latest --api-key YOUR_API_KEY

Alternatively, you can add it manually to your Claude Code settings file (~/.claude.json or your project’s .claude/settings.json):

{
  "mcpServers": {
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp@latest"]
    }
  }
}

Restart Claude Code. You should see Context7 listed when Claude starts up.

Context7 is built by Upstash. If you run into ERR_MODULE_NOT_FOUND issues with npx, try using bunx instead: claude mcp add context7 -- bunx @upstash/context7-mcp@latest

Verify it works

Ask Claude to look up the Scope plugin docs:

Can you use Context7 to look up how Daydream Scope plugins work?

Claude will call resolve-library-id to find Scope, then query-docs to pull the plugin development documentation. If you see schema examples and pipeline code in the response, you are good to go.

Build the plugin

Start a new Claude Code session in an empty directory and walk through this conversation:

Ask Claude to research the plugin system

I want to build a Scope plugin that creates a film noir effect - classic black
and white, high contrast, dark vignette around the edges, and subtle film grain.
Can you look up how Scope plugins work and tell me what we need to build?

Claude will query Context7 for the Scope plugin documentation and come back with the full picture: project structure, pyproject.toml entry points, schema patterns, pipeline class interface, and effect function conventions. It is essentially reading the same docs you read in the previous tutorial, but doing it in real time.

Generate the entire plugin

Once Claude has the context, tell it to build:

Go ahead and build the complete plugin for me. Include all the files -
pyproject.toml, schema with UI controls for each effect parameter, pipeline
class, and the individual effect functions. Make the effects GPU-accelerated
with PyTorch.

Claude will generate the full project structure:

scope-film-noir/
├── pyproject.toml
└── src/
    └── scope_film_noir/
        ├── __init__.py
        ├── schema.py
        ├── pipeline.py
        └── effects/
            ├── __init__.py
            ├── desaturate.py
            ├── contrast.py
            ├── vignette.py
            └── grain.py

Each file will follow the exact patterns from the Scope documentation - Pydantic schema with ui_field_config for automatic UI controls, lazy imports in __init__.py, torch.Tensor operations for GPU-accelerated processing, and the Pipeline base class with prepare() and __call__() methods.

Review and iterate

This is the vibe coding part. Read through what Claude generated and ask for changes in plain English:

Can you make the grain more like actual film grain - luminance-dependent so
bright areas get less grain than shadows? Also bump the default contrast up
a bit, it should feel dramatic out of the box.

Claude will update the effect code and schema defaults. Keep iterating until the parameters feel right. You can also ask Claude to explain any part of the code:

How does the vignette effect work? What does the radial gradient do?

Since Claude has the Scope docs in context, its explanations will be grounded in how the framework actually works.

Install and test

Once you are happy with the code, install it in Scope:

Desktop app: Open Settings > Plugins, click Browse, and select the scope-film-noir folder
Server: Enter the path to the plugin directory and click Install

Select Film Noir from the pipeline selector, connect a camera, and you should see your feed transformed into a moody black-and-white scene with dramatic shadows and subtle grain.

You can ask Claude to query specific parts of the Scope docs mid-conversation. For example: “Can you look up how post-processors work in Scope? I want to chain this after a generative model.” Claude will fetch the relevant documentation and adapt your plugin accordingly.

This approach uses a purpose-built Claude Code skill that guides you through plugin creation with a structured, interactive flow. Instead of an open-ended conversation, the skill asks you specific questions about your plugin and then generates all the files in one go.

Why this approach?

The skill encodes the full Scope plugin reference and a complete working example (the VFX Pack from the previous tutorial) directly in its prompt. Claude does not need to look anything up - it already has everything it needs. This makes the process faster and more predictable. The structured question flow also ensures you do not forget anything (like setting up the pyproject.toml entry point or choosing between main pipeline and post-processor modes).If Context7 is the “explore and build” approach, the skill is the “answer questions and ship” approach.

Scope Plugin Skill source code

Browse the skill source to see how it works under the hood - includes the full Scope plugin reference and a complete working example baked into the prompt

Setup

Install the skill

Clone the skill repository and symlink it into your Claude Code skills directory:

git clone https://github.com/viborc/scope-plugin-skill.git
cd scope-plugin-skill
mkdir -p ~/.claude/skills
ln -s "$(pwd)" ~/.claude/skills/create-scope-plugin

For project-specific installation, copy the skill folder into your project’s .claude/skills/ directory instead of symlinking to the global location.

Verify it works

Open Claude Code and type:

/create-scope-plugin

Claude should respond by asking about your plugin concept. If it does, you are set.

Build the plugin

Invoke the skill with your idea

You can start with just the slash command, or give it a head start with a description:

/create-scope-plugin a film noir black and white effect with vignette and grain

The skill kicks off a four-phase workflow:

Concept Exploration - Claude discusses your idea, suggests effects and parameters, and confirms the creative direction
Specification Gathering - Structured questions about naming, pipeline settings, UI parameters, and technical details
File Generation - Claude creates every file: pyproject.toml, schema, pipeline, effects, and __init__.py
Testing Support - Installation instructions and validation steps

Answer the questions

The skill will walk you through questions like:

What should the plugin be called?
Which effects do you want? (desaturation, contrast, vignette, grain, etc.)
What parameters should be exposed as sliders? What are the defaults and ranges?
Should this be a main pipeline or a post-processor?
Any third-party dependencies beyond what Scope provides?

You can answer in as much or as little detail as you want. For anything you skip, the skill uses sensible defaults based on the Scope plugin patterns.

Review the generated files

Once the questions are done, Claude generates all the files at once. You will get the complete project structure with production-ready code following every Scope convention - entry points, lazy imports, Pydantic schemas with ui_field_config, GPU-accelerated tensor operations, the works.Review the output and ask for any changes:

Can you add a sepia tone option as a toggle? When enabled it should add a
slight warm tint instead of pure black and white.

Install and test

The skill provides installation instructions at the end. Follow them to install the plugin in Scope, select it from the pipeline dropdown, and start tweaking the sliders.

Comparing the two approaches

	Context7 MCP	Plugin Skill
Best for	Exploration, unusual plugins, learning	Quick builds, standard plugin patterns
Setup	Add MCP server to config	Clone repo + symlink
Workflow	Open-ended conversation	Structured question flow
Docs access	Fetches latest docs on-the-fly	Reference baked into the skill
Flexibility	Ask anything, go off-script	Follows a defined 4-phase flow
Speed	Slightly slower (doc fetching)	Faster (no external lookups)

You can also combine them. Start with the skill to get a working plugin quickly, then use Context7 in a follow-up session to explore advanced patterns like post-processors, custom model loading, or chaining multiple pipelines.

Tips for better results

Regardless of which approach you use, these tips will help you get better plugins out of the conversation:

Be specific about the visual effect. “Film noir” is good. “Film noir with crushed blacks, a radial vignette that is stronger in the corners, and grain that is heavier in the shadows” is better. The more detail you give, the closer the first generation will be to what you want.
Reference real-world examples. “Make the contrast curve look like a classic S-curve from Lightroom” gives Claude a concrete target. “Make it look like the movie Sin City” works too.
Iterate on the parameters. The schema defaults are just a starting point. Ask Claude to adjust them: “The vignette is too subtle at 0.3, make the default 0.6 and cap the max at 1.0.”
Ask for explanations. If you want to understand what the generated code is doing, just ask. Both approaches can explain the GPU operations, the tensor shapes, and how each parameter maps to a visual change.
Test incrementally. Install the plugin after the first generation, see how it looks, then come back to Claude with feedback. “The grain looks too uniform - can you make it more organic?” is much easier to act on once you have seen the output on screen.

What’s next

You now have two AI-assisted workflows for building Scope plugins without writing code from scratch. Here are some ideas for plugins you could vibe code next:

Cyberpunk neon glow - Edge detection with colorful bloom and scanlines
Watercolor painting - Bilateral filtering with color quantization for a painted look
Thermal camera - Map luminance to a heat color palette
Tilt-shift miniature - Selective blur to make real scenes look like tiny models
Glitch art - Random block displacement, color channel splitting, and data moshing

Each of these follows the same pattern. Describe the effect, let Claude generate the code, install it, and iterate. The plugin system handles the rest.

Build a Video Effects Plugin

The manual tutorial - understand every line of code in a Scope plugin

Scope Plugin Skill

Install the Claude Code skill for guided plugin scaffolding

Developing Plugins

Full reference for plugin project setup, schemas, and pipeline types

Plugin Architecture

Technical deep-dive into how the plugin system works under the hood

Getting Started

Tutorials

Guides

API Reference

Pipelines

Reference

Vibe Code a Scope Plugin

Vibe Code a Scope Plugin

Prerequisites

Choose your approach

Context7 MCP

Plugin Skill

Build your plugin

Why this approach?

Setup

Build the plugin

Why this approach?

Scope Plugin Skill source code

Setup

Build the plugin

Comparing the two approaches

Tips for better results

What’s next

Build a Video Effects Plugin

Scope Plugin Skill

Developing Plugins

Plugin Architecture

Getting Started

Tutorials

Guides

API Reference

Pipelines

Reference

​Vibe Code a Scope Plugin

​Prerequisites

​Choose your approach

Context7 MCP

Plugin Skill

​Build your plugin

​Why this approach?

​Setup

​Build the plugin

​Why this approach?

Scope Plugin Skill source code

​Setup

​Build the plugin

​Comparing the two approaches

​Tips for better results

​What’s next

Build a Video Effects Plugin

Scope Plugin Skill

Developing Plugins

Plugin Architecture

Vibe Code a Scope Plugin

Prerequisites

Choose your approach

Build your plugin

Why this approach?

Setup

Build the plugin

Why this approach?

Setup

Build the plugin

Comparing the two approaches

Tips for better results

What’s next