Skip to main content
skill CX Codex

unity-editor-tooling — Claude Code skill: features and installation

The unity-editor-tooling Claude Code skill covers Unity Editor extensions and build automation. It activates for custom inspectors, editor windows, importers, and Unity CI/CD tasks.

MIT 102 installs ★ 66 updated 2026-06-18

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add JosiahSiegel/claude-plugin-marketplace --skill unity-editor-tooling -a claude-code
Open on GitHub

What unity-editor-tooling does

The skill provides patterns for extending the Unity Editor and automating builds. Its material includes custom inspector templates, EditorWindow examples, build scripts, GameCI setup, .asmdef guidance, and CI YAML.

It also covers PropertyDrawer, ScriptedImporter, platform switching, and preprocessor symbols. Editor code belongs in an Editor/ folder or behind #if UNITY_EDITOR.

The agent activates it for requests involving editor scripts, build pipelines, or Unity CI/CD. Examples include BuildPipeline.BuildPlayer and a GitHub Actions workflow using GameCI.

What it helps with

  • write a custom inspector for a component
  • create a standalone Unity Editor window
  • import assets from a custom file format
  • script a build for a target platform
  • configure Unity builds with GameCI in CI

Example prompts for the agent

  • Write a custom inspector for the EnemySpawner component.
  • Create an EditorWindow to search scene objects.
  • Set up GitHub Actions to build a Unity project with GameCI.

How to install unity-editor-tooling

1Skills CLI (Vercel)

npx skills add JosiahSiegel/claude-plugin-marketplace --skill unity-editor-tooling -a claude-code

2Manually: put the files in place

~/.claude/skills/unity-editor-tooling/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/unity-editor-tooling/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about unity-editor-tooling

How do I install unity-editor-tooling in Claude Code?

Run npx skills add JosiahSiegel/claude-plugin-marketplace --skill unity-editor-tooling -a claude-code. The skill file is at ~/.claude/skills/unity-editor-tooling/SKILL.md.

What does unity-editor-tooling do?

It helps extend the Unity Editor, script builds, and configure CI/CD. The skill includes examples for inspectors, editor windows, and custom asset importers.

When does the agent use unity-editor-tooling?

It activates for requests about custom inspectors, EditorWindow, ScriptedImporter, build automation, or Unity CI/CD.

Source text

SKILL.md · MIT
---
name: unity-editor-tooling
description: |
  Unity Editor tooling, build automation, and asset pipeline customization.
  PROACTIVELY activate for: (1) writing custom Editor scripts, (2) custom inspectors and PropertyDrawer attributes, (3) EditorWindow creation, (4) ScriptedImporter for custom asset types, (5) build pipeline scripting (BuildPipeline.BuildPlayer, IBuildPostprocessor), (6) platform-switching automation, (7) CI/CD for Unity (GameCI, GitHub Actions, Unity Build Automation), (8) Assembly Definition (.asmdef) organization, (9) preprocessor symbols and platform defines, (10) Editor-only code with #if UNITY_EDITOR.
  Provides: custom inspector templates, EditorWindow examples, build script patterns, GameCI setup, .asmdef best practices, and CI YAML for Unity builds.
---

# Unity Editor Scripting and Tooling

## Overview

Reference for extending the Unity Editor, automating builds, testing, version control configuration, and package development. Covers custom inspectors, editor windows, build pipeline scripting, CI/CD, and the Unity Test Framework.

## Custom Inspectors

### Basic Custom Editor

