Unity Compile Fixer

Overview

This skill enables automatic detection and resolution of Unity C# compilation errors by leveraging VSCode's diagnostic system. It collects real-time errors from the OmniSharp C# language server, analyzes error patterns against a curated database of common Unity issues, and proposes context-aware solutions for user approval before applying fixes.

When to Use This Skill

Use this skill when:

• Unity projects report C# compilation errors in VSCode
• Need to diagnose the root cause of Unity compiler errors (CS* error codes)
• Want automated fix suggestions for common Unity scripting issues
• Working with Unity projects that have version control integration (Git, Unity Collaborate, Plastic SCM)
• Need to handle Unity .meta file conflicts

Example user requests:

• "Check Unity compilation errors and help me fix them"
• "My Unity project has compiler errors, can you diagnose and fix?"
• "Unity scripts are not compiling, what's wrong?"
• "Fix the C# errors in my Unity project"

Workflow

Follow this workflow when the skill is invoked:

1. Detect Compilation Errors

Use the mcp__ide__getDiagnostics tool to collect errors from VSCode:

// Collect all project diagnostics
mcp__ide__getDiagnostics()

// Or target specific Unity script files
mcp__ide__getDiagnostics({ uri: "file:///path/to/PlayerController.cs" })

Filter the diagnostics to focus on Unity-relevant errors:

• Severity: Only process errors with severity: "Error" (ignore warnings)
• Source: Only process source: "csharp" (OmniSharp C# diagnostics)
• Error Codes: Focus on CS* compiler error codes (e.g., CS0246, CS0029, CS1061)

2. Analyze Error Patterns

For each detected error:

1. Extract error information:

   • File path and line number from uri and range
   • Error code from message (e.g., "CS0246")
   • Full error message text

2. Match against error pattern database:

   • Load references/error-patterns.json
   • Find the error code entry (e.g., CS0246)
   • Retrieve common causes and solutions

3. Read affected file context:

   • Use Read tool to load the file with errors
   • Examine surrounding code for context
   • Identify missing imports, incorrect types, or API misuse

3. Generate Solution Proposals

For each error, create a structured fix proposal:

**Error**: CS0246 at PlayerController.cs:45
**Message**: The type or namespace name 'Rigidbody' could not be found

**Analysis**:
- Missing using directive for UnityEngine namespace
- Common Unity API usage pattern

**Proposed Solution**:
Add `using UnityEngine;` at the top of PlayerController.cs

**Changes Required**:
- File: Assets/Scripts/PlayerController.cs
- Action: Insert using directive at line 1

4. User Confirmation

Before applying any fixes:

1. Present all proposed solutions in a clear, structured format

2. Use AskUserQuestion tool to get user approval:

   • List each error and proposed fix
   • Allow user to approve all, select specific fixes, or cancel

3. Wait for explicit confirmation - do not apply fixes automatically

5. Apply Approved Fixes

For each approved fix:

1. Use Edit tool to modify the affected file
2. Preserve code formatting and existing structure
3. Apply minimal changes - only fix the specific error

Example:

Edit({
  file_path: "Assets/Scripts/PlayerController.cs",
  old_string: "public class PlayerController : MonoBehaviour",
  new_string: "using UnityEngine;\n\npublic class PlayerController : MonoBehaviour"
})

6. Verify Version Control Status

After applying fixes:

1. Check for .meta file conflicts:

   • Use Grep to search for Unity .meta files
   • Verify that script GUID hasn't changed
   • Check for merge conflict markers (<<<<<<, ======, >>>>>>)

2. Report VCS status:

   • List modified files
   • Warn about any .meta file issues
   • Suggest git operations if needed

7. Re-validate Compilation

After fixes are applied:

1. Re-run diagnostics using mcp__ide__getDiagnostics()
2. Compare error count before and after
3. Report results to the user:
   • Number of errors fixed
   • Remaining errors (if any)
   • Success rate

Error Pattern Database

The skill relies on references/error-patterns.json for error analysis. This database contains:

• Error Code: CS* compiler error code
• Description: Human-readable explanation
• Common Causes: Typical reasons this error occurs in Unity
• Solutions: Step-by-step fix instructions
• Unity-Specific Notes: Unity API considerations

To analyze an error, load the database and match the error code:

Read({ file_path: "references/error-patterns.json" })
// Parse JSON and find errorCode entry

Analysis Scripts

The skill includes Node.js scripts in scripts/ for complex error analysis:

scripts/analyze-diagnostics.js

Processes VSCode diagnostics JSON output and extracts Unity-relevant errors.

Usage:

node scripts/analyze-diagnostics.js <diagnostics-json-file>

Output:

• Filtered list of Unity C# compilation errors
• Error classification by type (missing imports, type errors, API issues)
• Severity and file location information

This script can be run independently or invoked from the SKILL.md workflow when detailed analysis is needed.

Best Practices

When using this skill:

1. Start with full project diagnostics - use mcp__ide__getDiagnostics() without parameters to get complete error picture
2. Prioritize errors by severity and dependency - fix foundational errors (missing imports) before downstream errors
3. Batch related fixes - group errors from the same file for efficient editing
4. Always verify VCS status - Unity .meta files are critical for version control
5. Re-validate after fixes - ensure errors are actually resolved

Resources

scripts/analyze-diagnostics.js

Node.js script for processing VSCode diagnostics and filtering Unity-specific C# errors.

references/error-patterns.json

Curated database of common Unity C# compilation errors with solutions and Unity-specific guidance.