opencode-skills-collection 3.0.7 → 3.0.9

package/bundled-skills/skill-writer/references/description-optimization.md

@@ -0,0 +1,30 @@
+# Description Optimization
+
+The frontmatter `description` is the trigger surface. It should say what the skill does and when to use it.
+
+## Should-trigger set
+
+Write 3 to 6 queries that should load the skill. Confirm the description contains the user's likely nouns and verbs.
+
+Examples:
+
+- "Create a new skill for PDF cleanup."
+- "Update this skill to add a safer validation flow."
+- "Turn these docs into a reusable agent workflow."
+
+## Should-not-trigger set
+
+Write 3 to 6 nearby queries that should not load the skill. Remove vague words that over-trigger.
+
+Examples:
+
+- "Explain what skills are at a high level."
+- "Install an existing skill."
+- "Run a one-off command that does not need a reusable workflow."
+
+## Precision rules
+
+- Put domain, artifact, and action words in the first sentence.
+- Avoid generic descriptions like "helps with productivity."
+- Include major variants only if the skill really supports them.
+- Keep the description compact enough to scan.

package/bundled-skills/skill-writer/references/design-principles.md

@@ -0,0 +1,26 @@
+# Design Principles
+
+## Write for agent behavior
+
+- Use imperative instructions that tell the agent what to do.
+- Put trigger language in the frontmatter description, not only in the body.
+- Keep SKILL.md as a navigation layer when the skill has many modes.
+- Put optional depth, examples, rubrics, and tool-specific details in references.
+
+## Keep the context budget healthy
+
+- Prefer checklists, tables, and short decision rules over long essays.
+- Do not duplicate the same rule in SKILL.md and references unless it is a safety-critical reminder.
+- Include only files the agent may actually load during work.
+
+## Balance depth and concision
+
+- Add detail where mistakes are costly, repeated, or hard to detect.
+- Compress detail where the model already has general knowledge.
+- Make every required artifact explicit: files, commands, reports, comments, commits, or validation outputs.
+
+## Safety and provenance
+
+- Label risky, destructive, credential-handling, financial, medical, legal, or security guidance clearly.
+- Preserve source provenance when adapting external content.
+- Prefer safe commands and explicit prerequisites over remote execution shortcuts.

package/bundled-skills/skill-writer/references/evaluation-path.md

@@ -0,0 +1,28 @@
+# Evaluation Path
+
+Use evaluation to decide whether the skill actually changes agent behavior.
+
+## Lightweight qualitative check
+
+Run this by default:
+
+1. Read the skill as an agent would.
+2. Simulate one realistic task.
+3. Confirm the output contract is clear.
+4. Check that validation is possible.
+5. List residual gaps.
+
+## Depth rubric
+
+Score each dimension as pass, partial, or fail:
+
+- Trigger precision.
+- Workflow completeness.
+- Safety and permission boundaries.
+- Output determinism.
+- Validation strength.
+- Progressive disclosure.
+
+## Baseline comparison
+
+Only run a deeper baseline-vs-with-skill comparison when requested or when risk is high. Use the same task, same inputs, and a holdout case that was not used while editing.

package/bundled-skills/skill-writer/references/examples/workflow-process.md

@@ -0,0 +1,27 @@
+# Example: Workflow Process Skill
+
+Use this shape when a task needs a predictable sequence and a clear closeout.
+
+## Trigger
+
+Use when the user asks to run a repeatable maintenance, release, audit, or conversion process.
+
+## Skeleton
+
+```markdown
+# Example Workflow Skill
+
+Resolve scope, inspect source files, execute the ordered workflow, validate results, and report changed artifacts.
+
+## Workflow
+
+1. Inspect local instructions and inputs.
+2. Select the smallest matching path.
+3. Make scoped changes.
+4. Run required checks.
+5. Report results and gaps.
+
+## Output
+
+Return summary, files changed, validation, and remaining risks.
+```

