Unity Architect

Build decoupled Unity architectures using ScriptableObject event channels and runtime sets.

110|18|Updated Mar 25, 2026
One-click install
npx skills add https://github.com/TravisLeeeeee/awesome-openclaw-personas --skill unity-architect-travisleeeeee
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: Unity Architect
Source: https://github.com/TravisLeeeeee/awesome-openclaw-personas/tree/main/personas/game-development/unity-architect
Command: npx skills add https://github.com/TravisLeeeeee/awesome-openclaw-personas --skill unity-architect-travisleeeeee

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps Unity teams eliminate spaghetti architecture by replacing tight scene coupling and singleton-style managers with ScriptableObject-driven, data-first design.

Core Features & Use Cases

  • ScriptableObject event channels & variable containers: decouple systems with GameEvent and variable SOs like FloatVariable for reliable cross-system communication.
  • Singleton-free RuntimeSet tracking: manage active entities via RuntimeSet<T> patterns instead of global state.
  • Designer-friendly editor tooling: add CreateAssetMenu assets and custom PropertyDrawer/Editor utilities so non-programmers can extend workflows safely.
  • Scene & serialization hygiene: enforce rules like no scene-instance references inside SOs and correct EditorUtility.SetDirty usage to prevent Unity serialization surprises.

Quick Start

Use the Unity Architect Skill to implement ScriptableObject event channels and variable SOs in a new or refactored project, then decompose any God MonoBehaviours into single-responsibility components wired through the Inspector.

Frequently Asked Questions about Unity Architect

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I decouple Unity systems without using singletons?

Replace singletons with ScriptableObject event channels and variable containers like FloatVariable for cross-system communication, eliminating tight scene coupling and global state while maintaining modular, data-first architecture.

What is a RuntimeSet in Unity and when should I use it?

A RuntimeSet in Unity is a ScriptableObject-based pattern used to track active entities without relying on global state or singletons. Use RuntimeSet tracking to manage active entities modularly when you need to decouple systems from scene hierarchy dependencies.

How to refactor God MonoBehaviours into single-responsibility components?

To refactor God MonoBehaviours, decompose them into single-responsibility components wired through the Inspector using ScriptableObject-driven design, replacing GameObject.Find calls and God classes with self-contained prefabs and event-channel messaging for clean modular architecture.

Does this Unity architecture approach work for existing projects or only new ones?

This ScriptableObject-first architecture approach works for both refactoring existing Unity projects and creating new systems, applying modular SOP-driven components, reusable runtime sets, and event-channel messaging to eliminate spaghetti architecture regardless of project age.

What are the serialization hygiene rules for Unity ScriptableObjects?

Serialization hygiene rules for Unity ScriptableObjects include avoiding scene-instance references inside SOs and using correct EditorUtility.SetDirty usage, preventing Unity serialization surprises and ensuring reliable data persistence across editor and runtime environments.

Why should I avoid GameObject.Find in Unity architecture?

Avoid GameObject.Find in Unity architecture because it creates tight scene coupling and performance bottlenecks. Replace it with ScriptableObject event channels and RuntimeSet patterns to achieve decoupled, singleton-free systems that scale without hard scene dependencies.