Index of every page on this site: llms.txt
All skills
gamedev-skills avatar

/unity-csharp-scripting

@c6ca6c4
Run it yourself

Writes and fixes Unity 6.3 LTS C# gameplay scripts: MonoBehaviour lifecycle, serialization, .meta/GUID discipline and command-line tests. Use for new or renamed .cs files, "Missing script" or a field missing from the Inspector. Not for physics (`unity-physics`), input (`unity-input-system`), data assets (`unity-scriptableobjects`) or builds (`unity-build-pipeline`).

Use this Skill: https://skilld.dev/gh/gamedev-skills/awesome-gamedev-agent-skills/unity-csharp-scripting

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈98 tokens for metadata: the name and description. ≈2k when used: this file. ≈3k more on demand in 2 files.

Description uses 4.9% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈393 characters, or 4.9%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

Unity C# Scripting (MonoBehaviour)

Write correct gameplay scripts for Unity 6.3 LTS (6000.3), C# 9 on .NET Standard 2.1, keep the project's .meta files intact, and prove the result compiles and behaves without opening the Editor by hand.

When to use

  • Authoring or fixing a MonoBehaviour: lifecycle callbacks, component references, serialized fields, coroutines, async with Awaitable.
  • Creating, moving, renaming or deleting scripts and assets from the file system.
  • Compiling or testing a Unity project from a terminal or CI, for any Unity skill.
  • The project has Assets/, ProjectSettings/ and *.cs files.

When not to use: rigidbodies and collision response → unity-physics; reading player input → unity-input-system; shared data assets and config → unity-scriptableobjects; Animator parameters → unity-animation; building players → unity-build-pipeline.

Workflow

  1. Read the project's versions first. ProjectSettings/ProjectVersion.txt gives the Editor version; Packages/manifest.json the packages; any *.asmdef files tell you which assembly a new script lands in. Keep the project's version unless asked to upgrade.
  2. Pick the callback by purpose. Awake caches references to its own components; OnEnable/OnDisable subscribe and unsubscribe; Start wires things that depend on other objects' Awake; FixedUpdate is physics; LateUpdate follows movement (cameras).
  3. Expose tunables with [SerializeField] private so designers can edit them and other code cannot. A plain class needs [System.Serializable] to show up.
  4. Move every file with its .meta. A .meta holds the asset's GUID; a new .meta means a new GUID and every reference to the old one shows "Missing script". A brand-new file needs no .meta: Unity writes one on the next import. Keep each MonoBehaviour or ScriptableObject class in a file of the same name.
  5. Run the checker: python scripts/check_unity_project.py <project-dir> (--json for machine-readable output). Fix every ERROR (duplicate or malformed GUIDs, files moved without their .meta, missing script references) and re-run until it exits 0. Run it from this skill's directory or resolve the installed path first; it needs Python 3.10+ only, reads text-serialized assets and never writes. --help lists the checks and exit codes.
  6. Compile. With the Unity CLI and a ready Editor, unity recompile --project-path <project>; otherwise a batch-mode import and grep -E "error CS[0-9]{4}" on its log.
  7. Prove the behavior with an EditMode or PlayMode test, or by reading the value back from the running Editor with unity command script eval. Read references/agent-checks.md for the exact commands, the test .asmdef and how to read the results. Report which checks ran and which could not.

Patterns

1. Serialized fields that survive refactors

using UnityEngine;
using UnityEngine.Serialization;

public class Turret : MonoBehaviour
{
    [SerializeField, Range(0.1f, 5f)] private float fireInterval = 0.5f;

    // Renamed from "range": without this attribute every scene and prefab loses the value.
    [FormerlySerializedAs("range")]
    [SerializeField] private float maxRange = 12f;

    [System.Serializable]
    public class Stats { public int hp = 100; public int armor = 0; }

    [SerializeField] private Stats stats = new();
}

2. A coroutine you can stop exactly

private Coroutine _spawnLoop;

private void OnEnable()  => _spawnLoop = StartCoroutine(SpawnLoop());
private void OnDisable() { if (_spawnLoop != null) StopCoroutine(_spawnLoop); }

private System.Collections.IEnumerator SpawnLoop()
{
    var wait = new WaitForSeconds(1f);   // allocate once, reuse
    while (true) { Spawn(); yield return wait; }
}

private void Spawn() { }

For async/await with Awaitable, the full execution order and custom yield instructions, read references/lifecycle-and-coroutines.md.

Gotchas

  • ?. and ?? on a destroyed object. Unity overrides == so a destroyed object equals null, but ?., ?? and is null skip that override and see a live reference. Use if (target) or target == null for anything derived from UnityEngine.Object.
  • Renaming a serialized field wipes its saved values. Add [FormerlySerializedAs("old")] (namespace UnityEngine.Serialization) when you rename.
  • "Missing script" after a refactor. The .meta stayed behind, was regenerated, or the class name no longer matches the file name. The checker reports all three.
  • Physics in Update. Forces or MovePosition outside FixedUpdate jitter and depend on frame rate. Read input in Update, apply it in FixedUpdate.
  • Order between objects. All Awake calls finish before any Start, but the order among Awakes (and among Starts) is undefined unless Script Execution Order is set. Do cross-object wiring in Start.
  • Coroutines stop when the GameObject is deactivated. SetActive(false) kills them; setting only the component's enabled = false does not. Restart in OnEnable if needed.
  • An async method keeps running after its object is destroyed. Pass destroyCancellationToken to Awaitable waits (they then throw OperationCanceledException), and await each Awaitable instance only once: they are pooled.
  • Obsolete warnings on FindObjectOfType/FindObjectsOfType. Use FindAnyObjectByType or FindObjectsByType(FindObjectsSortMode.None) on 6.3. From 6.4, FindFirstObjectByType and the FindObjectsSortMode overload are obsolete too: use FindAnyObjectByType and FindObjectsByType<T>(). All of them scan the scene; cache the result.
  • Repeated GetComponent in hot paths. Cache stable references in Awake, and profile before treating an occasional lookup as the bottleneck.
  • The first Update can run in the same frame as Start. Guard fields that other objects set later.

References

  • Read references/agent-checks.md before compiling or testing a project from the command line: Unity CLI commands, batch-mode commands, test assembly files, log locations and how to read NUnit results.
  • Read references/lifecycle-and-coroutines.md when ordering matters across callbacks, or for coroutine yield instructions, CustomYieldInstruction and the Awaitable equivalents of coroutine waits.
  • scripts/check_unity_project.py: run it (step 5); treat it as a black box and use --help instead of reading the source.

Related skills

  • unity-physics: Rigidbody, collisions and FixedUpdate motion.
  • unity-input-system: reading player input into these scripts.
  • unity-scriptableobjects: sharing data between scripts without singletons.

Version notes

Last verified: 2026-11-11, against Unity 6000.3.28f1.

Source: SKILL.md on GitHub

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

No alerts8d3 checks · Risk SAFE
  • Gen Agent Trust Hub9d

    The skill is a professional tool for Unity C# development. It includes a Python script for project validation and instructions for using the official Unity CLI. While it involves downloading the Unity CLI and processing project files, these actions are transparent, directed toward well-known official sources, and aligned with the skill's stated purpose. The 'low' verdict is assigned due to the inherent surface for indirect prompt injection when processing untrusted Unity project files.

  • Socket8d

    No alerts

  • Snyk9d

    Risk: LOW · No issues

Signed by skilld at c6ca6c4. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub last week.

Activeupdated last week

README badge

README badge for gamedev-skills/awesome-gamedev-agent-skills/unity-csharp-scripting