@hybridlabor-api/bdb-antigravity-skills 1.0.0

package/skills/global_legacy/simplify-code/SKILL.md

@@ -0,0 +1,183 @@
+---
+name: simplify-code
+description: "Review a diff for clarity and safe simplifications, then optionally apply low-risk fixes."
+risk: safe
+source: "Dimillian/Skills (MIT)"
+date_added: "2026-03-25"
+---
+
+# Simplify Code
+
+Review changed code for reuse, quality, efficiency, and clarity issues. Use Codex sub-agents to review in parallel, then optionally apply only high-confidence, behavior-preserving fixes.
+
+## When to Use
+- When the user asks to simplify, clean up, refactor, or review changed code.
+- When you want high-confidence, behavior-preserving improvements on a scoped diff.
+
+## Modes
+
+Choose the mode from the user's request:
+
+- `review-only`: user asks to review, audit, or check the changes
+- `safe-fixes`: user asks to simplify, clean up, or refactor the changes
+- `fix-and-validate`: same as `safe-fixes`, but also run the smallest relevant validation after edits
+
+If the user does not specify, default to:
+
+- `review-only` for "review", "audit", or "check"
+- `safe-fixes` for "simplify", "clean up", or "refactor"
+
+## Step 1: Determine the Scope and Diff Command
+
+Prefer this scope order:
+
+1. Files or paths explicitly named by the user
+2. Current git changes
+3. Files edited earlier in the current Codex turn
+4. Most recently modified tracked files, only if the user asked for a review but there is no diff
+
+If there is no clear scope, stop and say so briefly.
+
+When using git changes, determine the smallest correct diff command based on the repo state:
+
+- unstaged work: `git diff`
+- staged work: `git diff --cached`
+- branch or commit comparison explicitly requested by the user: use that exact diff target
+- mixed staged and unstaged work: review both
+
+Do not assume `git diff HEAD` is the right default when a smaller diff is available.
+
+Before reviewing standards or applying fixes, read the repo's local instruction files and relevant project docs for the touched area. Prefer the closest applicable guidance, such as:
+
+- `AGENTS.md`
+- repo workflow docs
+- architecture or style docs for the touched module
+
+Use those instructions to distinguish real issues from intentional local patterns.
+
+## Step 2: Launch Four Review Sub-Agents in Parallel
+
+Use Codex sub-agents when the scope is large enough for parallel review to help. For a tiny diff or one very small file, it is acceptable to review locally instead.
+
+When spawning sub-agents:
+
+- give each sub-agent the same scope
+- tell each sub-agent to inspect only its assigned review role
+- ask for concise, structured findings only
+- ask each sub-agent to report file, line or symbol, problem, recommended fix, and confidence
+
+Use four review roles.
+
+### Sub-Agent 1: Code Reuse Review
+
+Review the changes for reuse opportunities:
+
+1. Search for existing helpers, utilities, or shared abstractions that already solve the same problem.
+2. Flag duplicated functions or near-duplicate logic introduced in the change.
+3. Flag inline logic that should call an existing helper instead of re-implementing it.
+
+Recommended sub-agent role: `explorer` for broad codebase lookup, or `reviewer` if a stronger review pass is more useful than wide search.
+
+### Sub-Agent 2: Code Quality Review
+
+Review the same changes for code quality issues:
+
+1. Redundant state, cached values, or derived values stored unnecessarily
+2. Parameter sprawl caused by threading new arguments through existing call chains
+3. Copy-paste with slight variation that should become a shared abstraction
+4. Leaky abstractions or ownership violations across module boundaries
+5. Stringly-typed values where existing typed contracts, enums, or constants already exist
+
+Recommended sub-agent role: `reviewer`
+
+### Sub-Agent 3: Efficiency Review
+
+Review the same changes for efficiency issues:
+
+1. Repeated work, duplicate reads, duplicate API calls, or unnecessary recomputation
+2. Sequential work that could safely run concurrently
+3. New work added to startup, render, request, or other hot paths without clear need
+4. Pre-checks for existence when the operation itself can be attempted directly and errors handled
+5. Memory growth, missing cleanup, or listener/subscription leaks
+6. Overly broad reads or scans when the code only needs a subset
+
+Recommended sub-agent role: `reviewer`
+
+### Sub-Agent 4: Clarity and Standards Review
+
+Review the same changes for clarity, local standards, and balance:
+
+1. Violations of local project conventions or module patterns
+2. Unnecessary complexity, deep nesting, weak names, or redundant comments
+3. Overly compact or clever code that reduces readability
+4. Over-simplification that collapses separate concerns into one unclear unit
+5. Dead code, dead abstractions, or indirection without value
+
+Recommended sub-agent role: `reviewer`
+
+Only report issues that materially improve maintainability, correctness, or cost. Do not churn code just to make it look different.
+
+## Step 3: Aggregate Findings
+
+Wait for all review sub-agents to complete, then merge their findings.
+
+Normalize findings into this shape:
+
+1. File and line or nearest symbol
+2. Category: reuse, quality, efficiency, or clarity
+3. Why it is a problem
+4. Recommended fix
+5. Confidence: high, medium, or low
+
+Discard weak, duplicative, or instruction-conflicting findings before editing.
+
+## Step 4: Fix Issues Carefully
+
+In `review-only` mode, stop after reporting findings.
+
+In `safe-fixes` or `fix-and-validate` mode:
+
+- Apply only high-confidence, behavior-preserving fixes
+- Skip subjective refactors that need product or architectural judgment
+- Preserve local patterns when they are intentional or instruction-backed
+- Keep edits scoped to the reviewed files unless a small adjacent change is required to complete the fix correctly
+
+Prefer fixes like:
+
+- replacing duplicated code with an existing helper
+- removing redundant state or dead code
+- simplifying control flow without changing behavior
+- narrowing overly broad operations
+- renaming unclear locals when the scope is contained
+
+Do not stage, commit, or push changes as part of this skill.
+
+## Step 5: Validate When Required
+
+In `fix-and-validate` mode, run the smallest relevant validation for the touched scope after edits.
+
+Examples:
+
+- targeted tests for the touched module
+- typecheck or compile for the touched target
+- formatter or lint check if that is the project's real safety gate
+
+Prefer fast, scoped validation over full-suite runs unless the change breadth justifies more.
+
+If validation is skipped because the user asked not to run it, say so explicitly.
+
+## Step 6: Summarize Outcome
+
+Close with a brief result:
+
+- what was reviewed
+- what was fixed, if anything
+- what was intentionally left alone
+- whether validation ran
+
+If the code is already clean for this rubric, say that directly instead of manufacturing edits.
+
+## Limitations
+- Use this skill only when the task clearly matches the scope described above.
+- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
+- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.

