CLAD Agents and Skills
Reference for the agents and skills in the CLAD plugin, grouped by development stage, with the tools each one needs and tips for using them.
- Snapchat: fully supported
- SPECS: fully supported
- Camera Kit Web: not supported
- Camera Kit Mobile: not supported
- SnapchatFully supported
- SPECSFully supported
- Camera Kit WebNot supported — CLAD's skills cover Snapchat and SPECS Lenses
- Camera Kit MobileNot supported — CLAD's skills cover Snapchat and SPECS Lenses
The CLAD plugin (ls-clad) gives an AI assistant skills, which teach it one part of Lens Studio,
and agents, which take on one job in their own context. Together they let the assistant build in a
closed-loop, agentic way. This page lists the key ones. To install the plugin, see
What Is CLAD.
The assistant usually picks the right skills and agents on its own as it works; you don't have to
name them. Name a skill (/build-mesh) or an agent (script-author) in a prompt when you want more
control over a step.
Ways to drive CLAD
CLAD can build a whole Lens on its own, or help you with specific parts of one.
One prompt, end to end, with the SPECS Experience Builder. Ask the specs-experience-builder
agent for a whole interactive SPECS experience. It plans it, generates meshes, sound, music, UI,
and icons, writes the scripts, and assembles the scene. Then it checks the result in the live
Preview and offers next steps: LEAF tests, optimization, publishing, and more.
Build me an interactive solar system for SPECS
One step at a time. On an existing project, or when you only want parts of CLAD, call each skill or agent yourself. For a solar-system Lens, you might use:
| Step | Skill or agent |
|---|---|
| Lay out the sun and the planets orbiting it | /scene-construction |
| Make the planets orbit the sun | /lens-api |
| Generate custom models (a rocket, an asteroid) to fly around | /build-mesh |
| Make the sun glow realistically | /shader-graph |
| Show a panel with a planet's details when it's tapped | /icon-selector, /font-selector, then /specs-build-ui |
| Add an ambient soundtrack and tap sounds | /build-music and /build-sfx |
| After each change, check that tapping a planet shows its panel (read-only, while you build) | /verify-preview |
| When it works, lock it in with a re-runnable LEAF test, so later changes can't silently break it | live-lens-tester (agent) |
In this workflow you drive the progress and hand tasks to CLAD. The SPECS Experience Builder goes into much more detail on its own, to get a working Lens from one prompt.
/lens-studio-field-notes holds tips that help an AI agent succeed with Lens Studio projects.
/lens-studio-router loads it automatically, so you rarely call it yourself.
Specialist agents
Besides the SPECS Experience Builder, CLAD has specialists you can call while you build. An agent works in its own context, so the main conversation stays small. These are the ones to know:
| Agent | What it does |
|---|---|
specs-experience-builder | Plans and builds a complete SPECS Lens from one prompt |
snapchat-experience-builder | Plans and builds a complete Snapchat Lens or game from one prompt |
script-author | Writes the TypeScript behavior scripts and compile-checks them; doesn't change the scene layout |
editor-api-specialist | Makes heavy, multi-step project changes through the Editor API, keeping the noise out of the main conversation |
specs-project-migrator | Moves an older Spectacles (2024) project to SPECS 27, separating the automatic fixes from the manual follow-ups |
live-lens-tester | Writes and runs LEAF test scenarios in the Preview and on a connected device |
The other specialists start automatically, as part of a step in the loop; they're named with that step in the sections that follow.
Setup skills
| Skill | What it does |
|---|---|
/lens-studio-router | The entry point for any Lens Studio task: checks that Lens Studio and the MCP server are ready, picks the platform, and routes to the right workflow |
/specs-project-init | Checks a SPECS project: camera, world tracking, required packages, and Preview device |
/ensure-package-installed | Checks that a package is installed, and installs it and its dependencies from the Asset Library if it's missing |
/reset-preview-environment | Gives you a clean Preview before you generate a new scene: moves the Preview camera back to its start, turns off objects left from a previous build, and records where the log starts so you read only new output |
/reset-preview-environment is safe to run any number of times. It doesn't delete scripts or
assets, and it leaves the lighting, skybox, and tracking in place.
A few skills run external tools (Node.js, ffmpeg, Blender), noted with each skill. /specs-project-init
checks for the optional ones and warns you when a workflow needs one that's missing.
Design and prototype skills
| Skill | What it does | Needs |
|---|---|---|
/scene-construction | The hub for adding and arranging objects: read the scene, pick presets, apply, save | |
/camera-and-rendering | Sets up cameras and on-screen 2D content, and finds invisible objects | |
/materials | Sets colors, shininess, and textures with presets: the default for "make it look like X" | |
/shader-graph | Builds custom surfaces no preset can make (glowing, animated, procedural) | |
/vfx-graph | Builds particle effects: smoke, sparks, trails, magic | |
/physics | Adds gravity, collisions, joints, and objects you can drag or throw, including collisions with faces, hands, and the world | |
/build-mesh | Generates a finished 3D model from a text description, optionally animated, with the backend that suits it (see the next table) | Node.js |
/mesh-builder-scripting | Builds or reshapes geometry from code at runtime, instead of the ready-made models of /build-mesh | |
/build-image | Generates a 2D image from a prompt | |
/lens-package-toolkit | Installs, unpacks, inspects, and authors Lens Studio packages | |
/update-lens-packages | Updates Interaction Kit, UI Kit, and Sync Kit to their latest versions, or to a version you name | |
/lens-api | Writes TypeScript that runs inside a Lens: events, taps, screen-to-world conversion, objects created at runtime | |
/editor-api | Writes code that automates the Lens Studio editor for bulk changes. It's a different runtime from the Lens; never mix the two | |
/lens-studio-field-notes | The shared rules the router loads automatically | |
/specs-build-ui | Builds world-space UI for SPECS: heads-up displays, menus, sliders, switches, text inputs | |
/font-selector | Finds a font by mood or name and applies it to text | |
/icon-selector | Finds and imports the right Material icon for a button or panel | |
/build-music | Composes original music: melodies, beats, jingles. Works offline and is license-free | Node.js; ffmpeg to check the track isn't silent (without it, the track still renders) |
/build-sfx | Generates sound effects: clicks, impacts, whooshes, ambient textures, 8-bit | Node.js |
/specs-audio | How sound plays on SPECS: power-saving or low-latency playback, Snap recording, microphone input |
/build-mesh picks one of four backends for each model, by what the model needs:
| Backend | Best for | Trade-offs | Needs |
|---|---|---|---|
| SPECS text-to-3D (the default for static props) | The best textures, in any style; also image to 3D | Static only. Runs as a job you create, poll, and download, minutes per model | Lens Studio sign-in (no API key) |
| FAST3D | Faster static props, when you ask for fast or draft models | Lower quality than SPECS text-to-3D; no local tools needed | Lens Studio sign-in |
| MeshBuilder (code-authored) | Anything that must move, articulate, or be generated from parameters: lathe, extrude, tube, skinned meshes | Hands off to /mesh-builder-scripting and produces TypeScript, not a GLB. No waiting, but less realistic (no textures) | |
| Blender voxel | A blocky voxel look, and the only backend that makes a rigged GLB (with a skeleton) | Blender |
/specs-build-ui uses icons and fonts; it doesn't make them. Run /icon-selector and
/font-selector first, then /specs-build-ui reads the icons on disk and the font you pass it. The
builder enforces this order.
/specs-build-ui and /specs-interaction-recipes cover different layers. Panels, buttons, and
dialogs (anything flat that people read or tap) belong to /specs-build-ui: a UI Kit button already
handles its own tap. Hand gestures on 3D objects (grab a planet, throw a ball) belong to
/specs-interaction-recipes. The two connect through events: the UI module sends events that your
main script listens to. Don't build a button from a collider yourself; the builder guards against
that.
SPECS capability skills
| Skill | What it does |
|---|---|
/specs-interaction-recipes | The playbook for hand actions: pinch, hover, grab, swipe, throw, custom gestures |
/specs-keyboard | Shows the AR keyboard for text input: text, URL, number, or phone |
/specs-asr | Turns speech into text in real time, in 40+ languages; good for dictation and talking to an AI |
/specs-ai-remote-service | Connects to AI services through the Remote Service Gateway (see the next table) |
/specs-camera | Reads camera frames for computer vision, AR overlays, and AI |
/specs-depth | Reads per-pixel depth, to place objects at the right distance and hide them behind real things |
/specs-world-query | Casts rays to find real surfaces (floor, table, wall) and places objects on them |
/specs-location | Reads GPS, heading, and Snap Places, for outdoor and map-based AR |
/specs-custom-locations | Anchors content to one scanned real-world place |
/specs-snap-cloud | A cloud backend (Supabase) for saved data, leaderboards, uploads, and edge functions |
/specs-sync-kit | Builds shared, multiplayer, or colocated experiences with Sync Kit |
/specs-internet | Makes HTTP requests and downloads remote media (images, video, audio, glTF) |
/specs-websocket | Opens a lasting two-way connection, for live feeds and streaming |
/specs-spatial-image | Turns a 2D photo into a 3D depth image |
/specs-ndk | Adds a native C++ module for advanced, high-performance code |
The Remote Service Gateway fronts several providers, picked by what you build:
| Provider | Use it for |
|---|---|
| Gemini | Text and multimodal chat; image generation through the Imagen endpoint |
| OpenAI | Chat completions and Realtime voice |
| Snap3D | AI image and 3D generation |
For voice, chat completions with speech recognition (hold to talk) need only the microphone and the gateway. Gemini Live and OpenAI Realtime give full live voice, and need the WebSocket and dynamic audio setup.
/specs-ndk needs CMake, Python 3, and a C++ toolchain. It downloads the SpecsNDK toolchain without
signing in; only if that download is refused (401 or 403) does it install the Google Cloud SDK and
run gcloud auth login.
After a multiplayer build with /specs-sync-kit, the specs-sync-kit-validator agent checks the
project for common setup mistakes, without changing it: sample content left in, the wrong start
mode, game content in the wrong place, and a camera without tracking. It reports a fix for each.
Debugging skills
| Skill | What it does |
|---|---|
/lens-debug | Start here for a bug: describe the symptom, and it routes you to the right specialist |
/specs-debug | Adds checks for SPECS-only bugs: Interaction Kit, the AI gateway, Sync Kit, tracking, world-space UI |
/lens-log-analysis | Reads the logs correctly; a clean compile doesn't mean the Lens actually ran |
/lens-js-debugger | Sets breakpoints, steps through code, and inspects live values. See Debug a Lens With the JavaScript Debugger |
/preview-inspection | Queries the running scene: finds objects, reads transforms, captures a render |
/specs-preview-interaction | Drives the Preview with simulated hand actions (pinch, drag, tap) to test behavior, with no SPECS needed |
/verify-preview | Checks that a change did what was intended, without changing anything; use it after each change |
/verify-preview runs in the main conversation, with the full code in view. It compiles again, captures
the running Preview, can drive an interaction and read the logs, then judges the result against
what the code should do. It stays short and focused to keep the main context small, and can hand
bulk screenshots to a helper when the context fills up.
Testing skills: LEAF
LEAF instruments your Lens for testing: repeatable scenarios that check its parts keep working. CLAD can write and run LEAF scenarios for you.
| Skill | What it does |
|---|---|
/specs-leaf-install-packages | Installs LEAF before you write or run tests |
/specs-leaf-write-scenarios | Writes test scenarios for a Lens and attaches them |
/specs-leaf-run-in-preview | Runs the scenarios in the Preview: the fastest loop while you build |
To install LEAF and write scenarios yourself, see Test Your Lens With LEAF.
Use /verify-preview and LEAF at different times. While you build, /verify-preview checks
whether your last change worked, writes nothing, and is the right tool most of the time. When the experience
is far enough along that you want protection against regressions, use the live-lens-tester agent
(or the LEAF skills) to write a test suite you can run again. Building: /verify-preview. Locking
in: LEAF.
Optimization skills
| Skill | What it does |
|---|---|
/specs-capture-perf-trace | Records a performance trace (.pftrace) from one or more Preview panels |
/perfetto-trace-analysis | Finds frame drops and stutter in a trace, with an honest confidence level |
/specs-lens-perf-attribution | Measures which part of the Lens uses the frame time (ms per frame), and plans fixes |
/specs-lens-perf-optimize | Applies the planned fixes one at a time, checking each and committing each to Git |
/specs-optimize-lens-mesh | Merges meshes that share a material and reduces geometry, to cut draw calls |
/specs-lens-perf-optimize runs two agents in a loop: perf-attribution-runner measures where the
frame time goes, and perf-fix-applicator applies one fix at a time, which can be undone, with a
capture before and after. Both start automatically; you only call the skill.
Migration skill
/specs-27-migration moves an older Lens to the SPECS 27 APIs, updating features that changed.
Publishing skill
/specs-publish takes a SPECS Lens to "submitted for review" in guided phases: it finds the project
and its details, checks sign-in and signing, packages the Lens, uploads it, and submits it.
Related
- What Is CLAD: how the agents and skills fit together.
- Test Your Lens With LEAF: the test framework CLAD writes for.
- The ls-extensions repository: the full list, including the skills for Snapchat Lenses.