```csharp
#if UNITY_EDITOR
using UnityEditor;
using UnityEngine;

[CustomEditor(typeof(EnemySpawner))]
public class EnemySpawnerEditor : Editor
{
    SerializedProperty spawnPoints;
    SerializedProperty enemyPrefab;
    SerializedProperty spawnInterval;

    void OnEnable()
    {
        spawnPoints = serializedObject.FindProperty("_spawnPoints");
        enemyPrefab = serializedObject.FindProperty("_enemyPrefab");
        spawnInterval = serializedObject.FindProperty("_spawnInterval");
    }

    public override void OnInspectorGUI()
    {
        serializedObject.Update();

        EditorGUILayout.PropertyField(enemyPrefab);
        EditorGUILayout.Slider(spawnInterval, 0.1f, 10f, new GUIContent("Spawn Interval"));

        EditorGUILayout.Space();
        EditorGUILayout.LabelField("Spawn Points", EditorStyles.boldLabel);
        EditorGUILayout.PropertyField(spawnPoints, true);

        if (GUILayout.Button("Add Spawn Point at Origin"))
        {
            spawnPoints.InsertArrayElementAtIndex(spawnPoints.arraySize);
            var newElement = spawnPoints.GetArrayElementAtIndex(spawnPoints.arraySize - 1);
            newElement.vector3Value = Vector3.zero;
        }

        serializedObject.ApplyModifiedProperties();
    }

    void OnSceneGUI()
    {
        var spawner = (EnemySpawner)target;
        // Draw handles in scene view for each spawn point
        for (int i = 0; i < spawner.SpawnPointCount; i++)
        {
            Vector3 point = spawner.GetSpawnPoint(i);
            Vector3 newPoint = Handles.PositionHandle(point, Quaternion.identity);
            if (point != newPoint)
            {
                Undo.RecordObject(spawner, "Move Spawn Point");
                spawner.SetSpawnPoint(i, newPoint);
            }
        }
    }
}
#endif
```

**Key rules:**
- Always wrap editor code in `#if UNITY_EDITOR` or place in `Editor/` folders
- Use `SerializedProperty` for undo/redo support and multi-object editing
- Call `serializedObject.Update()` before and `ApplyModifiedProperties()` after changes
- Use `Undo.RecordObject()` before direct modifications

### PropertyDrawer

```csharp
[CustomPropertyDrawer(typeof(MinMaxRange))]
public class MinMaxRangeDrawer : PropertyDrawer
{
    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
    {
        EditorGUI.BeginProperty(position, label, property);
        var min = property.FindPropertyRelative("min");
        var max = property.FindPropertyRelative("max");
        float minVal = min.floatValue;
        float maxVal = max.floatValue;

        position = EditorGUI.PrefixLabel(position, label);
        EditorGUI.MinMaxSlider(position, ref minVal, ref maxVal, 0f, 100f);
        min.floatValue = minVal;
        max.floatValue = maxVal;
        EditorGUI.EndProperty();
    }
}
```

Use PropertyDrawers for reusable field-level customization. Use CustomEditors for component-level customization.

## EditorWindow

```csharp
public class LevelEditorWindow : EditorWindow
{
    [MenuItem("Tools/Level Editor")]
    static void ShowWindow() => GetWindow<LevelEditorWindow>("Level Editor");

    Vector2 scrollPos;
    string searchFilter = "";

    void OnGUI()
    {
        EditorGUILayout.BeginHorizontal(EditorStyles.toolbar);
        searchFilter = EditorGUILayout.TextField(searchFilter, EditorStyles.toolbarSearchField);
        if (GUILayout.Button("Refresh", EditorStyles.toolbarButton, GUILayout.Width(60)))
            RefreshData();
        EditorGUILayout.EndHorizontal();

        scrollPos = EditorGUILayout.BeginScrollView(scrollPos);
        // Draw content
        EditorGUILayout.EndScrollView();
    }

    void OnSelectionChange() => Repaint(); // React to selection changes
}
```

Use `EditorWindow` for standalone tools. Use `[MenuItem]` for menu bar integration. Override `OnSelectionChange`, `OnHierarchyChange`, `OnProjectChange` for reactive updates.

## ScriptedImporter

```csharp
[ScriptedImporter(1, "leveldata")]
public class LevelDataImporter : ScriptedImporter
{
    public override void OnImportAsset(AssetImportContext ctx)
    {
        string json = File.ReadAllText(ctx.assetPath);
        var levelData = ScriptableObject.CreateInstance<LevelData>();
        JsonUtility.FromJsonOverwrite(json, levelData);
        ctx.AddObjectToAsset("main", levelData);
        ctx.SetMainObject(levelData);
    }
}
```

Register custom file extensions. Unity re-imports automatically when the source file changes.

## Build Pipeline

### Build Script