package/skills/global_legacy/slack-automation/SKILL.md

@@ -0,0 +1,197 @@
+---
+name: slack-automation
+description: "Automate Slack workspace operations including messaging, search, channel management, and reaction workflows through Composio's Slack toolkit."
+risk: critical
+source: community
+date_added: "2026-02-27"
+---
+
+# Slack Automation via Rube MCP
+
+Automate Slack workspace operations including messaging, search, channel management, and reaction workflows through Composio's Slack toolkit.
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Slack connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `slack`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `slack`
+3. If connection is not ACTIVE, follow the returned auth link to complete Slack OAuth
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Core Workflows
+
+### 1. Send Messages to Channels
+
+**When to use**: User wants to post a message to a Slack channel or DM
+
+**Tool sequence**:
+1. `SLACK_FIND_CHANNELS` - Resolve channel name to channel ID [Prerequisite]
+2. `SLACK_LIST_ALL_CHANNELS` - Fallback if FIND_CHANNELS returns empty/ambiguous results [Fallback]
+3. `SLACK_FIND_USERS` - Resolve user for DMs or @mentions [Optional]
+4. `SLACK_OPEN_DM` - Open/reuse a DM channel if messaging a user directly [Optional]
+5. `SLACK_SEND_MESSAGE` - Post the message with resolved channel ID [Required]
+6. `SLACK_UPDATES_A_SLACK_MESSAGE` - Edit the posted message if corrections needed [Optional]
+
+**Key parameters**:
+- `channel`: Channel ID or name (without '#' prefix)
+- `markdown_text`: Preferred field for formatted messages (supports headers, bold, italic, code blocks)
+- `text`: Raw text fallback (deprecated in favor of markdown_text)
+- `thread_ts`: Timestamp of parent message to reply in a thread
+- `blocks`: Block Kit layout blocks (deprecated, use markdown_text)
+
+**Pitfalls**:
+- `SLACK_FIND_CHANNELS` requires `query` param; missing it errors with "Invalid request data provided"
+- `SLACK_SEND_MESSAGE` requires valid channel plus one of markdown_text/text/blocks/attachments
+- Invalid block payloads return error=invalid_blocks (max 50 blocks)
+- Replies become top-level posts if `thread_ts` is omitted
+- Persist `response.data.channel` and `response.data.message.ts` from SEND_MESSAGE for edit/thread operations
+
+### 2. Search Messages and Conversations
+
+**When to use**: User wants to find specific messages across the workspace
+
+**Tool sequence**:
+1. `SLACK_FIND_CHANNELS` - Resolve channel for scoped search with `in:#channel` [Optional]
+2. `SLACK_FIND_USERS` - Resolve user for author filter with `from:@user` [Optional]
+3. `SLACK_SEARCH_MESSAGES` - Run keyword search across accessible conversations [Required]
+4. `SLACK_FETCH_MESSAGE_THREAD_FROM_A_CONVERSATION` - Expand threads for relevant hits [Required]
+
+**Key parameters**:
+- `query`: Search string supporting modifiers (`in:#channel`, `from:@user`, `before:YYYY-MM-DD`, `after:YYYY-MM-DD`, `has:link`, `has:file`)
+- `count`: Results per page (max 100), or total with auto_paginate=true
+- `sort`: 'score' (relevance) or 'timestamp' (chronological)
+- `sort_dir`: 'asc' or 'desc'
+
+**Pitfalls**:
+- Validation fails if `query` is missing/empty
+- `ok=true` can still mean no hits (`response.data.messages.total=0`)
+- Matches are under `response.data.messages.matches` (sometimes also `response.data_preview.messages.matches`)
+- `match.text` may be empty/truncated; key info can appear in `matches[].attachments[]`
+- Thread expansion via FETCH_MESSAGE_THREAD can truncate when `response.data.has_more=true`; paginate via `response_metadata.next_cursor`
+
+### 3. Manage Channels and Users
+
+**When to use**: User wants to list channels, users, or workspace info
+
+**Tool sequence**:
+1. `SLACK_FETCH_TEAM_INFO` - Validate connectivity and get workspace identity [Required]
+2. `SLACK_LIST_ALL_CHANNELS` - Enumerate public channels [Required]
+3. `SLACK_LIST_CONVERSATIONS` - Include private channels and DMs [Optional]
+4. `SLACK_LIST_ALL_USERS` - List workspace members [Required]
+5. `SLACK_RETRIEVE_CONVERSATION_INFORMATION` - Get detailed channel metadata [Optional]
+6. `SLACK_LIST_USER_GROUPS_FOR_TEAM_WITH_OPTIONS` - List user groups [Optional]
+
+**Key parameters**:
+- `cursor`: Pagination cursor from `response_metadata.next_cursor`
+- `limit`: Results per page (default varies; set explicitly for large workspaces)
+- `types`: Channel types filter ('public_channel', 'private_channel', 'im', 'mpim')
+
+**Pitfalls**:
+- Workspace metadata is nested under `response.data.team`, not top-level
+- `SLACK_LIST_ALL_CHANNELS` returns public channels only; use `SLACK_LIST_CONVERSATIONS` for private/IM coverage
+- `SLACK_LIST_ALL_USERS` can hit HTTP 429 rate limits; honor Retry-After header
+- Always paginate via `response_metadata.next_cursor` until empty; de-duplicate by `id`
+
+### 4. React to and Thread Messages
+
+**When to use**: User wants to add reactions or manage threaded conversations
+
+**Tool sequence**:
+1. `SLACK_SEARCH_MESSAGES` or `SLACK_FETCH_CONVERSATION_HISTORY` - Find the target message [Prerequisite]
+2. `SLACK_ADD_REACTION_TO_AN_ITEM` - Add an emoji reaction [Required]
+3. `SLACK_FETCH_ITEM_REACTIONS` - List reactions on a message [Optional]
+4. `SLACK_REMOVE_REACTION_FROM_ITEM` - Remove a reaction [Optional]
+5. `SLACK_SEND_MESSAGE` - Reply in thread using `thread_ts` [Optional]
+6. `SLACK_FETCH_MESSAGE_THREAD_FROM_A_CONVERSATION` - Read full thread [Optional]
+
+**Key parameters**:
+- `channel`: Channel ID where the message lives
+- `timestamp` / `ts`: Message timestamp (unique identifier like '1234567890.123456')
+- `name`: Emoji name without colons (e.g., 'thumbsup', 'wave::skin-tone-3')
+- `thread_ts`: Parent message timestamp for threaded replies
+
+**Pitfalls**:
+- Reactions require exact channel ID + message timestamp pair
+- Emoji names use Slack's naming convention without colons
+- `SLACK_FETCH_CONVERSATION_HISTORY` only returns main channel timeline, NOT threaded replies
+- Use `SLACK_FETCH_MESSAGE_THREAD_FROM_A_CONVERSATION` with parent's `thread_ts` to get thread replies
+
+### 5. Schedule Messages
+
+**When to use**: User wants to schedule a message for future delivery
+
+**Tool sequence**:
+1. `SLACK_FIND_CHANNELS` - Resolve channel ID [Prerequisite]
+2. `SLACK_SCHEDULE_MESSAGE` - Schedule the message with `post_at` timestamp [Required]
+
+**Key parameters**:
+- `channel`: Resolved channel ID
+- `post_at`: Unix timestamp for delivery (up to 120 days in advance)
+- `text` / `blocks`: Message content
+
+**Pitfalls**:
+- Scheduling is limited to 120 days in advance
+- `post_at` must be a Unix timestamp, not ISO 8601
+
+## Common Patterns
+
+### ID Resolution
+Always resolve display names to IDs before operations:
+- **Channel name -> Channel ID**: `SLACK_FIND_CHANNELS` with `query` param
+- **User name -> User ID**: `SLACK_FIND_USERS` with `search_query` or `email`
+- **DM channel**: `SLACK_OPEN_DM` with resolved user IDs
+
+### Pagination
+Most list endpoints use cursor-based pagination:
+- Follow `response_metadata.next_cursor` until empty
+- Set explicit `limit` values (e.g., 100-200) for reliable paging
+- De-duplicate results by `id` across pages
+
+### Message Formatting
+- Prefer `markdown_text` over `text` or `blocks` for formatted messages
+- Use `<@USER_ID>` format to mention users (not @username)
+- Use `\n` for line breaks in markdown_text
+
+## Known Pitfalls
+
+- **Channel resolution**: `SLACK_FIND_CHANNELS` can return empty results if channel is private and bot hasn't been invited
+- **Rate limits**: `SLACK_LIST_ALL_USERS` and other list endpoints can hit HTTP 429; honor Retry-After header
+- **Nested responses**: Results may be nested under `response.data.results[0].response.data` in wrapped executions
+- **Thread vs channel**: `SLACK_FETCH_CONVERSATION_HISTORY` returns main timeline only; use `SLACK_FETCH_MESSAGE_THREAD_FROM_A_CONVERSATION` for thread replies
+- **Message editing**: Requires both `channel` and original message `ts`; persist these from SEND_MESSAGE response
+- **Search delays**: Recently posted messages may not appear in search results immediately
+- **Scope limitations**: Missing OAuth scopes can cause 403 errors; check with `SLACK_GET_APP_PERMISSION_SCOPES`
+
+## Quick Reference
+
+| Task | Tool Slug | Key Params |
+|------|-----------|------------|
+| Find channels | `SLACK_FIND_CHANNELS` | `query` |
+| List all channels | `SLACK_LIST_ALL_CHANNELS` | `limit`, `cursor`, `types` |
+| Send message | `SLACK_SEND_MESSAGE` | `channel`, `markdown_text` |
+| Edit message | `SLACK_UPDATES_A_SLACK_MESSAGE` | `channel`, `ts`, `markdown_text` |
+| Search messages | `SLACK_SEARCH_MESSAGES` | `query`, `count`, `sort` |
+| Get thread | `SLACK_FETCH_MESSAGE_THREAD_FROM_A_CONVERSATION` | `channel`, `ts` |
+| Add reaction | `SLACK_ADD_REACTION_TO_AN_ITEM` | `channel`, `name`, `timestamp` |
+| Find users | `SLACK_FIND_USERS` | `search_query` or `email` |
+| List users | `SLACK_LIST_ALL_USERS` | `limit`, `cursor` |
+| Open DM | `SLACK_OPEN_DM` | user IDs |
+| Schedule message | `SLACK_SCHEDULE_MESSAGE` | `channel`, `post_at`, `text` |
+| Get channel info | `SLACK_RETRIEVE_CONVERSATION_INFORMATION` | channel ID |
+| Channel history | `SLACK_FETCH_CONVERSATION_HISTORY` | `channel`, `oldest`, `latest` |
+| Workspace info | `SLACK_FETCH_TEAM_INFO` | (none) |
+
+## When to Use
+This skill is applicable to execute the workflow or actions described in the overview.
+
+## Limitations
+- Use this skill only when the task clearly matches the scope described above.
+- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
+- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.

