Skip to main content

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

Platform details

  • Snapchat — Fully supported.

  • SPECS — Fully supported.

  • Camera Kit Web — Not supported — CLAD's skills cover Snapchat and SPECS Lenses.

  • Camera Kit Mobile — Not 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:

StepSkill 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 itlive-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:

AgentWhat it does
specs-experience-builderPlans and builds a complete SPECS Lens from one prompt
snapchat-experience-builderPlans and builds a complete Snapchat Lens or game from one prompt
script-authorWrites the TypeScript behavior scripts and compile-checks them; doesn't change the scene layout
editor-api-specialistMakes heavy, multi-step project changes through the Editor API, keeping the noise out of the main conversation
specs-project-migratorMoves an older Spectacles (2024) project to SPECS 27, separating the automatic fixes from the manual follow-ups
live-lens-testerWrites 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

SkillWhat it does
/lens-studio-routerThe 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-initChecks a SPECS project: camera, world tracking, required packages, and Preview device
/ensure-package-installedChecks that a package is installed, and installs it and its dependencies from the Asset Library if it's missing
/reset-preview-environmentGives 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

SkillWhat it doesNeeds
/scene-constructionThe hub for adding and arranging objects: read the scene, pick presets, apply, save
/camera-and-renderingSets up cameras and on-screen 2D content, and finds invisible objects
/materialsSets colors, shininess, and textures with presets: the default for "make it look like X"
/shader-graphBuilds custom surfaces no preset can make (glowing, animated, procedural)
/vfx-graphBuilds particle effects: smoke, sparks, trails, magic
/physicsAdds gravity, collisions, joints, and objects you can drag or throw, including collisions with faces, hands, and the world
/build-meshGenerates a finished 3D model from a text description, optionally animated, with the backend that suits it (see the next table)Node.js
/mesh-builder-scriptingBuilds or reshapes geometry from code at runtime, instead of the ready-made models of /build-mesh
/build-imageGenerates a 2D image from a prompt
/lens-package-toolkitInstalls, unpacks, inspects, and authors Lens Studio packages
/update-lens-packagesUpdates Interaction Kit, UI Kit, and Sync Kit to their latest versions, or to a version you name
/lens-apiWrites TypeScript that runs inside a Lens: events, taps, screen-to-world conversion, objects created at runtime
/editor-apiWrites 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-notesThe shared rules the router loads automatically
/specs-build-uiBuilds world-space UI for SPECS: heads-up displays, menus, sliders, switches, text inputs
/font-selectorFinds a font by mood or name and applies it to text
/icon-selectorFinds and imports the right Material icon for a button or panel
/build-musicComposes original music: melodies, beats, jingles. Works offline and is license-freeNode.js; ffmpeg to check the track isn't silent (without it, the track still renders)
/build-sfxGenerates sound effects: clicks, impacts, whooshes, ambient textures, 8-bitNode.js
/specs-audioHow 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:

BackendBest forTrade-offsNeeds
SPECS text-to-3D (the default for static props)The best textures, in any style; also image to 3DStatic only. Runs as a job you create, poll, and download, minutes per modelLens Studio sign-in (no API key)
FAST3DFaster static props, when you ask for fast or draft modelsLower quality than SPECS text-to-3D; no local tools neededLens Studio sign-in
MeshBuilder (code-authored)Anything that must move, articulate, or be generated from parameters: lathe, extrude, tube, skinned meshesHands off to /mesh-builder-scripting and produces TypeScript, not a GLB. No waiting, but less realistic (no textures)
Blender voxelA 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

SkillWhat it does
/specs-interaction-recipesThe playbook for hand actions: pinch, hover, grab, swipe, throw, custom gestures
/specs-keyboardShows the AR keyboard for text input: text, URL, number, or phone
/specs-asrTurns speech into text in real time, in 40+ languages; good for dictation and talking to an AI
/specs-ai-remote-serviceConnects to AI services through the Remote Service Gateway (see the next table)
/specs-cameraReads camera frames for computer vision, AR overlays, and AI
/specs-depthReads per-pixel depth, to place objects at the right distance and hide them behind real things
/specs-world-queryCasts rays to find real surfaces (floor, table, wall) and places objects on them
/specs-locationReads GPS, heading, and Snap Places, for outdoor and map-based AR
/specs-custom-locationsAnchors content to one scanned real-world place
/specs-snap-cloudA cloud backend (Supabase) for saved data, leaderboards, uploads, and edge functions
/specs-sync-kitBuilds shared, multiplayer, or colocated experiences with Sync Kit
/specs-internetMakes HTTP requests and downloads remote media (images, video, audio, glTF)
/specs-websocketOpens a lasting two-way connection, for live feeds and streaming
/specs-spatial-imageTurns a 2D photo into a 3D depth image
/specs-ndkAdds a native C++ module for advanced, high-performance code

The Remote Service Gateway fronts several providers, picked by what you build:

ProviderUse it for
GeminiText and multimodal chat; image generation through the Imagen endpoint
OpenAIChat completions and Realtime voice
Snap3DAI 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

SkillWhat it does
/lens-debugStart here for a bug: describe the symptom, and it routes you to the right specialist
/specs-debugAdds checks for SPECS-only bugs: Interaction Kit, the AI gateway, Sync Kit, tracking, world-space UI
/lens-log-analysisReads the logs correctly; a clean compile doesn't mean the Lens actually ran
/lens-js-debuggerSets breakpoints, steps through code, and inspects live values. See Debug a Lens With the JavaScript Debugger
/preview-inspectionQueries the running scene: finds objects, reads transforms, captures a render
/specs-preview-interactionDrives the Preview with simulated hand actions (pinch, drag, tap) to test behavior, with no SPECS needed
/verify-previewChecks 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.

SkillWhat it does
/specs-leaf-install-packagesInstalls LEAF before you write or run tests
/specs-leaf-write-scenariosWrites test scenarios for a Lens and attaches them
/specs-leaf-run-in-previewRuns 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

SkillWhat it does
/specs-capture-perf-traceRecords a performance trace (.pftrace) from one or more Preview panels
/perfetto-trace-analysisFinds frame drops and stutter in a trace, with an honest confidence level
/specs-lens-perf-attributionMeasures which part of the Lens uses the frame time (ms per frame), and plans fixes
/specs-lens-perf-optimizeApplies the planned fixes one at a time, checking each and committing each to Git
/specs-optimize-lens-meshMerges 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.