package/bundled-skills/skill-writer/references/iteration-path.md

@@ -0,0 +1,28 @@
+# Iteration Path
+
+Use this path when improving a skill from outcomes, traces, examples, or user feedback.
+
+## Gather examples
+
+Collect:
+
+- Positive examples where the skill helped.
+- Negative examples where it misfired.
+- Fix examples showing the desired behavior.
+- Any validation output or user correction.
+
+Remove secrets and unrelated personal data before storing examples.
+
+## Diagnose
+
+For each example, identify whether the problem is:
+
+- Triggering: skill loaded too often or not often enough.
+- Routing: wrong reference or workflow branch.
+- Instruction gap: missing step, safety rule, or output requirement.
+- Validation gap: no check caught the failure.
+- Overload: too much context or too many steps.
+
+## Patch
+
+Make the smallest instruction change that would have changed the outcome. Retest against at least one positive and one negative example when feasible.

package/bundled-skills/skill-writer/references/mode-selection.md

@@ -0,0 +1,35 @@
+# Mode Selection
+
+Use this file first. Pick the smallest path that can satisfy the user's request.
+
+## Skill classes
+
+- `workflow-process`: repeatable multi-step work where sequencing, checkpoints, and outputs matter.
+- `integration-documentation`: using a specific API, CLI, SDK, file format, or platform.
+- `security-review`: finding, validating, or fixing safety and security issues.
+- `skill-authoring`: creating or improving skills, generators, templates, or skill documentation.
+- `generic`: broad guidance where no specialized pattern fits.
+
+## Operation modes
+
+- `create`: new skill folder or new supporting files.
+- `update`: revise an existing skill without changing its core purpose.
+- `synthesize`: build a skill from external docs, local files, examples, or multiple sources.
+- `iterate`: improve a skill from observed outcomes, user feedback, traces, or examples.
+
+## Required paths
+
+| Mode | Read next |
+|------|-----------|
+| `create` | `authoring-path.md`, then `description-optimization.md` |
+| `update` | `authoring-path.md`, then `registration-validation.md` |
+| `synthesize` | `synthesis-path.md`, then `authoring-path.md` |
+| `iterate` | `iteration-path.md`, then `authoring-path.md` |
+
+For hybrid work, run the paths in this order: `synthesize`, `iterate`, `authoring`, `evaluation`, `registration`.
+
+## Depth decision
+
+- Use a lightweight pass for small copy, metadata, or reference repairs.
+- Use a full synthesis pass when the skill depends on external behavior, tools, safety rules, or examples.
+- Ask one concise clarification only when target audience, tool surface, or safety boundary is unknown and cannot be inferred.

package/bundled-skills/skill-writer/references/output-patterns.md

@@ -0,0 +1,34 @@
+# Output Patterns
+
+## Standard implementation closeout
+
+Return:
+
+1. Summary.
+2. Files changed.
+3. Validation performed.
+4. Open gaps or risks.
+
+## Review findings
+
+Return findings first, ordered by severity:
+
+- File and line.
+- Impact.
+- Suggested fix.
+
+Then include open questions and a brief summary.
+
+## Skill authoring report
+
+Return:
+
+1. Skill purpose and trigger.
+2. Structure chosen.
+3. References or scripts added.
+4. Validation result.
+5. Known limitations.
+
+## Deterministic artifacts
+
+When the user expects a file, deck, spreadsheet, script, or release, produce the artifact and report where it is. Do not replace the artifact with advice.

package/bundled-skills/skill-writer/references/registration-validation.md