```csharp
public static class BuildScript
{
    [MenuItem("Build/Build Windows")]
    public static void BuildWindows()
    {
        var options = new BuildPlayerOptions
        {
            scenes = EditorBuildSettings.scenes
                .Where(s => s.enabled)
                .Select(s => s.path).ToArray(),
            locationPathName = "Builds/Windows/Game.exe",
            target = BuildTarget.StandaloneWindows64,
            options = BuildOptions.None
        };

        var report = BuildPipeline.BuildPlayer(options);
        if (report.summary.result != BuildResult.Succeeded)
            throw new Exception($"Build failed: {report.summary.totalErrors} errors");
    }
}
```

### CI/CD with GameCI (GitHub Actions)

```yaml
name: Unity Build
on:
  push:
    branches: [main]

jobs:
  build:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        targetPlatform: [StandaloneWindows64, StandaloneLinux64, WebGL]
    steps:
      - uses: actions/checkout@v4
        with:
          lfs: true

      - uses: game-ci/unity-builder@v4
        env:
          UNITY_LICENSE: ${{ secrets.UNITY_LICENSE }}
          UNITY_EMAIL: ${{ secrets.UNITY_EMAIL }}
          UNITY_PASSWORD: ${{ secrets.UNITY_PASSWORD }}
        with:
          targetPlatform: ${{ matrix.targetPlatform }}
          buildMethod: BuildScript.Build${{ matrix.targetPlatform }}

      - uses: actions/upload-artifact@v4
        with:
          name: build-${{ matrix.targetPlatform }}
          path: build/${{ matrix.targetPlatform }}
```

Activate a Unity license first using `game-ci/unity-activate`. Use Unity Build Automation (Cloud Build) as an alternative if CI runners lack capacity.

## Assembly Definitions

```text
Project/
├── Scripts/
│   ├── Core/             Core.asmdef          (no references)
│   ├── Gameplay/          Gameplay.asmdef      (references: Core)
│   ├── UI/                UI.asmdef            (references: Core, Gameplay)
│   ├── Networking/        Networking.asmdef     (references: Core)
│   ├── Editor/            Editor.asmdef        (references: Core; Editor-only platform)
│   └── Tests/
│       ├── EditMode/      Tests.EditMode.asmdef (references: Core; Test assemblies)
│       └── PlayMode/      Tests.PlayMode.asmdef (references: Core, Gameplay)
```

**Benefits:** Incremental compilation (only recompile changed assemblies), enforced dependency boundaries, required for testability.

**Rules:**
- Set Editor-only assemblies to Editor platform only
- Test assemblies must reference `UnityEngine.TestRunner` and `UnityEditor.TestRunner`
- Use Assembly Definition References for cross-assembly access

## Unity Test Framework

### Edit Mode Test

```csharp
[TestFixture]
public class InventoryTests
{
    [Test]
    public void AddItem_IncreasesCount()
    {
        var inventory = new Inventory(maxSlots: 10);
        inventory.Add(new Item("Sword", 1));
        Assert.AreEqual(1, inventory.Count);
    }

    [Test]
    public void AddItem_WhenFull_ReturnsFalse()
    {
        var inventory = new Inventory(maxSlots: 1);
        inventory.Add(new Item("Sword", 1));
        Assert.IsFalse(inventory.Add(new Item("Shield", 1)));
    }
}
```

### Play Mode Test

```csharp
[UnityTest]
public IEnumerator Player_TakesDamage_HealthDecreases()
{
    var player = new GameObject().AddComponent<PlayerHealth>();
    player.Initialize(100);
    player.TakeDamage(30);
    yield return null; // Wait one frame
    Assert.AreEqual(70, player.CurrentHealth);
}
```

Run tests via Window > General > Test Runner. Edit Mode tests run instantly. Play Mode tests enter play mode and can test MonoBehaviour logic, coroutines, and physics.

## Version Control

### Unity .gitignore (Essential Entries)

```text
/[Ll]ibrary/
/[Tt]emp/
/[Oo]bj/
/[Bb]uild/
/[Bb]uilds/
/[Ll]ogs/
/[Uu]ser[Ss]ettings/
/[Mm]emoryCaptures/
/[Rr]ecordings/
*.csproj
*.sln
*.suo
*.user
*.pidb
*.booproj
*.unityproj
```

### Project Settings for Version Control

1. Edit > Project Settings > Editor > Asset Serialization: Force Text
2. Edit > Project Settings > Editor > Version Control Mode: Visible Meta Files
3. Use Unity Smart Merge: configure `.gitattributes` with `*.unity merge=unityyamlmerge`
4. Install UnityYAMLMerge (ships with Unity) and configure git to use it

