[Feature]: Add Skill Integration

[David-rn]

Search before asking

• I have searched the issues and discussions and found no similar feature request.

Feature Description

What

Hi team!

Since I've been using daily supervision and inference libraries, I've created a set of skills for both Supervision and Inference. You can find them here. They still need a bit of refinement but so far so good.

Why

I believe there could be real value in having official skills maintained directly within each library's repository. This would:

• Keep the skills in sync with the latest API changes and releases (since each skill could have the version number of the library)
• Give users a reliable, first-party resource for AI-assisted development

How

One idea would be to add a CLI command (e.g. supervision skills install or a simple entry point) that copies the relevant skill directly into their current project (.claude/skills/). This would make it seamless to integrate AI assistance into any workflow built on top of supervision. That way, the library version installed in the user's environment will match the skill installed, so any change would be tracked.

I'd be happy to contribute to this effort or discuss the approach further. Looking forward to hearing your thoughts!

Example Usage

No response

Are you willing to submit a PR?

• Yes I'd like to help by submitting a PR!

[Borda]

Hey @David-rn, thanks so much for opening this issue and sharing your custom skills! This is incredibly serendipitous timing. We actually have a beta version of a very similar concept currently in internal testing, so your proposal validates exactly what we’ve been working towards.

Since you are already using this daily and we are actively shaping the final implementation, we would love to learn more about your expectations to ensure what we build fully covers your use cases and handles the most common patterns you encounter.

If you have a moment, we'd love your thoughts on a few things:

1. Common Patterns & Daily Workflow
   • What are the most common coding patterns or supervision pipelines you find yourself asking the AI to build?
   • Are you primarily generating standard boilerplate, setting up end-to-end inference pipelines, or debugging complex logic (like zone counting or tracking)?
2. Tooling & Environment
   What IDE or AI tools are you building this around? Are you strictly using Claude Desktop, or are you adapting this for tools like Cursor (.cursorrules), GitHub Copilot, or other agents?
3. Scope & Granularity
   In your experience, does the AI perform better with one overarching prompt for the entire library, or do you find it needs modular skills broken down by feature (e.g., one for supervision-tracking, another for supervision-annotators)?
4. The "Ideal" Skill Content
   To consistently hit those common patterns, what specific components make up your best-performing skills right now? Do you find that feeding the AI raw API documentation works best, or does it rely heavily on specific code snippets and end-to-end examples?

We are really excited to get this right. I'd love to hear your thoughts, and if you're open to it, we'd love to collaborate on the PR once we finalize the approach!

[David-rn]

Thanks for the response. I'm really glad to hear you're already working on something similar! Happy to share what I've learned so far:

1. Common Patterns & Daily Workflow

My most frequent use cases are mode inference + annotation and end-to-end inference pipelines. For the latter, one of the most critical decisions the AI needs to get right is when to use InferencePipeline (from inference library) vs sv.process_video. That is because the former one fits better for more complex pipelines (streams, threading, etc) and sometimes it gets confused about when to use one vs the other (I'm still trying to figure out).

2. Tooling & Environment

I'm primarily using Claude Code and OpenCode .

3. Scope & Granularity

This is where I've iterated the most. In my experience, a modular approach worked significantly better than one monolithic prompt. The structure that's given me the best results is:

• A top-level SKILL.md that contains high-level, common patterns and references to feature-specific sub-skills
• Dedicated sub-skills for each feature area (e.g., annotators, tracking, tools, utils)

This also helps with token efficiency since the AI only loads the context it actually needs for a given task instead of ingesting the entire library surface. One important caveat: the description that triggers each sub-skill needs to be very precise. If it's too vague, the right skill won't fire. Getting these descriptions has been challenging, since there are many methods and utilities in each module.

4. The "Ideal" Skill Content

I've found that function signatures with their docstrings work really well. Without them, the AI tends to hallucinate parameter names. For example, it kept generating progress instead of the correct show_progress parameter in sv.process_video. Including the actual API signatures solved that.

The downside is that right now I had to manually write those signatures into the skills, which is essentially duplicating what's already in the source code. One approach I haven't tested yet but find promising: having the skill point to the actual source file and line number where a function is defined (hopefully, similar to what it is done with mkdocks), rather than copying the signature. Since most coding agents have read permissions on the codebase, the skill would reference the source of truth directly and stay in sync with the code automatically.

Looking forward to seeing how you're approaching it on your end!