@@ -0,0 +1,33 @@
+# Registration And Validation
+
+Use this path after skill edits.
+
+## Repository checks
+
+Run the checks required by the repository. In this project, skill changes normally require:
+
+```bash
+npm run chain
+npm run catalog
+```
+
+Use stricter or specialized checks when the changed skill includes risky commands, external references, generated artifacts, or package/runtime behavior.
+
+## Artifact checks
+
+Confirm:
+
+- `SKILL.md` frontmatter parses.
+- Referenced files exist.
+- Generated registry files are synced when the repository owns them on `main`.
+- Credits and provenance are present when external sources are used.
+- The final response reports validation honestly.
+
+## Reject conditions
+
+Do not mark the work complete if:
+
+- Required references are missing.
+- The skill cannot be followed without hidden context.
+- A risky instruction lacks prerequisites.
+- Validation failed and the failure is not explicitly accepted by the user.

package/bundled-skills/skill-writer/references/skill-patterns.md

@@ -0,0 +1,50 @@
+# Skill Patterns
+
+## Minimal workflow skill
+
+Use for narrow repeatable work.
+
+Structure:
+
+1. Purpose and trigger.
+2. Inputs to collect.
+3. Ordered steps.
+4. Output contract.
+5. Validation.
+6. Limitations.
+
+## Navigation skill with references
+
+Use when the skill covers several modes, tools, or depth levels.
+
+Structure:
+
+1. Short SKILL.md with a routing table.
+2. One reference per mode or domain.
+3. Examples in `references/examples/`.
+4. Scripts only for deterministic repeated actions.
+
+## Integration skill
+
+Use for CLIs, APIs, SDKs, or platforms.
+
+Include:
+
+- Installation or environment assumptions.
+- Authentication and permission boundaries.
+- Safe command patterns.
+- Common failure signatures.
+- Verification commands.
+
+## Review or audit skill
+
+Use for code, security, docs, or quality reviews.
+
+Include:
+
+- Scope definition.
+- Evidence collection.
+- Severity or priority scale.
+- Finding format.
+- False-positive handling.
+- Verification and residual risk.

package/bundled-skills/skill-writer/references/synthesis-path.md

@@ -0,0 +1,31 @@
+# Synthesis Path
+
+Use this path when a skill depends on external docs, existing local files, prior examples, or multiple sources.
+
+## Source collection
+
+1. Identify local source files first.
+2. Use primary sources for tools, APIs, standards, and current behavior.
+3. Record source names or URLs when adapting material.
+4. Separate facts from assumptions.
+
+## Coverage checks
+
+Confirm the skill covers:
+
+- When to use and when not to use it.
+- Required inputs and permissions.
+- Main workflow.
+- Expected outputs.
+- Validation commands or checks.
+- Common failure modes.
+- Safety boundaries.
+
+## Depth gates
+
+Do not move to authoring until:
+
+- The core task can be executed from the skill alone.
+- Risky or irreversible actions have prerequisites.
+- External sources are credited when required.
+- Missing information is either resolved or listed as an explicit assumption.

package/bundled-skills/skill-writer/references/workflow-patterns.md

@@ -0,0 +1,36 @@
+# Workflow Patterns
+
+## Linear workflow
+
+Use when each step depends on the previous step.
+
+Pattern: inspect -> decide -> implement -> validate -> report.
+
+## Branching workflow
+
+Use when task type changes the next steps.
+
+Pattern:
+
+1. Classify the task.
+2. Select the matching branch.
+3. Run only branch-specific references.
+4. Rejoin at validation.
+
+## Evidence-first workflow
+
+Use when correctness depends on files, logs, sources, or user-provided examples.
+
+Pattern: collect evidence -> summarize constraints -> make the smallest effective change -> verify against evidence.
+
+## Iterative workflow
+
+Use when outputs improve through examples or feedback.
+
+Pattern: gather examples -> identify deltas -> patch instructions -> test against holdout cases -> record remaining gaps.
+
+## Release or publishing workflow
+
+Use when the skill must produce public artifacts.
+
+Pattern: preflight -> changelog or notes -> version/tag/release -> publish -> close linked work.

package/bundled-skills/unity-ai-game-creator/SKILL.md