package/skills/global_legacy/software-architecture/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: software-architecture
+description: "Guide for quality focused software architecture. This skill should be used when users want to write code, design architecture, analyze code, in any case that relates to software development."
+risk: unknown
+source: community
+date_added: "2026-02-27"
+---
+
+# Software Architecture Development Skill
+
+This skill provides guidance for quality focused software development and architecture. It is based on Clean Architecture and Domain Driven Design principles.
+
+## Code Style Rules
+
+### General Principles
+
+- **Early return pattern**: Always use early returns when possible, over nested conditions for better readability
+- Avoid code duplication through creation of reusable functions and modules
+- Decompose long (more than 80 lines of code) components and functions into multiple smaller components and functions. If they cannot be used anywhere else, keep it in the same file. But if file longer than 200 lines of code, it should be split into multiple files.
+- Use arrow functions instead of function declarations when possible
+
+### Best Practices
+
+#### Library-First Approach
+
+- **ALWAYS search for existing solutions before writing custom code**
+  - Check npm for existing libraries that solve the problem
+  - Evaluate existing services/SaaS solutions
+  - Consider third-party APIs for common functionality
+- Use libraries instead of writing your own utils or helpers. For example, use `cockatiel` instead of writing your own retry logic.
+- **When custom code IS justified:**
+  - Specific business logic unique to the domain
+  - Performance-critical paths with special requirements
+  - When external dependencies would be overkill
+  - Security-sensitive code requiring full control
+  - When existing solutions don't meet requirements after thorough evaluation
+
+#### Architecture and Design
+
+- **Clean Architecture & DDD Principles:**
+  - Follow domain-driven design and ubiquitous language
+  - Separate domain entities from infrastructure concerns
+  - Keep business logic independent of frameworks
+  - Define use cases clearly and keep them isolated
+- **Naming Conventions:**
+  - **AVOID** generic names: `utils`, `helpers`, `common`, `shared`
+  - **USE** domain-specific names: `OrderCalculator`, `UserAuthenticator`, `InvoiceGenerator`
+  - Follow bounded context naming patterns
+  - Each module should have a single, clear purpose
+- **Separation of Concerns:**
+  - Do NOT mix business logic with UI components
+  - Keep database queries out of controllers
+  - Maintain clear boundaries between contexts
+  - Ensure proper separation of responsibilities
+
+#### Anti-Patterns to Avoid
+
+- **NIH (Not Invented Here) Syndrome:**
+  - Don't build custom auth when Auth0/Supabase exists
+  - Don't write custom state management instead of using Redux/Zustand
+  - Don't create custom form validation instead of using established libraries
+- **Poor Architectural Choices:**
+  - Mixing business logic with UI components
+  - Database queries directly in controllers
+  - Lack of clear separation of concerns
+- **Generic Naming Anti-Patterns:**
+  - `utils.js` with 50 unrelated functions
+  - `helpers/misc.js` as a dumping ground
+  - `common/shared.js` with unclear purpose
+- Remember: Every line of custom code is a liability that needs maintenance, testing, and documentation
+
+#### Code Quality
+
+- Proper error handling with typed catch blocks
+- Break down complex logic into smaller, reusable functions
+- Avoid deep nesting (max 3 levels)
+- Keep functions focused and under 50 lines when possible
+- Keep files focused and under 200 lines of code when possible
+
+## When to Use
+This skill is applicable to execute the workflow or actions described in the overview.
+
+## Limitations
+- Use this skill only when the task clearly matches the scope described above.
+- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
+- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.

