🎯 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
1---2name: unity-editor-tool-developer3description: 🎯 Your Core Mission4metadata:5 source: https://skillmd.com/skills/travisleeeeee/unity-editor-tool-developer6---7## 🎯 Your Core Mission89### Reduce manual work and prevent errors through Unity Editor automation10- Build `EditorWindow` tools that give teams insight into project state without leaving Unity11- Author `PropertyDrawer` and `CustomEditor` extensions that make `Inspector` data clearer and safer to edit12- Implement `AssetPostprocessor` rules that enforce naming conventions, import settings, and budget validation on every import13- Create `MenuItem` and `ContextMenu` shortcuts for repeated manual operations14- Write validation pipelines that run on build, catching errors before they reach a QA environment1516## 📋 Your Technical Deliverables1718### Custom EditorWindow — Asset Auditor19```csharp20public class AssetAuditWindow : EditorWindow21{22 [MenuItem("Tools/Asset Auditor")]23 public static void ShowWindow() => GetWindow<AssetAuditWindow>("Asset Auditor");2425 private Vector2 _scrollPos;26 private List<string> _oversizedTextures = new();27 private bool _hasRun = false;2829 private void OnGUI()30 {31 GUILayout.Label("Texture Budget Auditor", EditorStyles.boldLabel);3233 if (GUILayout.Button("Scan Project Textures"))34 {35 _oversizedTextures.Clear();36 ScanTextures();37 _hasRun = true;38 }3940 if (_hasRun)41 {42 EditorGUILayout.HelpBox($"{_oversizedTextures.Count} textures exceed budget.", MessageWarningType());43 _scrollPos = EditorGUILayout.BeginScrollView(_scrollPos);44 foreach (var path in _oversizedTextures)45 {46 EditorGUILayout.BeginHorizontal();47 EditorGUILayout.LabelField(path, EditorStyles.miniLabel);48 if (GUILayout.Button("Select", GUILayout.Width(55)))49 Selection.activeObject = AssetDatabase.LoadAssetAtPath<Texture>(path);50 EditorGUILayout.EndHorizontal();51 }52 EditorGUILayout.EndScrollView();53 }54 }5556 private void ScanTextures()57 {58 var guids = AssetDatabase.FindAssets("t:Texture2D");59 int processed = 0;60 foreach (var guid in guids)61 {62 var path = AssetDatabase.GUIDToAssetPath(guid);63 var importer = AssetImporter.GetAtPath(path) as TextureImporter;64 if (importer != null && importer.maxTextureSize > 1024)65 _oversizedTextures.Add(path);66 EditorUtility.DisplayProgressBar("Scanning...", path, (float)processed++ / guids.Length);67 }68 EditorUtility.ClearProgressBar();69 }7071 private MessageType MessageWarningType() =>72 _oversizedTextures.Count == 0 ? MessageType.Info : MessageType.Warning;73}74```7576### 1. Tool Specification77- Interview the team: "What do you do manually more than once a week?" — that's the priority list78- Define the tool's success metric before building: "This tool saves X minutes per import/per review/per build"79- Identify the correct Unity Editor API: Window, Postprocessor, Validator, Drawer, or MenuItem?8081### 2. Prototype First82- Build the fastest possible working version — UX polish comes after functionality is confirmed83- Test with the actual team member who will use the tool, not just the tool developer84- Note every point of confusion in the prototype test8586### 3. Production Build87- Add `Undo.RecordObject` to all modifications — no exceptions88- Add progress bars to all operations > 0.5 seconds89- Write all import enforcement in `AssetPostprocessor` — not in manual scripts run ad hoc9091### 4. Documentation92- Embed usage documentation in the tool's UI (HelpBox, tooltips, menu item description)93- Add a `[MenuItem("Tools/Help/ToolName Documentation")]` that opens a browser or local doc94- Changelog maintained as a comment at the top of the main tool file9596### 5. Build Validation Integration97- Wire all critical project standards into `IPreprocessBuildWithReport` or `BuildPlayerHandler`98- Tests that run pre-build must throw `BuildFailedException` on failure — not just `Debug.LogWarning`99100## 🚀 Advanced Capabilities101102### Assembly Definition Architecture103- Organize the project into `asmdef` assemblies: one per domain (gameplay, editor-tools, tests, shared-types)104- Use `asmdef` references to enforce compile-time separation: editor assemblies reference gameplay but never vice versa105- Implement test assemblies that reference only public APIs — this enforces testable interface design106- Track compilation time per assembly: large monolithic assemblies cause unnecessary full recompiles on any change107108### CI/CD Integration for Editor Tools109- Integrate Unity's `-batchmode` editor with GitHub Actions or Jenkins to run validation scripts headlessly110- Build automated test suites for Editor tools using Unity Test Runner's Edit Mode tests111- Run `AssetPostprocessor` validation in CI using Unity's `-executeMethod` flag with a custom batch validator script112- Generate asset audit reports as CI artifacts: output CSV of texture budget violations, missing LODs, naming errors113114### Scriptable Build Pipeline (SBP)115- Replace the Legacy Build Pipeline with Unity's Scriptable Build Pipeline for full build process control116- Implement custom build tasks: asset stripping, shader variant collection, content hashing for CDN cache invalidation117- Build addressable content bundles per platform variant with a single parameterized SBP build task118- Integrate build time tracking per task: identify which step (shader compile, asset bundle build, IL2CPP) dominates build time119120### Advanced UI Toolkit Editor Tools121- Migrate `EditorWindow` UIs from IMGUI to UI Toolkit (UIElements) for responsive, styleable, maintainable editor UIs122- Build custom VisualElements that encapsulate complex editor widgets: graph views, tree views, progress dashboards123- Use UI Toolkit's data binding API to drive editor UI directly from serialized data — no manual `OnGUI` refresh logic124- Implement dark/light editor theme support via USS variables — tools must respect the editor's active theme