agentleFS
TheArcForgeTheArcForge/hades-plugin/skills/unity-workflow/SKILL.md

unity-workflow

Skill3 starsChanged 3 months agoMITView on GitHub

Use when designing or building Unity features and a structured workflow is needed. Provides a research-design-implement-verify process that leverages Hades Graph and memory for project-aware development.

The file

Show its rules and text

We split this skill into the rules it gives an agent

14 rules. About 0 are common, 10 are distinctive, and 4 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈10

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 4

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    When starting any non-trivial Unity feature (new system, new component type, cross-scene work)

    line 13
  2. Distinctive:

    When the feature touches multiple existing systems and you need to understand impact before designing

    line 14
  3. Very specific:

    When superpowers:brainstorming is not available — this skill provides the same structure for Unity-specific work

    line 15
  4. Distinctive:

    Before doing anything, understand the scope.

    line 30
  5. Distinctive:

    Ask clarifying questions until there is no ambiguity.

    line 53
  6. Distinctive:

    If multiple systems are involved, describe the data flow between them.

    line 63
  7. Distinctive:

    Call out tradeoffs explicitly — what you gain and what you give up with this approach.

    line 64
  8. Distinctive:

    Do not begin implementation until the user confirms the design.

    line 69
  9. Distinctive:

    Write C# scripts using standard file editing tools.

    line 78
  10. Very specific:

    Use Awaitable.MainThreadAsync() to marshal async work back to the main thread.

    line 92
  11. Very specific:

    Prefer Physics.RaycastNonAlloc over RaycastAll for hot paths.

    line 93
  12. Very specific:

    Use [SerializeField] private fields instead of public fields for Inspector exposure.

    line 94
  13. Distinctive:

    After implementation, confirm the work is correct before reporting completion.

    line 101
  14. Distinctive:

    If the feature established a new convention or pattern, record it:

    line 113

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Unity Development Workflow

A design-first process for building Unity features with Hades Graph and memory. Follow all four phases in order. Do not skip phases — tasks that seem simple often reveal hidden complexity once the project context is loaded.

This is a process skill. It defines how to approach Unity work, not what specific patterns to use. Load domain skills (hades:unity-architect, hades:scene-authoring, etc.) during the relevant phases for decision frameworks and tool sequences.

When to Apply

  • When starting any non-trivial Unity feature (new system, new component type, cross-scene work)
  • When the feature touches multiple existing systems and you need to understand impact before designing
  • When superpowers:brainstorming is not available — this skill provides the same structure for Unity-specific work

Project Context Check

Used during Phase 1 (Analyze). Run these before designing anything:

get_project_summary()                    — understand overall project structure
recall_memory("<feature_domain>")        — find relevant prior decisions and patterns

Decision Framework

Phase 1: Analyze

Before doing anything, understand the scope.

Use Hades Graph tools to explore the project:

get_project_summary()          — overall structure: scenes, assemblies, major systems
get_scene_summary("<scene>")   — current scene hierarchy and component counts
search_by_name("<keyword>")    — find existing scripts, prefabs, or assets by name
graph_query(edgeKind: "references", edgeTargetNamePattern: "<pattern>", edgeTargetKind: "Class")  — find where a pattern is already in use

Use memory to find prior decisions:

recall_memory("<feature_domain>")   — e.g., "inventory", "audio", "player movement"

Questions to answer before proceeding:

  • What is the user building? Name the feature in one sentence.
  • What existing systems does it touch? What scripts and prefabs are already relevant?
  • Are there prior decisions in memory that constrain the design?
  • What are the unknowns? Identify anything ambiguous in the request.
  • Does this need persistence, networking, or live configuration?
  • What is the performance profile? (spawned frequently? rendered every frame? loaded once?)

Ask clarifying questions until there is no ambiguity. Do not proceed with assumptions.


Phase 2: Design

Present the architectural approach before building anything.

  • State which pattern you will use and why (prefab vs variant, ScriptableObject vs MonoBehaviour, pool vs instantiate, component vs system).
  • Identify the files you will create and the files you will modify.
  • If multiple systems are involved, describe the data flow between them.
  • Call out tradeoffs explicitly — what you gain and what you give up with this approach.
  • Reference hades:unity-architect for detailed decision frameworks on architecture choices.

Get explicit user approval before proceeding to Phase 3.

Do not begin implementation until the user confirms the design. If feedback arrives that changes the scope, return to Phase 1.


Phase 3: Implement

Execute the approved design.

Writing code:

  • Write C# scripts using standard file editing tools.
  • C# scripts handle runtime behavior: component logic, state machines, event handling, physics.
  • Editor scripts (under Editor/ folders) handle asset setup, custom inspectors, and build tooling.
  • State what you are creating at each step. Do not work silently.

Referencing workflow skills:

  • For scene construction: hades:scene-authoring
  • For prefab creation and editing: hades:prefab-workflow
  • For animation controller setup: hades:animation-workflow
  • For designer-facing data (item configs, event channels, runtime sets): hades:data-modeling — use scriptable_object_apply to create/configure the actual asset instances, not hand-written .asset YAML.

These skills provide efficient tool sequences and ordering for their respective workflows. Load them when the relevant work begins.

Unity 6+ conventions:

  • Use Awaitable.MainThreadAsync() to marshal async work back to the main thread.
  • Prefer Physics.RaycastNonAlloc over RaycastAll for hot paths.
  • Use [SerializeField] private fields instead of public fields for Inspector exposure.
  • Cache GetComponent results in Awake, never in Update.

Phase 4: Verify

After implementation, confirm the work is correct before reporting completion.

Code review:

  • Load hades:unity-reviewer and run through its checklist on all modified C# files.
  • At minimum, manually check: missing event unsubscriptions, Unity fake null (?./??), and GetComponent in Update.

Graph-backed impact check:

find_references_to("<modified_script>")   — confirm no unexpected dependents are broken

Memory update:

  • If the feature established a new convention or pattern, record it:
propose_memory_update("<domain>", "<what was decided and why>")

Report:

  • State what was built and where.
  • Note any work the user needs to handle manually (scene wiring, Inspector assignments, asset configuration).
  • Note any follow-up tasks deferred from this session.

Anti-Examples

  • Jumping straight to implementation without running get_project_summary or recall_memory — produces designs that duplicate existing systems or contradict prior decisions.
  • Asking no clarifying questions when the request is ambiguous — produces implementations that solve the wrong problem.
  • Presenting a design and immediately starting implementation before the user responds — skips the approval gate.
  • Using grep -r "ClassName" to find references instead of find_references_to — the graph knows about both asset references and C# code-level references (fields, parameters, constructors, casts, inheritance).
  • Using find . -name "*.cs" to locate scripts instead of search_by_name — the graph indexes every script, type, and method with their relationships.
  • Reading .unity or .prefab files as YAML instead of using get_scene_summary or inspect_asset — the graph provides parsed, structured data.

Cross-References

Skills: hades:unity-architect — architecture decision frameworks. hades:scene-authoring — scene construction workflows. hades:prefab-workflow — prefab creation and editing. hades:animation-workflow — animation controller setup. hades:unity-reviewer — code review for Unity anti-patterns.

Hades MCP Tools: get_project_summary, get_scene_summary, search_by_name (namePattern substring + optional declaration kind filter — no path or exact-match option), find_references_to (asset + C# code references), trace_dependencies, recall_memory, propose_memory_update, graph_query, project_get_console_log, project_run_tests, script_editing_session (action: begin/end), scriptable_object_apply (create/configure ScriptableObject asset instances).

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.