## Custom Packages (UPM)

```text
com.company.my-package/
├── package.json
├── Runtime/
│   ├── com.company.my-package.asmdef
│   └── MyScript.cs
├── Editor/
│   ├── com.company.my-package.editor.asmdef
│   └── MyEditorScript.cs
├── Tests/
│   ├── Runtime/
│   └── Editor/
├── Documentation~/
├── CHANGELOG.md
└── README.md
```

Install local packages via `manifest.json`: `"com.company.my-package": "file:../../Packages/my-package"` or via git URL.

## Additional Resources

### Reference Files
- **`references/editor-recipes.md`** -- Advanced editor patterns: Gizmos, Handles, SceneView overlays, custom menus, asset post-processors, build hooks (IPreprocessBuildWithReport), serialization callbacks, Terrain and ProBuilder scripting, multi-scene editing workflows

© JosiahSiegel · MIT · JosiahSiegel/claude-plugin-marketplace

Similar skills

All skills for Game dev and 3D: Unity, Unreal, Godot, Blender →
unity-build-pipeline gamedev-skills unity-build-pipeline is a Claude Code skill that configures and automates Unity 6.3 LTS builds with profiles and scripts. It runs for build automation or player-only reflection errors. CX Codex +1 11,100installs unity-package-management Unity-Technologies unity-package-management manages UPM packages outside the Unity Editor using Pipeline commands or a headless C# fallback. Helpful for dependency setup and CI workflows. CX Codex +1 9,000installs scenario-unity-pipeline-automation scenario-labs scenario-unity-pipeline-automation — a skill for Claude Code, Codex, Cursor, Copilot, Gemini CLI and OpenCode — automates Unity 6.3 asset import (FBX, PNG), prefab builds, Addressables, CI builds. CX Codex +1 567installs sprite-editor Unity-Technologies sprite-editor rewrites Unity sprite rects, borders, pivots, outlines and slicing by generating C# that runs inside a connected Editor. CX Codex +1 7,100installs unity-csharp-scripting gamedev-skills The unity-csharp-scripting Claude Code skill writes and fixes Unity 6.3 LTS gameplay scripts in C#. It activates for new or renamed .cs files, “Missing script” errors, or fields absent from the Inspector. CX Codex +1 11,700installs unity-developer rmyndharis unity-developer — a skill for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode that brings Unity 6 LTS expertise into the agent context: rendering pipelines, C# performance patterns, and cross-platform builds. CX Codex +1 3,000installs

From the same set96

The whole set →
unity-ui-development unity-ui-development guides Unity interface creation across UGUI and UI Toolkit. Provides recipes for UXML structure, USS styling, RectTransform anchors, and runtime data binding. CX Codex +1 107installs viral-video-platform-algorithms The viral-video-platform-algorithms Claude Code skill explains TikTok, YouTube, Instagram, and Facebook algorithms. It activates for platform strategy, video reach, hashtags, and posting schedules. CX Codex +1 106installs azure-ml-foundry-workspace azure-ml-foundry-workspace guides Azure Machine Learning and Azure AI Foundry setup, from workspace networking to compute and model endpoints. Use it to plan configuration or investigate deployment logs. CX Codex +1 105installs ffmpeg-animation-timing-reference The ffmpeg-animation-timing-reference Claude Code skill explains timing units in FFmpeg and ASS/SSA subtitles. It helps select animation, transition, and caption durations and check audio-video sync. CX Codex +1 104installs unity-networking The unity-networking Claude Code skill supports multiplayer networking work in Unity. It activates for framework setup, RPCs, synchronized state, lobbies, and server-authoritative designs. CX Codex +1 103installs unity-performance unity-performance — a skill for tracking down Unity stutter and low FPS: what to open in the Profiler, how to cut draw calls, where garbage collection causes spikes. CX Codex +1 103installs dax-mastery The dax-mastery Claude Code skill assists with DAX in Power BI semantic models. It activates for measures, calculated columns, evaluation contexts, time intelligence, and formula tuning. CX Codex +1 101installs python-opencv The python-opencv Claude Code skill supports Python computer-vision work with OpenCV. It activates for image and video processing, color conversion, and contour detection. CX Codex +1 100installs

Project sponsors

Companies that keep this analytics open