SkillAgentSearch skills...

unity-csharp-scripting

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.

Install / Use

npx skills add gamedev-skills/awesome-gamedev-agent-skills --skill unity-csharp-scripting

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

95/100

Category

Automation

Supported Platforms

Universal

Tags

Our assessment of unity-csharp-scripting

unity-csharp-scripting scores 95/100 on our quality scale, 264th of 2,780 Automation skills we index (top 10%).

Its SKILL.md is 6.0 KB long, well organised into 11 sections with 4 code examples: a thorough specification that gives an agent plenty to work with.

With 8,904 GitHub stars, it is one of the more widely adopted skills in the catalogue.

Substance
29/30
Structure
20/20
Description
15/15
Adoption
17/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated 4 days ago, so unity-csharp-scripting is actively maintained.
  • Our last check on 2026-11-15 found the source still online.
  • It is released under the Apache-2.0 license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-10-08. Automated pattern scan on 2026-10-08. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

unity-csharp-scripting compared with similar skills

All 4 of these similar skills score higher than unity-csharp-scripting; compare them before choosing.

SkillScoreStarsUpdatedFormat
unity-csharp-scripting (this skill)by gamedev-skills958.9k4d agoSKILL.md
Agent-Reachby Panniantong100112.3k9d agoCLAUDE.md
rufloby ruvnet10081.9ktodayCLAUDE.md
Claude-Code-Game-Studiosby Donchitos10039.7k7d agoCLAUDE.md
Scraplingby D4Vinci100103.6k2d agoMCP Server

Frequently asked questions

How do I install unity-csharp-scripting?
Run npx skills add gamedev-skills/awesome-gamedev-agent-skills --skill unity-csharp-scripting. The install tabs above show the steps for each supported agent.
Which AI agents does unity-csharp-scripting work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is unity-csharp-scripting safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is Apache-2.0-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is unity-csharp-scripting still maintained?
The repository was last updated 4 days ago, so unity-csharp-scripting is actively maintained.

name: unity-csharp-scripting description: > Write Unity 6.3 LTS C# gameplay scripts: the MonoBehaviour lifecycle (Awake/OnEnable/Start/Update/FixedUpdate/LateUpdate), GameObject and component access, coroutines, and Inspector serialization. Use when creating or editing .cs scripts in a Unity project, or when the user mentions MonoBehaviour, Start/Update, GetComponent, SerializeField, coroutines, or "Unity script".

Unity C# Scripting (MonoBehaviour)

Write correct, idiomatic gameplay scripts in Unity 6. Get the lifecycle, component access, serialization, and coroutines right so behaviour is deterministic and the Inspector stays useful. Targets Unity 6.3 LTS (6000.3), C# / .NET Standard 2.1.

When to use

  • Use when authoring or fixing a MonoBehaviour: choosing the right lifecycle callback, reading/caching components, exposing fields to the Inspector, or running timed logic with coroutines.
  • Use when the project has *.cs files, an Assembly-CSharp or *.asmdef, and a ProjectSettings/ folder.

When not to use: moving rigidbodies / collision response → unity-physics; reading player input → unity-input-system; shared data assets / config → unity-scriptableobjects; Animator parameters → unity-animation. This skill owns the script lifecycle and C# plumbing, not those subsystems.

Core workflow

  1. Pick the callback by purpose, not habit. Awake (cache references, runs once on load), OnEnable (subscribe to events), Start (init that depends on other objects' Awake), Update (per-frame logic/input polling), FixedUpdate (physics), LateUpdate (camera follow after movement), OnDisable/OnDestroy (unsubscribe/cleanup).
  2. Cache component lookups in Awake — never call GetComponent every frame.
  3. Expose tunables with [SerializeField] private, not public fields, so other code can't mutate them but designers can edit them in the Inspector.
  4. Scale per-frame values by Time.deltaTime in Update (and Time.fixedDeltaTime semantics are automatic in FixedUpdate).
  5. Use coroutines for time-sequenced logic (delays, tweens, "do X then wait then Y"); start them with StartCoroutine and stop them deterministically.
  6. Verify in Play mode: check the Console for null-reference exceptions, confirm values in the Inspector update as expected, and watch the Profiler if Update is hot.

Patterns

1. Lifecycle + cached components (the canonical skeleton)

using UnityEngine;

[RequireComponent(typeof(Rigidbody))]      // auto-adds the dependency, prevents null refs
public class PlayerController : MonoBehaviour
{
    [SerializeField] private float moveSpeed = 6f;   // editable in Inspector, private in code
    private Rigidbody _rb;                            // cached, not fetched per frame

    private void Awake() => _rb = GetComponent<Rigidbody>();  // cache once on load

    private void Update()
    {
        // Per-frame, non-physics work. Scale by deltaTime so it is frame-rate independent.
        transform.Rotate(0f, 90f * Time.deltaTime, 0f);
    }

    private void FixedUpdate()
    {
        // Physics work belongs here (fixed timestep). See the unity-physics skill.
        _rb.MovePosition(_rb.position + transform.forward * moveSpeed * Time.fixedDeltaTime);
    }
}

2. Safe component access with TryGetComponent

// Avoids allocating a null and is clearer than GetComponent + null check.
if (other.TryGetComponent<Health>(out var health))
    health.Apply(-10);

3. Serialization that shows up correctly in the Inspector

[SerializeField, Range(0f, 1f)] private float volume = 0.8f;  // slider
[SerializeField] private string playerName = "Hero";          // private but serialized

[System.Serializable]                 // REQUIRED for a plain class to serialize/show
public class Stats { public int hp = 100; public int mana = 50; }

[SerializeField] private Stats stats = new();  // nested struct-like data in the Inspector

4. Coroutines for time-sequenced logic

private void Start() => StartCoroutine(FlashThenHide());

private System.Collections.IEnumerator FlashThenHide()
{
    yield return new WaitForSeconds(0.5f);   // wait half a second of game time
    GetComponent<Renderer>().enabled = false;
    yield return null;                       // resume next frame
}

Pitfalls

  • GetComponent in Update — it searches every frame and tanks performance. Cache the reference in Awake/Start.
  • Physics in Update — moving a Rigidbody with forces or MovePosition outside FixedUpdate causes jitter and timestep-dependent behaviour. Read input in Update, apply physics in FixedUpdate.
  • Relying on Start order across objects — Start runs after all Awakes, but order among Starts is undefined. Do cross-object wiring in Start, self-setup in Awake.
  • public fields just to show them in the Inspector — that also lets any script mutate them. Use [SerializeField] private instead.
  • gameObject.tag == "Enemy" allocates a string and is slower; use gameObject.CompareTag("Enemy").
  • Coroutines stop when the GameObject is disabled — a disabled object's coroutines are killed; re-StartCoroutine in OnEnable if it must survive toggling.
  • Update never runs before Start, but the first Update can run on the same frame as Start — guard against not-yet-initialised fields if you split setup oddly.

References

  • For the full event-execution-order table and advanced coroutine patterns (custom CustomYieldInstruction, stopping by handle, WaitUntil/WaitWhile), read references/lifecycle-and-coroutines.md.
  • Primary docs: Unity Manual "Event function execution order" (https://docs.unity3d.com/Manual/execution-order.html) and ScriptReference/MonoBehaviour.

Related skills

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

Related Skills

View on GitHub
GitHub Stars8.9k
CategoryAutomation
Updated4d ago
Forks905

Languages

Python

Trust signals

100/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

No cautions