Building SPECS Experiences Faster
Building for SPECS is not like building a web page or a mobile app. The canvas is the world around the wearer, and the input model is hands, gaze, voice, mobile controls, and physical motion all at once. Get it wrong and the experience feels laggy, unreadable, or unstable the moment it's on someone's face.
Three pieces make this tractable, and they stack:
SIK (SPECS Interaction Kit) handles the hard parts of input, pinch, grab, poke, hover, hand and mobile control, and the event system that connects them to objects in a scene.
SPECS UI Kit sits on top of SIK and adds the interface layer: buttons, sliders, switches, frames, text input, scroll views, and per-state visual feedback.
CLAD (Closed Loop Agentic Development) is the newest piece. It connects an AI coding tool directly to Lens Studio so it can build scenes, wire up the two toolkits, debug, and iterate, in the same editor you already use.
The key point is that CLAD doesn't invent spatial interactions from scratch. It reaches for the same battle-tested SIK and UI Kit components a developer would, which is exactly why the output holds up on hardware. The rest of this post walks through that loop, then shows what we built with it.
A note on names: SIK and the UI Kit are shown here under their future-facing names, SPECS Interaction Kit and SPECS UI Kit. You may know them today as Spectacles Interaction Kit and Spectacles UI Kit.
The reason this works is that SIK and the UI Kit already solve the problems every spatial Lens runs into. Nobody has to rebuild input targeting, gesture state, hover feedback, draggable objects, or panel controls from scratch; they start from components that already know how a SPECS experience should feel, and extend from there.
For more background on the interaction model behind these systems, see the earlier Snap Engineering article on spatial interaction for Spectacles.
SIK: Hand, mobile, and multimodal interaction events.
SPECS UI Kit: Controls, frames, text input, themes, layouts, and spatial UI states.
Samples: Working examples that can be cloned, remixed, and extended.
CLAD: AI-assisted assembly, debugging, testing, and iteration.
The practical split is simple: SIK turns intent into events, while SPECS UI Kit turns those events into interfaces people can understand in space. The SIK focuses on hand tracking, gestures, targeting, and interactables; the SPECS UI Kit focuses on reusable controls, panels, layout, and visual states.
SIK gives a Lens a shared language for input. A pinch, poke, hover, grab, ray target, or mobile-controller action can all flow through interactors and input data providers, then land on the same interactable objects in the scene. That means a developer can build the behavior once, then support multiple ways of reaching it.
SPECS UI Kit builds on SIK with controls that already understand spatial states: idle, hovered, triggered, toggled, disabled, error, and more. Instead of hand-building every panel, developers can start with buttons, sliders, switches, text input, scroll views, frames, backplates, and layout systems that are designed for SPECS.
That layer model shows up as real components, a spatial backplate for grouping content, custom visual styling, and extended button behavior, each keeping its interaction states intact.
The Spectacles hackathon showcase is a useful proof point because the projects are not all the same kind of Lens. Developers have built AR codebase maps, live captioning tools, sign-language translators, reading companions, CPR training, cultural learning experiences, navigation utilities, spatial games, filmmaking tools, creative workbenches, and skill-capture assistants like Over Shoulder. Different genres, same foundation: objects need to be targetable, controls need to respond clearly, and interfaces need to stay readable while the user moves through the world.
Over Shoulder, built at AWE 2026 by Inna Horobchunk, Volodymyr Kurbatov, and Liam Mason, shows that foundation in a practical setting. It started from a simple question:
“So, being lazy, we asked: what if we just demonstrate a skill once, and the system builds the whole contextual guide? That's how we found our direction, and a simple question became the core of Over Shoulder: the platform that turns expertise into guidance.”
In practice, a pro performs a task once while wearing SPECS, and the system extracts the actions, context, and voice into a reusable Skills Library that can be reviewed and edited later.
Because these skills can span many physical contexts, the interface has to adapt without getting in the way. That is exactly the kind of experience SIK and SPECS UI Kit are meant to support: reliable targeting, clear controls, spatial feedback, and panels that stay useful while the user keeps moving through the task. Watch the full Over Shoulder demo.
Ask for a hand-controlled object, a spatial settings panel, a draggable creative tool, or a prototype game mechanic, and CLAD builds it from the same primitives you'd reach for by hand, SIK for the interaction, the UI Kit for the interface.
Under the hood it drives Lens Studio directly: creating objects, attaching components, importing assets, writing TypeScript, updating materials, configuring cameras, and running the preview. The "closed loop" part is what happens next, when the first result is off, CLAD inspects the scene, reads the logs, makes a targeted change, and checks again, instead of handing you a wall of code to debug alone.
CLAD is built around the best practices we've developed through years of working in Lens Studio. Rather than treating AI as a general-purpose assistant, it captures that domain expertise as reusable, composable skills that guide the agent through proven workflows.
Those skills are open source and available today in the ls-extensions repository, with the full collection browsable here. They span nearly every part of Lens Studio development, scene construction, rendering, shaders, and materials through debugging, performance, testing, package management, and publishing. Each one packages practical knowledge into a repeatable workflow, so the agent handles specialized tasks with consistency instead of relying on generic prompting.
Skills are also modular and shareable: use the built-in collection today, adapt them to your own workflows, or write new ones that encode your team's knowledge. As the collection grows, so does what the agents built on top of it can do.
Describe what you want to build. CLAD creates a scene, picks starter structures, generates supporting assets, and sets up an initial interaction model, so early ideation feels less like scaffolding and more like shaping.
Once the prototype exists, CLAD adds the real behavior: grab and release, hover feedback, poke targets, sliders, switches, draggable frames, scroll views, state management, audio, shader effects, and spatial placement. The toolkits become part of its build vocabulary rather than something the developer wires up separately.
This pays off most on UI-heavy Lenses. CLAD asks the UI Kit for a round button instead of hand-building one, picks a style that already defines idle, hovered, triggered, toggled, error, and inactive states, and reaches for grid, flex, and virtualized-list patterns when a Lens needs menus, inventories, leaderboards, or long settings panels.
Spatial bugs are usually visual or behavioral: a button doesn't respond, content appears behind the user, a shader renders wrong, or hand input feels off. CLAD inspects the Lens Studio preview, collects logs, uses the JavaScript debugger, and applies fixes with full scene context, including the exact SIK and UI Kit components involved.
For repeatable checks, CLAD works with LEAF, the Lens Evaluation and Automation Framework. LEAF lets you define scenarios that run against a Lens in the preview: simulate hand input, gestures, ray targeting, hover, trigger, and drag, then assert that the Lens behaved correctly.
In practice, an interaction flow becomes a regression test. A scenario might open a UI Kit menu, hover a button, trigger it, drag an object, scroll a list, and confirm the visible state changed. Because UI Kit controls are built on SIK interactables, those checks target the same interaction layer a developer uses in the Lens, not a separate test-only path.
LEAF also validates reach-sensitive UI with a Bitmoji-powered IK interactor. Rather than calling a button directly, the test drives a full arm and head toward the target, surfacing controls that are too far away, hidden behind content, or only reachable through an unintended far-field ray. CLAD installs LEAF, authors these scenarios, runs them, and interprets the results while the prototype is still moving fast.
For performance-sensitive work, CLAD profiles the Lens, attributes frame cost, and applies focused optimizations so the interaction and UI hold their frame rate on hardware.
When the experience is ready, CLAD can help with final checks, package preparation, and publishing workflows. The same loop that helped create the Lens can help move it toward a shareable build.
The one-day builds are our own stress test, but the SPECS community has been showing the real range. Developers are shipping games, creative tools, educational experiences, media viewers, and collaborative spatial interfaces, all resting on the same fundamentals: hands that feel reliable, interface elements that respond clearly, and feedback that feels native to the hardware.
Since launch, Spectacles Community Challenge submissions have showcased the breadth of what's possible on Spectacles—from fitness and procedural escape rooms to spatial painting, reality-bending world effects, hands-on science labs, and live-stream media experiments.
What unites these projects isn't a single genre or style—it's a focus on making interactions feel natural, immersive, and uniquely suited to Spectacles. With CLAD, creators can explore ideas more quickly, remix proven examples, and turn early prototypes into polished experiences.
Here are a few projects from past Community Challenges:
Magic Science Lab is a hands-on AR chemistry lab for Spectacles that lets users safely explore chemical reactions through spatial interaction. The update added direct hand tracking interaction with improved precision and stability. Users can now trigger reactions using natural hand gestures, making the experience more intuitive and immersive. The lens turns any environment into an interactive mini lab for learning and experimentation.
Vector Fields makes abstract math concepts tangible by visualizing vector fields in AR. Players can explore magnetic dipoles, expansion and contraction dynamics, and vortex or wave patterns, switching between field types and rendering modes like flow lines, particles, and arrows for a hands-on learning experience.
Cubique Chamber offers a spatial twist on the classic Rubik's Cube, placing users inside the iconic puzzle itself. With a panel of buttons at their disposal, players are challenged to solve the cube from within, testing their logic and spatial awareness in a new way. The experience reimagines a familiar game with an immersive perspective, turning problem-solving into a fully interactive challenge.
Reachy Mini brings a cute robot into AR. Users can control it directly like a puppet or speak with it in Assistant Mode, where it responds to voice and information about its surroundings. A simulator mode lets people without a physical robot enjoy the same experience. Created by creative technologist Johannes Tscharn, the Reachy Mini Lens and its companion Python app are available as an open-source, MIT-licensed template, with documentation for developers who want to customize or extend it. The source code is available in the spectacles-reachy-mini GitHub repository.
Agility Trainer for Spectacles is a training experience designed to improve stamina, speed, dexterity, and mobility through interactive gameplay. It features four easy-to-understand game modes with persistent scoring to track progress over time. The experience supports both physical movement and cognitive skills, combining reaction-based challenges with full-body engagement in AR.
SynthSync is an asymmetric rhythm game that transforms music into a synchronized full-body workout across Spectacles and mobile. One player acts as the trainer on a phone, sending beat-driven challenges, while the Spectacles wearer dodges, catches, and moves in sync with the rhythm. Powered by Snap Cloud for real-time synchronization, the experience supports both multiplayer and solo play, combining motion gameplay, music interaction, and dynamic body tracking into a competitive fitness-inspired experience.
TransitView NL is a Spectacles Lens that brings public transport data from the Netherlands into an immersive spatial interface, allowing users to explore real-time timetables and routes directly within their environment. The Lens also includes a demo mode that simulates locations in Amsterdam, enabling users outside the Netherlands to experience the functionality and interact with transit information as if they were at a local stop.
AirTouch is a Spectacles prototype created by Krunal Gediya that turns a laptop display into a spatial touchscreen. After defining the screen with a four-corner pinch calibration, users can interact with a Mac or Windows computer through hand tracking, including clicking, dragging, scrolling, and moving the cursor in space. AirTouch combines Spectacles hand tracking, spatial plane projection, WebSocket communication, and a companion desktop app to add spatial interaction to traditional computing workflows. Its source code and documentation are publicly available in the AirTouch GitHub repository.
To see how fast the loop could really move, we gave ourselves a constraint: one working SPECS experience per day, no throwaway demos. The results below span games, education, productivity, media, and simulation, and each followed the same shape, a clear prompt, a first working version assembled on top of SIK and the UI Kit, then iteration on feel and feedback.
To be clear about what "a day" means: CLAD was fastest at the parts that are usually slowest, standing up a scene, wiring interactions, and building out UI panels went from hours to minutes. The time that remained went where it should, into judgment calls, tuning spatial placement so a board sits naturally on a real table, adjusting feedback timing, and catching cases where the first generated layout was technically correct but didn't feel right on device. The toolkits are why the output was stable enough to iterate on instead of rebuild.
The first setup is intentionally simple: open Lens Studio, create a SPECS project, and start from the Base Template. From there, you can build manually with SIK and SPECS UI Kit, or connect CLAD and ask it to assemble, modify, inspect, debug, test, or optimize the experience with you.
Open Lens Studio and create a SPECS project.
Start from the Base Template.
Use SIK for hand and mobile interaction patterns.
Use SPECS UI Kit for spatial controls, panels, text input, layout, states, and feedback.
Connect your AI coding tool when you want CLAD to help build, inspect, debug, test, or optimize the experience. Start from the official setup guides for Claude Code, Codex, or Cursor.
The important setup detail is that Lens Studio should already be open with the SPECS project before the AI tool connects. That lets the project expose its Lens Studio MCP connection, so CLAD can inspect the scene, install packages, run tools, and make changes inside the active project.
Build from scratch: Make a hand-controlled constellation builder for SPECS using SIK interactions and a SPECS UI Kit control panel.
Add interaction: Use SIK to add grab, hover, and release behavior to these floating objects.
Improve the interface: Turn this debug panel into a compact SPECS UI Kit panel with buttons, sliders, and status feedback.
Organize content: Use SPECS UI Kit layout components to make this inventory panel responsive and scrollable.
Customize behavior: Extend this SIK interactable so it only responds to poke input while the menu is open.
Verify behavior: Run the preview, inspect why this SPECS UI Kit button is not responding, and fix the SIK event wiring.
Add tests: Create a LEAF scenario that opens the SPECS UI Kit menu, selects an item, and verifies the scene changes.
The best SPECS experiences come from tight iteration across interaction, visuals, performance, and real-world feel. SIK and the UI Kit provide the native patterns that make that iteration stable; CLAD shortens the path from intent to a working version you can react to. The seven apps above weren't built despite the toolkits or replaced by AI, they were built by putting the two together.
Open Lens Studio, start from the SIK and UI Kit foundations, and connect CLAD when you want the loop to move faster.