@@ -0,0 +1,299 @@
+---
+name: unity-ai-game-creator
+description: "Transform raw game ideas into complete Unity projects with AI-powered asset generation, scene blueprints, music/SFX prompts, and step-by-step development procedures using Unity 6+ and modern AI tools."
+category: game-development
+risk: safe
+source: community
+source_type: community
+date_added: "2026-05-08"
+author: Mann-Makhecha
+tags: [unity, game-development, ai-generation, asset-pipeline, scene-design, music-generation, game-design-document]
+tools: [claude, cursor, gemini, codex, antigravity]
+---
+
+# Unity AI Game Creator
+
+## Overview
+
+This skill transforms a raw game concept into a fully structured Unity development plan with AI-generated assets, scenes, music, scripts, and deployment-ready builds. It guides the agent through a 5-phase pipeline — from extracting core game dimensions to producing ready-to-use AI prompts for every asset category — using the latest Unity 6+ features and AI tooling ecosystem. Unlike generic Unity reference skills, this skill is workflow-driven: the user provides an idea, and the agent delivers a complete, actionable game development roadmap.
+
+## When to Use This Skill
+
+- Use when a user describes a game idea and wants a complete development plan
+- Use when generating AI prompts for 3D models, textures, music, sound effects, or UI assets
+- Use when setting up a new Unity project from scratch with modern architecture
+- Use when creating Scene Blueprints from a concept description
+- Use when building a Game Design Document (GDD) from a rough idea
+- Use when leveraging Unity AI Assistant, MCP server, or external AI tools in a game workflow
+- Use when planning monetization, performance budgets, or app store deployment
+
+## How It Works
+
+### Master Pipeline
+
+Execute these phases in order. Each phase produces concrete deliverables before advancing.
+
+```
+PHASE 1: IDEATION ──▶ PHASE 2: BLUEPRINT ──▶ PHASE 3: GENERATION ──▶ PHASE 4: ASSEMBLY ──▶ PHASE 5: DEPLOYMENT
+  Game Brief            GDD + Scenes           AI Prompts + Assets     Project Setup          Build + Store
+  Genre Analysis        Architecture           Scripts + Audio         Core Systems           QA + Submit
+  Scope Assessment      Scene Blueprints       Voice + UI              Polish + Juice         Analytics
+```
+
+### Phase 1: Ideation & Deep Analysis
+
+Extract and clarify these dimensions from the user's game idea. Ask only for what is ambiguous — infer the rest from context.
+
+| Dimension | What to Extract | If Unclear |
+|-----------|----------------|------------|
+| **Genre** | Primary + secondary genre blend | Suggest 3 genre combinations |
+| **Platform** | Mobile, PC, Console, WebGL, VR/AR | Recommend based on scope |
+| **Perspective** | 2D, 2.5D, 3D, Top-down, Side-scroll, FPS, TPS | Infer from genre |
+| **Art Style** | Realistic, Stylized, Pixel, Low-poly, Anime, Painterly | Suggest 3 options |
+| **Core Loop** | The 30-second repeating gameplay action | Identify from description |
+| **Target Audience** | Age range, gamer profile, platform habits | Recommend based on genre |
+| **Session Length** | Average play session duration | Infer from platform + genre |
+| **Monetization** | Free-to-play, Premium, Hybrid | Recommend based on platform |
+| **Scope** | Solo dev, small team, studio | Ask if not obvious |
+| **Timeline** | MVP in weeks, full release target | Suggest realistic milestones |
+
+**Also provide:**
+1. **Top 3 Reference Games** — What they do well, what the user can learn
+2. **Market Gap** — What opportunity exists that competitors miss
+3. **Core Differentiator** — The one unique thing about this game
+4. **Risk Assessment** — Technical and market risks with mitigations
+
+**Scope Calibration:**
+
+| Scope | Timeline | Team Size | Feature Budget |
+|-------|----------|-----------|----------------|
+| Prototype | 1–2 weeks | Solo | Core loop only |
+| Vertical Slice | 4–6 weeks | Solo–2 | 1 complete level + polish |
+| MVP | 8–12 weeks | 2–4 | 3–5 levels + save + UI |
+| Full Release | 16–24+ weeks | 3–8 | Complete content + multiplayer |
+
+### Phase 2: Blueprint & Design
+
+#### Game Design Document (GDD)
+
+Generate a structured GDD covering:
+
+1. **Executive Summary** — Elevator pitch, genre, USPs
+2. **Gameplay** — Core loop diagram, progression, abilities, win/loss, difficulty curve
+3. **World & Narrative** — Setting, characters, level structure
+4. **Art Direction** — Visual style, color palette (hex codes), reference descriptions, UI/UX style
+5. **Audio Direction** — Music style per scene, SFX categories, voice needs
+6. **Technical Spec** — Unity version, render pipeline, performance budgets, SDKs
+7. **Monetization Strategy** — Revenue model, IAP design, ad placement
+8. **Development Roadmap** — Phases, milestones, feature priority matrix, risk register
+
+#### Scene Blueprints
+
+For each scene, produce a hierarchy covering:
+
+- **Environment** — Ground/terrain, skybox, lighting setup, props with positions
+- **Interactive Objects** — Behavior on interaction
+- **Characters / NPCs** — AI behavior, patrol paths, dialogue triggers
+- **UI Overlay** — HUD elements, contextual prompts
+- **Audio Layers** — Background music (mood, tempo, loop point), ambient SFX, trigger SFX
+- **Camera Setup** — Type (Cinemachine/Fixed/Follow), behavior configuration
+- **Systems Active** — Save checkpoints, spawners, particle effects
+
+#### Architecture Blueprint
+
+Provide recommended project folder structure:
+
+```
+Assets/_Project/
+├── Scripts/ (Core, Gameplay, UI, Data, Audio, Utilities)
+├── Prefabs/ (Characters, Environment, UI, VFX)
+├── Scenes/
+├── Art/ (Models, Textures, Materials, Animations, UI_Assets)
+├── Audio/ (Music, SFX, Ambience)
+├── ScriptableObjects/
+└── Resources/
+```
+
+### Phase 3: AI-Powered Asset Generation
+
+For every asset category, provide ready-to-use prompts for the best current AI tools.
+
+#### 3D Model Prompts
+
+Recommend tools dynamically (Meshy.ai, Tripo3D, Rodin, Unity AI Assistant) and generate prompts including:
+- Asset name, art style, gameplay purpose
+- Polygon budget, texture resolution, PBR maps needed
+- Animation-ready flag, scale reference
+- Unity import settings (scale factor, normals, animation type, material handling)
+
+#### Texture & 2D Asset Prompts
+
+Recommend tools (Leonardo.ai, Midjourney, DALL·E, Unity AI Assistant) and generate prompts including:
+- Texture type (seamless tile, sprite, UI element, concept art)
+- Resolution, style, tiling requirements, PBR maps
+- Unity import settings (texture type, filter mode, compression, max size)
+
+#### Music Prompts
+
+Recommend tools (Suno, Soundraw, Sonauto) and generate prompts including:
+- Track name, scene context, mood, tempo (BPM), duration
+- Instruments, reference tracks, loop points, dynamic layers
+- Unity import settings (format, load type, compression, loop config)
+
+#### Sound Effects Prompts
+
+Recommend tools (ElevenLabs, OptimizerAI/SFX Engine) and generate prompts including:
+- SFX name, category, gameplay context, duration
+- Variation count, characteristics
+- Unity import settings (format, load type, 3D sound config, variation arrays)
+
+#### Voice & Narration Prompts
+
+Recommend tools (ElevenLabs, Play.ht, Coqui) and generate prompts including:
+- Character name, voice profile, dialogue line, emotion, context
+
+#### UI/UX Asset Prompts
+
+Generate specifications for Unity UI Toolkit or AI image generation including:
+- Element name, screen context, visual style
+- States (normal, hover, pressed, disabled)
+- Dimensions, anchor behavior, animation descriptions
+
+### Phase 4: Assembly & Development
+
+#### Project Initialization Checklist
+
+- Unity version (recommend latest Unity 6 LTS)
+- Render pipeline (URP for mobile/stylized, HDRP for high-fidelity, Built-in for 2D)
+- Build settings, player settings (color space, scripting backend, API compatibility)
+- Essential packages (Input System, Cinemachine, TextMeshPro, Addressables, Unity AI Assistant)
+- Git LFS configuration for large assets
+
+#### Development Order (Week-by-Week)
+
+1. **Foundation** — Project setup, GameManager, event system, scene management, input config
+2. **Core Gameplay** — Player controller, camera, core loop, basic enemies
+3. **Content & Systems** — Level building, UI system, audio manager, save/load
+4. **Polish & Feedback** — VFX/juice, progression, tutorial, settings
+5. **Platform & Release** — Profiling, monetization, analytics, platform polish, submission
+
+#### Script Architecture Patterns
+
+- GameManager → Singleton or Service Locator
+- Events → Observer Pattern (C# events + ScriptableObject Events)
+- Save System → JSON serialization + encryption
+- Object Pooling → Generic pool for bullets, enemies, VFX
+- State Machine → Player states, game states, enemy AI
+- Audio → Singleton with Audio Mixer Groups
+- UI → UI Toolkit with MVVM or event binding
+- Scene Loading → Addressables + async with progress
+- Input → New Input System with Action Maps
+
+#### Unity AI Assistant & MCP Integration
+
+- Setup steps for Unity AI Assistant (Unity 6.3+)
+- MCP server configuration for external IDE/agent control
+- Example in-editor prompts for scene manipulation, scripting, profiling
+
+### Phase 5: Quality & Deployment
+
+#### Performance Budgets
+
+|                    | Mobile    | PC        | Console   |
+|--------------------|-----------|-----------|-----------|
+| Target FPS         | 30/60     | 60/120    | 60        |
+| Draw Calls         | < 100     | < 500     | < 300     |
+| Triangles/frame    | < 100K    | < 2M      | < 1M      |
+| Texture Memory     | < 150MB   | < 1GB     | < 512MB   |
+| Build Size         | < 150MB   | < 2GB     | < 4GB     |
+
+#### Testing Checklist
+
+Core loop stability, UI responsiveness, save/load persistence, audio balance, memory leak checks, frame rate stability, input device coverage, edge cases (low battery, interruptions), accessibility, localization.
+
+#### Store Submission Guide
+
+App icon, feature graphic, screenshots, promotional video, descriptions, keywords, privacy policy, age rating, content rating — with AI prompts for generating marketing assets.
+
+## Examples
+
+### Example 1: Cozy Farming Game
+
+**User:** "I want to make a cozy farming game with magic elements for mobile"
+
+**Agent delivers:**
+1. **Game Brief** — Cozy farm sim × magical creatures, mobile portrait, stylized low-poly, 5-min sessions, F2P with cosmetic IAP
+2. **3 Reference Games** — Stardew Valley (loop), Merge Magic (mobile UX), Moonstone Island (magic farm blend)
+3. **Core Loop** — Plant → Tend → Harvest → Sell → Upgrade → Discover magical seeds
+4. **Scene Blueprints** — Farm (main), Village Market, Enchanted Forest, Player Home
+5. **AI Asset Kit** — 15 crop models, 8 building models, 5 character models, seasonal music tracks, ambient farm SFX, UI kit
+6. **Technical Plan** — Unity 6 LTS + URP, mobile-first 30fps, addressable assets for seasonal updates
+7. **6-Week Roadmap** — Foundation → Core Gameplay → Content → Monetization → Polish → Soft Launch
+
+### Example 2: Multiplayer Shooter
+
+**User:** "Make a fast-paced arena shooter for PC with neon visuals"
+
+**Agent delivers:**
+1. **Game Brief** — Arena FPS, PC/Steam, stylized neon cyberpunk, 10-min matches, Premium $9.99
+2. **Core Loop** — Spawn → Loot → Fight → Eliminate → Score → Respawn
+3. **Technical Plan** — Unity 6 + HDRP, Netcode for GameObjects, dedicated servers, 120fps target
+4. **AI Asset Kit** — Arena models, weapon models, neon material/shader prompts, electronic music tracks, weapon SFX
+
+### Example 3: 2D Puzzle Mobile
+
+**User:** "Simple puzzle game like Wordle but with colors"
+
+**Agent delivers:**
+1. **Game Brief** — Casual puzzle, mobile portrait, flat minimalist, 2-min sessions, F2P with rewarded ads
+2. **Scope** — Prototype in 1 week, MVP in 3 weeks
+3. **Scene Blueprints** — Main Menu, Game Board, Results Screen, Daily Challenge
+4. **AI Asset Kit** — UI sprites, celebration particles, calm ambient music, tap/swipe SFX
+
+## Best Practices
+
+- ✅ **Start with the core loop** — Nail the 30-second cycle before anything else
+- ✅ **Profile before optimizing** — Use Unity Profiler to find real bottlenecks
+- ✅ **Use ScriptableObjects for data** — Decouple data from logic for flexibility
+- ✅ **Generate multiple AI asset variations** — Pick the best from 3–5 generations
+- ✅ **Test on real devices early** — Emulators miss platform-specific issues
+- ✅ **Version control from day one** — Git + LFS, commit often
+- ❌ **Don't hardcode tool choices** — Always present alternatives to the user
+- ❌ **Don't skip the GDD** — Even solo projects benefit from written design
+- ❌ **Don't optimize prematurely** — Make it work, make it right, make it fast
+- ❌ **Don't ship AI assets without review** — Check licensing terms for each tool
+
+## Limitations
+
+- This skill does not replace environment-specific validation, testing, or expert review.
+- AI-generated assets require legal review for commercial usage rights per each tool's Terms of Service.
+- Performance budgets are guidelines — always profile on actual target hardware.
+- AI tools and their capabilities evolve rapidly — verify current availability and pricing before recommending.
+- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.
+
+## Security & Safety Notes
+
+- This skill does not include shell commands, network fetches, or credential handling.
+- All AI tool recommendations are external services; the skill does not execute API calls or store tokens.
+- Asset generation prompts are text-only guidance — no automated downloads or file mutations occur.
+
+## Common Pitfalls
+
+- **Problem:** User provides a vague idea like "make a game"
+  **Solution:** Ask 2–3 targeted questions (genre, platform, scope) before generating the first draft
+
+- **Problem:** Scope creep — trying to build everything at once
+  **Solution:** Use the scope calibration table and feature priority matrix (Must/Should/Could/Won't)
+
+- **Problem:** AI-generated assets don't match the art style
+  **Solution:** Always include the GDD's art direction keywords in every asset prompt for consistency
+
+- **Problem:** Performance issues on target platform
+  **Solution:** Set platform-specific budgets early and profile against them weekly
+
+## Related Skills
+
+- `@unity-developer` - For deep Unity technical reference without the idea-to-game pipeline
+- `@game-development` - For the game development orchestrator that routes to platform-specific skills
+- `@unity-ecs-patterns` - For Entity Component System architecture patterns specifically
+- `@bevy-ecs-expert` - When building with Bevy/Rust instead of Unity

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-skills-collection",
-  "version": "3.0.7",
+  "version": "3.0.9",
   "description": "OpenCode CLI plugin that automatically downloads and keeps skills up to date.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",