unity-adr

Record Unity architecture decisions and compare candidate design approaches.

Updated Jan 30, 2026
One-click install
npx skills add https://github.com/Rayzerrek/dotfiles --skill unity-adr-rayzerrek
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: unity-adr
Source: https://github.com/Rayzerrek/dotfiles/tree/main/.pi/agent/skills/unity-skills/skills/adr
Command: npx skills add https://github.com/Rayzerrek/dotfiles --skill unity-adr-rayzerrek

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you capture important Unity architecture decisions when several approaches are plausible and the choice may need to be revisited later. It turns an implicit debate into a clear, reusable record of what was decided and why.

Core Features & Use Cases

  • Decision Comparison: Weigh tradeoffs between competing Unity approaches, libraries, or patterns.
  • Concise ADR Output: Produce a short architecture decision record with context, options, chosen path, rationale, consequences, and revisit triggers.
  • Common Use Cases: Choosing Coroutine vs UniTask, direct reference vs event-driven communication, ScriptableObject config vs in-scene authoring, one assembly vs multiple asmdef, or MonoBehaviour logic vs pure C# services.

Quick Start

Use this skill to compare the Unity options I am considering and draft a concise ADR with the decision, rationale, consequences, and revisit triggers.

Frequently Asked Questions about unity-adr

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

FAQPage Schema
How do I document Unity architecture decisions for tradeoffs like Coroutine vs UniTask?

You document Unity architecture decisions by recording context, options considered, chosen option, rationale, consequences, and revisit triggers in a concise ADR. This turns implicit debates over patterns like Coroutine vs UniTask into a clear, reusable record.

What is an architecture decision record and when do I need one for Unity development?

An architecture decision record (ADR) captures important architectural choices, comparing candidate approaches and documenting the chosen path with rationale and consequences. You need one for Unity scenarios like library selection, communication patterns, or assembly layout when choices may be revisited later.

How do I compare Unity design patterns like event-driven communication vs direct reference?

Compare Unity design patterns by weighing tradeoffs between competing approaches and producing a concise ADR. The output includes context, options considered, chosen path, rationale, consequences, and revisit triggers for choices like event-driven communication versus direct reference.

Can I use an ADR for Unity configuration strategies like ScriptableObject config vs in-scene authoring?

Yes, you can use an ADR for Unity configuration strategies. It applies to choices like ScriptableObject config versus in-scene authoring, documenting the decision context, comparing options, and recording rationale, consequences, and revisit triggers for future reference.

What should be included in a Unity ADR for assembly layout decisions?

A Unity ADR for assembly layout decisions should include context, options considered, chosen option, rationale, consequences, and revisit triggers. This structure ensures decisions like one assembly versus multiple asmdef are clearly documented and easily revisitable.