$ loading_
Learn Swift conventions, naming, and async patterns for DAT SDK iOS development.
This appears to be an open-source iOS development conventions/documentation skill with no declared secrets or remote endpoints, so overall risk is low. The README mentions build/test steps and SDK modules for devices/camera, but based on the provided material it mainly looks like guidance rather than an active tool, with no clear red flags for data exfiltration or credential abuse.
The material explicitly states there are no required keys or environment variables. The README does not request API tokens, account credentials, or other sensitive configuration, and shows no sign of credential collection, storage, or abuse.
No remote endpoints are declared, and the system checks classify it as prompt-only. While the docs mention SDK concepts such as device discovery, registration, and streaming, the provided material does not show this skill itself sending user data to external services.
As a prompt-only skill, it does not present itself as an executable tool. The xcodebuild/open commands in the README are merely development instructions and should not be treated as the skill automatically gaining local code-execution privileges.
The material does not declare any ability to read or write local files, databases, or other user resources. References to camera, display, and device selection are architectural SDK descriptions and do not by themselves show this skill directly accessing user data or requesting excessive permissions.
Positive factors include being open-source on GitHub and therefore auditable. However, the repository has 0 stars, no declared license, unknown maintenance status, and the linkage between this skill and the repo is only asserted in the material, so its provenance and maintenance should still be verified.
Copy the install command and let the AI configure it · recommended for beginners
Please install the "dat-conventions" skill from askskill: 1. Download https://raw.githubusercontent.com/facebook/meta-wearables-dat-ios/main/plugins/mwdat-ios/skills/dat-conventions/SKILL.md 2. Save it as ~/.claude/skills/dat-conventions/SKILL.md 3. Reload skills and tell me it's ready
Review this Swift code against DAT SDK iOS conventions. Check whether the type names, method names, and property names are idiomatic, then provide suggestions and a refactored version.
A list of naming issues, explanations, and a refactored Swift version that follows the conventions.
Rewrite this callback-based DAT SDK iOS code using async/await, and explain how to design error handling, thread switching, and return types.
Async/await sample code with key design notes and best-practice recommendations.
I’m building an iOS integration for the DAT SDK. Help me design the core Swift types, including request models, response models, error types, and protocol abstractions, and explain their responsibilities.
A clear type design proposal, sample code, and explanations of each type’s role in the architecture.
The SDK is organized into four modules:
async/await for all SDK operations — the SDK is fully asyncAsyncSequence / publisher .listen {} for observing streams@MainActor| Type | Convention | Example |
|---|---|---|
| Entry point | Wearables.shared | Wearables.shared.startRegistration() |
| Device sessions | *Session | DeviceSession |
| Capabilities | Named by function | Stream |
| Selectors | *DeviceSelector | AutoDeviceSelector, SpecificDeviceSelector |
| Config | *Configuration | StreamConfiguration |
| Publishers | *Publisher | statePublisher, videoFramePublisher |
import MWDATCore // Registration, devices, permissions
import MWDATCamera // Stream, VideoFrame, photo capture
import MWDATDisplay // Display, FlexBox, Text, Button, Image, Icon, VideoPlayer
For testing:
import MWDATMockDevice // MockDeviceKit, MockRaybanMeta, MockCameraKit
Wearables — SDK entry point. Call Wearables.configure() at launch, then use Wearables.sharedStream — Camera streaming session. Create with config + device selectorDisplay — Display capability attached to a started DeviceSessionVideoFrame — Individual video frame with .makeUIImage() convenienceAutoDeviceSelector — Automatically selects the best available deviceSpecificDeviceSelector — Selects a specific device by identifierStreamConfiguration — Configure video codec, resolution, frame rateMockDeviceKit — Factory for creating simulated devices in testsdo {
try Wearables.configure()
} catch {
// Handle configuration error
}
do {
try await Wearables.shared.startRegistration()
} catch {
// Handle registration error
}
# Install dependencies via Swift Package Manager
# In Xcode: File > Add Package Dependencies > enter repo URL
# Build from command line
xcodebuild -scheme MWDATCore -destination 'platform=iOS Simulator,name=iPhone 16'
# Run tests
xcodebuild test -scheme MWDATCoreTests -destination 'platform=iOS Simulator,name=iPhone 16'
For sample apps:
# Open the sample app workspace
open ExternalSampleApps/CameraAccess/CameraAccess.xcodeproj
# Build and run on simulator (uses MockDeviceKit - no glasses needed)
xcodebuild -scheme CameraAccess -destination 'platform=iOS Simulator,name=iPhone 16'
MWDATCore, MWDATCamera, MWDATDisplay when rendering Display content)try Wearables.configure()xcodebuildIf your editor supports remote MCP servers, connect https://mcp.facebook.com/wearables_dat and use search_dat_docs for current DAT setup, session lifecycle, camera streaming, MockDeviceKit, permissions, and exact API symbols.
Use llms.txt when your tool only supports static reference context.
Identify common bugs, version conflicts, and state machine failures faster.
Guide app registration with Meta AI and camera permission request flows.
Set up the Meta glasses SDK and make your first connection.
Manage device session states, pause and resume flows, and availability monitoring.
Build a complete DAT app with camera streaming and photo capture.
Stream camera video, capture frames or photos, and configure resolution and frame rate.
Learn Kotlin conventions, result handling, and session patterns for DAT SDK Android.
Build a complete DAT app with sessions, camera streaming, and photo capture.
Apply idiomatic Kotlin patterns to build robust, efficient, maintainable applications.
Add expert Swift concurrency guidance for safer code, better performance, and Swift 6 migration.
Build testable Swift code with protocol-based dependency injection and focused mocks.
Name code by domain meaning to improve clarity and team alignment.