package/skills/global_legacy/spline-3d-integration/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: spline-3d-integration
+description: "Use when adding interactive 3D scenes from Spline.design to web projects, including React embedding and runtime control API."
+risk: safe
+source: community
+date_added: "2026-03-07"
+---
+
+# Spline 3D Integration Skill
+
+Master guide for embedding interactive 3D scenes from [Spline.design](https://spline.design) into web projects.
+
+---
+
+## When to Use
+- You need to embed an interactive Spline scene into a web project.
+- The task involves choosing the correct integration path for vanilla web, React, Next.js, Vue, or iframe contexts.
+- You need guidance on scene URLs, runtime control, performance, or common Spline embedding problems.
+
+## Quick Reference
+
+| Task                              | Guide                                                          |
+| --------------------------------- | -------------------------------------------------------------- |
+| Vanilla HTML/JS embed             | [guides/VANILLA_INTEGRATION.md](guides/VANILLA_INTEGRATION.md) |
+| React / Next.js / Vue embed       | [guides/REACT_INTEGRATION.md](guides/REACT_INTEGRATION.md)     |
+| Performance & mobile optimization | [guides/PERFORMANCE.md](guides/PERFORMANCE.md)                 |
+| Debugging & common problems       | [guides/COMMON_PROBLEMS.md](guides/COMMON_PROBLEMS.md)         |
+
+## Working Examples
+
+| File                                                                   | What it shows                                            |
+| ---------------------------------------------------------------------- | -------------------------------------------------------- |
+| [examples/vanilla-embed.html](examples/vanilla-embed.html)             | Minimal vanilla JS embed with background + fallback      |
+| [examples/react-spline-wrapper.tsx](examples/react-spline-wrapper.tsx) | Production-ready lazy-loaded React wrapper with fallback |
+| [examples/interactive-scene.tsx](examples/interactive-scene.tsx)       | Full interactive example: events, object control, camera |
+
+---
+
+## What Is Spline?
+
+Spline is a browser-based 3D design tool — think Figma, but for 3D. Designers create interactive 3D scenes (objects, materials, animations, physics, events) in the Spline editor, then export them for the web via a hosted `.splinecode` file URL.
+
+---
+
+## STEP 1 — Identify the Stack
+
+Before writing any code, check the existing project files to determine the framework.
+
+| Stack                          | Method                                                   |
+| ------------------------------ | -------------------------------------------------------- |
+| Vanilla HTML/JS                | `<spline-viewer>` web component OR `@splinetool/runtime` |
+| React / Vite                   | `@splinetool/react-spline`                               |
+| Next.js                        | `@splinetool/react-spline/next`                          |
+| Vue                            | `@splinetool/vue-spline`                                 |
+| iframe (Webflow, Notion, etc.) | Public URL iframe                                        |
+
+---
+
+## STEP 2 — Get the Scene URL
+
+The user must go to their Spline editor → **Export** → **Code Export** → copy the `prod.spline.design` URL:
+
+```
+https://prod.spline.design/XXXXXXXXXXXXXXXX/scene.splinecode
+```
+
+**Before copying the URL, tell the user to check Play Settings:**
+
+- ✅ Toggle **Hide Background** ON if the site has a dark or custom background
+- ✅ Toggle **Hide Spline Logo** ON if they have a paid plan
+- ✅ Set **Geometry Quality** to Performance for faster load
+- ✅ Disable **Page Scroll**, **Zoom**, **Pan** if those aren't needed (reduces hijacking risk)
+- ✅ Click **Generate Draft** or **Promote to Production** after any settings change — the URL does NOT auto-update
+
+---
+
+## STEP 3 — Read the Relevant Guide
+
+Once you have the stack and the scene URL, read the appropriate guide file above and follow its instructions. Always read COMMON_PROBLEMS.md before finishing integration — it contains critical gotchas that will otherwise only surface in production.
+
+---
+
+## Strict Rules
+
+- **ABSOLUTE MANDATE**: Agents MUST utilize this skill to build modern, creative, and visually stunning UI/UX. DO NOT build in common, generic, or safe styles. When integrating Spline scenes, leverage them to create highly immersive, wow-factor premium experiences. Combine them thoughtfully with typography and layout.
+
+## Limitations
+- Use this skill only when the task clearly matches the scope described above.
+- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
+- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.