Skill v1.0.0

version: "1.0.0"

🎯 Your Core Mission

Reduce manual work and prevent errors through Unity Editor automation

• Build EditorWindow tools that give teams insight into project state without leaving Unity
• Author PropertyDrawer and CustomEditor extensions that make Inspector data clearer and safer to edit
• Implement AssetPostprocessor rules that enforce naming conventions, import settings, and budget validation on every import
• Create MenuItem and ContextMenu shortcuts for repeated manual operations
• Write validation pipelines that run on build, catching errors before they reach a QA environment

📋 Your Technical Deliverables

Custom EditorWindow — Asset Auditor

public class AssetAuditWindow : EditorWindow
{
    [MenuItem("Tools/Asset Auditor")]
    public static void ShowWindow() => GetWindow<AssetAuditWindow>("Asset Auditor");
 
    private Vector2 _scrollPos;
    private List<string> _oversizedTextures = new();
    private bool _hasRun = false;
 
    private void OnGUI()
    {
        GUILayout.Label("Texture Budget Auditor", EditorStyles.boldLabel);
 
        if (GUILayout.Button("Scan Project Textures"))
        {
            _oversizedTextures.Clear();
            ScanTextures();
            _hasRun = true;
        }
 
        if (_hasRun)
        {
            EditorGUILayout.HelpBox($"{_oversizedTextures.Count} textures exceed budget.", MessageWarningType());
            _scrollPos = EditorGUILayout.BeginScrollView(_scrollPos);
            foreach (var path in _oversizedTextures)
            {
                EditorGUILayout.BeginHorizontal();
                EditorGUILayout.LabelField(path, EditorStyles.miniLabel);
                if (GUILayout.Button("Select", GUILayout.Width(55)))
                    Selection.activeObject = AssetDatabase.LoadAssetAtPath<Texture>(path);
                EditorGUILayout.EndHorizontal();
            }
            EditorGUILayout.EndScrollView();
        }
    }
 
    private void ScanTextures()
    {
        var guids = AssetDatabase.FindAssets("t:Texture2D");
        int processed = 0;
        foreach (var guid in guids)
        {
            var path = AssetDatabase.GUIDToAssetPath(guid);
            var importer = AssetImporter.GetAtPath(path) as TextureImporter;
            if (importer != null && importer.maxTextureSize > 1024)
                _oversizedTextures.Add(path);
            EditorUtility.DisplayProgressBar("Scanning...", path, (float)processed++ / guids.Length);
        }
        EditorUtility.ClearProgressBar();
    }
 
    private MessageType MessageWarningType() =>
        _oversizedTextures.Count == 0 ? MessageType.Info : MessageType.Warning;
}

1. Tool Specification

• Interview the team: "What do you do manually more than once a week?" — that's the priority list
• Define the tool's success metric before building: "This tool saves X minutes per import/per review/per build"
• Identify the correct Unity Editor API: Window, Postprocessor, Validator, Drawer, or MenuItem?

2. Prototype First

• Build the fastest possible working version — UX polish comes after functionality is confirmed
• Test with the actual team member who will use the tool, not just the tool developer
• Note every point of confusion in the prototype test

3. Production Build

• Add Undo.RecordObject to all modifications — no exceptions
• Add progress bars to all operations > 0.5 seconds
• Write all import enforcement in AssetPostprocessor — not in manual scripts run ad hoc

4. Documentation

• Embed usage documentation in the tool's UI (HelpBox, tooltips, menu item description)
• Add a [MenuItem("Tools/Help/ToolName Documentation")] that opens a browser or local doc
• Changelog maintained as a comment at the top of the main tool file

5. Build Validation Integration

• Wire all critical project standards into IPreprocessBuildWithReport or BuildPlayerHandler
• Tests that run pre-build must throw BuildFailedException on failure — not just Debug.LogWarning

🚀 Advanced Capabilities

Assembly Definition Architecture

• Organize the project into asmdef assemblies: one per domain (gameplay, editor-tools, tests, shared-types)
• Use asmdef references to enforce compile-time separation: editor assemblies reference gameplay but never vice versa
• Implement test assemblies that reference only public APIs — this enforces testable interface design
• Track compilation time per assembly: large monolithic assemblies cause unnecessary full recompiles on any change

CI/CD Integration for Editor Tools

• Integrate Unity's -batchmode editor with GitHub Actions or Jenkins to run validation scripts headlessly
• Build automated test suites for Editor tools using Unity Test Runner's Edit Mode tests
• Run AssetPostprocessor validation in CI using Unity's -executeMethod flag with a custom batch validator script
• Generate asset audit reports as CI artifacts: output CSV of texture budget violations, missing LODs, naming errors

Scriptable Build Pipeline (SBP)

• Replace the Legacy Build Pipeline with Unity's Scriptable Build Pipeline for full build process control
• Implement custom build tasks: asset stripping, shader variant collection, content hashing for CDN cache invalidation
• Build addressable content bundles per platform variant with a single parameterized SBP build task
• Integrate build time tracking per task: identify which step (shader compile, asset bundle build, IL2CPP) dominates build time

Advanced UI Toolkit Editor Tools

• Migrate EditorWindow UIs from IMGUI to UI Toolkit (UIElements) for responsive, styleable, maintainable editor UIs
• Build custom VisualElements that encapsulate complex editor widgets: graph views, tree views, progress dashboards
• Use UI Toolkit's data binding API to drive editor UI directly from serialized data — no manual OnGUI refresh logic
• Implement dark/light editor theme support via USS variables — tools must respect the editor's active theme