miospotdevteam
21 verified skills
lbyl-verify
Verification protocol for reviewing Claude-implemented plan steps. Read plan.json, check every acceptance criterion mechanically, run type checker/linter/tests, check consumers via deps-query, report PASS or structured findings. Never modify source files.
development
doc-coauthoring
Collaborative document authoring through structured dialogue — RFCs, design docs, ADRs, specs, proposals, technical writing, runbooks, onboarding guides, API documentation, decision docs, postmortems, and any prose artifact where clarity and completeness matter. Use whenever the user wants to write, draft, or co-author documentation, specifications, technical proposals, architecture decision records, runbooks, onboarding guides, API docs, or any structured prose document. Also trigger when the user says 'help me write', 'draft an RFC', 'document this decision', 'write a spec', 'I need a design doc', or 'help me explain this'. Do NOT use when: making code changes without documentation output, implementing features, debugging, doing code review without documentation deliverables, writing inline code comments, updating README files as part of a code change, or adding JSDoc/docstrings as part of implementation work.
development
persistent-plans
Persistent planning system that writes every task plan to disk so it survives context compaction. Use this skill for ALL tasks — it is the default operating mode, not an optional add-on. Every coding task, feature, refactor, bug fix, migration, or multi-step operation starts with a plan written to `.temp/plan-mode/active/`. Even small tasks get a lightweight plan. The plan on disk is the source of truth, not context memory. Trigger this skill whenever you are about to do work. If you are starting a task, resuming after compaction, or the user says 'continue' — read the plan first. If no plan exists, create one. The only exception is truly trivial one-liner changes where the user explicitly says 'just do it' or 'no plan.' Do NOT use when: answering questions without code changes, pure research, documentation-only queries, or conversations that don't touch source files.
development
react-native-mobile
Build premium, native-feeling React Native mobile apps with spring animations, gesture-driven UI, haptic feedback, and platform-specific conventions. Use this skill whenever the user asks for: React Native app, mobile app, Expo app, native feel, gesture animations, haptic feedback, mobile UI, iOS/Android app, cross-platform mobile, Reanimated animations, bottom sheet, swipe gestures, pull-to-refresh, mobile navigation, tab bar, mobile onboarding, mobile performance, FlashList, MMKV storage, offline-first mobile, React Native new architecture, mobile dark mode, Dynamic Type, VoiceOver/TalkBack accessibility, Liquid Glass, or any request for building mobile applications that should feel indistinguishable from native apps. Also use when the user references apps like Things 3, Apollo, Spotify, Discord, Shopify, or Apple's HIG / Material Design 3. Do NOT use for: React web apps (use frontend-design), React Native Web without mobile focus, backend APIs, or admin dashboards — this skill is exclusively for native mobile experiences.
development
refactoring
Use when refactoring, restructuring, extracting, reorganizing, renaming across files, or moving files. Make sure to use this skill whenever the user asks to: rename a function, class, or type across multiple files; move files or modules to new locations; extract code into new modules, hooks, or utilities; split large files into smaller ones; restructure directory layouts; consolidate duplicate logic into shared abstractions; change naming conventions across the codebase; or clean up messy code by extracting common parts. Uses dep maps (deps-query.py) for instant consumer discovery before changes and regenerates stale maps after. Two modes: Full Mode (contract-based 4-phase refactoring) and Quick Mode (post-step simplification). Do NOT use for: single-variable renames within one function, formatting-only changes, changes within a single file, adding new features, bug fixes, or writing tests.
development
test-driven-development
Test-Driven Development workflow enforcing red-green-refactor cycles. Use when writing new features, adding behavior, or implementing functions where tests should drive design. Requires explicit test-first prompting because Claude naturally writes implementation first. Integrates with writing-plans (TDD rhythm in Progress items) and engineering-discipline (verification). Do NOT use when: fixing a bug in existing tested code (use systematic-debugging), writing tests for existing untested code (characterization tests are a different workflow), refactoring without behavior change (use refactoring), or the project has no test infrastructure.
development
brainstorming
Use before any creative work — new features, components, behavior changes. Turns vague ideas into concrete designs through collaborative dialogue before any code is written. Make sure to use this skill whenever the user wants to think through design options, is torn between approaches, wants to brainstorm or explore tradeoffs, is unsure about data models or system design, or describes a feature idea with multiple possible solutions and hasn't decided on the approach yet. Do NOT use for: implementation planning (use writing-plans), debugging (use systematic-debugging), refactoring (use refactoring), or pure codebase exploration without a design goal.
development
frontend-design
Create distinctive, production-grade frontend interfaces with intentional design direction — landing pages, portfolios, dashboards, marketing sites, pricing pages, sign-up flows, blog templates, documentation sites, product pages, or any web UI where visual quality matters. Make sure to use this skill whenever the user asks to build, design, or redesign a website, web page, or UI component — especially when they mention wanting it to look 'modern', 'polished', 'premium', 'beautiful', 'professional', 'clean', or 'fresh', or when they care about typography, color palette, visual hierarchy, or design systems. Also trigger when the user says 'make it look good', 'needs a visual refresh', 'feels dated', or 'doesn't stand out'. Covers greenfield (new designs) and integration (extending existing design systems) with framework-specific guidance for HTML/CSS, React, Vue, Svelte, Tailwind, and shadcn/ui. Do NOT use when: fixing a CSS bug with no design change, making backend-only changes, or building WebGL/Three.js/shader/scroll-driven immersive experiences (use immersive-frontend instead). When brainstorming preceded this skill, skip Phases 1-2 and start at Phase 3.
development
immersive-frontend
Build award-winning immersive web experiences with WebGL, Three.js, R3F, GSAP ScrollTrigger, custom GLSL shaders, and scroll-driven 3D choreography. Make sure to use this skill whenever the user asks for: immersive websites, WebGL experiences, 3D web, creative dev, scroll-driven animations, cinematic scroll, Three.js scenes, GSAP + Three.js, motion-driven sites, award-winning website design, Awwwards-quality sites, full-canvas experiences, particle systems, shader effects, smooth scroll with WebGL, preloader animations, image distortion effects, parallax depth, magnetic cursors, text reveal animations, infinite marquees, camera flythrough, noise displacement, fresnel glow, chromatic aberration, post-processing bloom, film grain, or any request that goes beyond standard UI into experiential, motion-first, canvas-driven territory. Also trigger when the user references studios like Active Theory, Lusion, Immersive Garden, or sites from Awwwards/Codrops, or uses words like 'cinematic', 'theatrical', or 'dark theme with neon'. Do NOT use for: standard UI components, form-heavy pages, admin dashboards, simple CSS hover states, or basic Framer Motion page transitions — use frontend-design instead.
development
lbyl-digest
INTERNAL conductor-dispatched digester skill for the look-before-you-leap plugin. Reads raw on-disk artifacts (Codex exploration MD, consensus batch MD files, codex-receipt-step-N.json + diff + modified files) and produces bounded, substance-preserving digests so the main Claude thread never reads raw bytes. Three operating modes: (1) co-exploration digester — merges Claude+Codex exploration outputs into discovery-digest.md; (2) consensus digester — collapses multi-batch consensus outputs into consensus-round-N-digest.md with ACCEPT/MODIFY/REJECT counts and open disagreements; (3) verification digester — reads the codex-receipt-step-N.json evidence artifact, the file changes Codex made, and the modified files themselves, and writes a sibling claude-review file with PASS/FINDINGS verdict + per-finding evidence. Dispatched ONLY by the conductor (look-before-you-leap, codex-dispatch, writing-plans) via the Skill or Agent tool. NEVER assignable as a plan-step skill in plan.json. NEVER write code, NEVER mint HMAC sidecars, NEVER pass --model flags.
tools
svg-art
Generate distinctive, production-quality SVG artwork inline in code — decorative backgrounds, abstract illustrations, generative patterns, filter effects, section dividers, brand marks, data visualizations, and animated elements. Pure hand-coded SVG with no external image assets or libraries. Use this skill whenever the user asks for: SVG illustrations, decorative SVG backgrounds, SVG patterns, SVG textures, grain/noise effects, generative art, abstract shapes, blob shapes, topographic patterns, mesh gradients, hero illustrations, SVG icons, section dividers, SVG filters, duotone effects, glow effects, SVG data visualization, sparklines, inline charts, or any request where visual art should be created as SVG code rather than imported as an image. Also trigger when frontend-design produces a design that calls for decorative artwork, custom illustrations, or textured backgrounds. Do NOT use for: GSAP-driven SVG animation (use immersive-frontend), raster image editing, CSS-only effects that don't need SVG, or simple geometric shapes that don't require artistic direction.
development
look-before-you-leap
Unified engineering discipline for ALL coding tasks. Conductor-mode orchestrator: Claude is the conductor that dispatches every step (Codex implements by default, Claude verifies; or Claude implements via sub-agents and Codex verifies), and the main thread reads ONLY plan.json, progress.json, signed receipts, HMAC sidecars, and lbyl-digest outputs — never raw .codex-result-*.txt, .codex-stream-*.jsonl, codex-exploration.md, codex-consensus-*.md, or git diff. Drives discovery (Claude Explore + Codex co-exploration → lbyl-digest), planning (writing-plans + Codex consensus → lbyl-digest → Orbit), execution (runnable-steps DAG frontier dispatched in parallel), and verification (codex-receipt-step-N.json + lbyl-digest verification). Use for every task that writes, edits, fixes, refactors, ports, migrates, or debugs code — no exceptions, no shortcuts. Do NOT use when: answering questions about code without changing it, pure research or documentation queries, conversations with no file edits, or running commands that don't modify the codebase.
development
react-native-mobile
Codex-facing React Native mobile implementation skill for code-heavy Expo and React Native work: data flow, networking, native modules, storage, list virtualization, performance, tests, and non-visual logic. Route UI/UX animation, haptic feel, gesture taste, and visual polish to Claude per the Routing Directive.
development
skill-review-standard
Post-creation quality gate for skills. Runs structural validation, a functional with/without test, and trigger overlap analysis to produce a SHIP/REVISE/BLOCK verdict. Use after finishing a skill with skill-creator, or when reviewing any skill before shipping. Also use when the user asks to 'review my skill', 'check skill quality', 'is this skill ready to ship', or 'validate this skill'. Do NOT use for: creating skills from scratch (use skill-creator), learning skill conventions (use plugin-dev:skill-development), or reviewing application code.
tools
systematic-debugging
Use when encountering any bug, test failure, or unexpected behavior. Enforces root cause investigation before fixes. Four phases: investigate, analyze patterns, form hypotheses, implement. Prevents guess-and-check thrashing. Use ESPECIALLY when under pressure or when 'just one quick fix' seems obvious. Do NOT use for: learning unfamiliar APIs (use exploration), performance optimization without a specific regression, or code review without a reported bug.
development
webapp-testing
End-to-end webapp testing with Playwright MCP integration. Use when: writing Playwright tests, E2E testing, browser testing, webapp testing, visual regression testing, accessibility testing with axe-core, testing user flows through a web UI, verifying frontend behavior in a real browser. Integrates with test-driven-development skill for test-first browser tests and engineering-discipline for verification. Do NOT use when: unit tests only (no browser UI involved), API tests without UI, mobile native testing (use react-native-mobile), testing CLI tools, or writing backend-only integration tests.
tools
writing-plans
Use after discovery to write implementation plans with TDD-granularity steps. Produces plan.json (immutable definition, frozen after approval), progress.json (mutable execution state), and masterPlan.md (user-facing proposal for Orbit review). Every step is one component/feature; TDD rhythm (test, verify fail, implement, verify pass, commit) lives in its progress items. Consumes discovery.md from exploration phase. Make sure to use this skill whenever the user says discovery is done, exploration is finished, discovery.md is ready, or asks to write/create/draft the implementation plan — even if they don't mention plan.json or masterPlan.md by name. Also use when the user references completed exploration findings, blast radius analysis, or consumer mappings and wants them converted into actionable steps. Do NOT use when: the user says 'just do it' or 'no plan', resuming or executing an existing plan, during exploration or brainstorming (discovery not yet complete), debugging, or code review.
development
mcp-builder
Build production-quality MCP (Model Context Protocol) servers that expose APIs, databases, and services as tools for LLMs. Use this skill whenever the user asks for: MCP server, Model Context Protocol, building MCP tools, MCP tool integration, MCP resource provider, creating tools for Claude, tool server, LLM tool API wrapper, exposing an API as MCP tools, MCP transport setup, stdio server, streamable HTTP server, MCP Inspector testing, or any request to build a server that makes external services available to AI assistants via the Model Context Protocol. Do NOT use when: using existing MCP tools without modification, calling MCP tools from client code, non-MCP API integrations (REST/GraphQL clients), general backend development without MCP, or configuring MCP servers in claude_desktop_config.json — this skill is for building MCP servers, not consuming them.
tools
engineering-discipline
Use for every task that writes, edits, fixes, refactors, ports, migrates, or debugs code — any language, any framework, any project size. This skill enforces the habits that prevent broken builds, missed consumers, and silent scope cuts: read imports and consumers before editing, track blast radius on shared types and utilities, never use `any`/`as any` type shortcuts, run type checkers/linters/tests after every change, and explicitly flag anything you skip. Applies to bug fixes, feature additions, refactors, dependency bumps, config changes, CI fixes, webhook handlers, form validation, migration scripts, and environment setup. Even one-file fixes get the verification step. Do NOT use for pure questions, explanations, research, documentation, code reading, PR reviews, or conversations that don't modify source files.
development
lbyl-implement
Implementation protocol for Codex-owned plan steps. Read plan.json for step description, files, and progress items. Read discovery.md for codebase context. Implement exactly what the step specifies — no scope additions, no scope cuts. Run verification after changes. Report FILES CHANGED, WHAT WAS DONE, VERIFICATION, ISSUES.
development
codex-dispatch
Orchestrates all Codex interactions for the look-before-you-leap plugin via codex exec CLI. Routes to direction-locked scripts (run-codex-verify.sh for claude-impl steps, run-codex-implement.sh for codex-impl steps), parallelizes across the runnable DAG frontier, and is strictly receipt-first: the main thread reads ONLY codex-receipt-step-N.json plus its HMAC sidecar — never raw streams, never .codex-result-step-N.txt as authority, never git diff, never raw exploration / consensus markdown. All large artifacts (exploration outputs, consensus batches, verification cross-checks) are routed through the lbyl-digest sub-agent. Conductor mode is the default and only mode — collab-split is gone. Use whenever a plan step requires Codex interaction. Do NOT use for plans with no Codex involvement.
tools