i tried cursor inside unity for the first time and within one week i could not go back to writing c sharp the old way
I had been writing Unity C# in Visual Studio for three years. A developer in a Discord server kept mentioning Cursor and I kept ignoring it. One afternoon I finally installed it and opened my Unity project inside it just to see what the fuss was about. By the end of that afternoon I had written more working code than I usually produce in three days. This is exactly what happened, what surprised me, what I got wrong, and why I am still using it six months later.
Marcus Webb
June 26, 2026
What I built in the first afternoon with Cursor: a complete save and load system using JSON serialization that saved player position, inventory, and quest states across three save slots. In Visual Studio I would have estimated this as a two day job. It took four hours and forty minutes. Not because Cursor wrote everything for me. Because I never got stuck for longer than two minutes on anything.
What I Was Using Before and Why I Resisted Switching
Visual Studio with Unity integration. Three years of the same setup. I knew where every menu was. My muscle memory was built around it. I had tried GitHub Copilot as a VS extension and found it occasionally useful but mostly just autocompleting things I was already going to type anyway. So when someone suggested Cursor my mental model of it was Copilot but in a different editor and I did not see the point of switching editors for marginal improvement. The thing I had wrong was that Cursor is not an autocomplete layer on top of an existing editor. The AI in Cursor knows your entire project. That is the difference.
The First Day: What I Actually Did
- Installation took about four minutes. Cursor installs as a standalone editor and imports your VS Code settings and extensions automatically. My Unity syntax highlighting, theme, and keybindings were all there when it opened.
- I opened my Unity project folder in Cursor as the workspace root. Not a single script. The entire Assets folder. This is the step that matters. Cursor indexed all my existing scripts and now knew every class, method, and variable name in my project.
- I started on the save system by typing a comment at the top of a new empty script. Something like: save and load system using JSON, three slots, saves player position inventory and quest states. Cursor started completing the class structure from that comment. I accepted completions, adjusted what did not fit, and kept going.
- The thing that stopped me in my tracks was when I was writing the InventoryData serialization and Cursor suggested the correct field names from my existing Inventory class without me specifying them. It had read my Inventory script and knew what fields existed. That was the moment I understood what made this different.
The Save System Code That Came Out of That First Session
// SaveLoadManager.cs
// Written in my first Cursor session on a Unity project
// Cursor knew my Inventory and QuestManager classes
// and referenced them correctly without me specifying
using System.IO;
using System.Collections.Generic;
using UnityEngine;
[System.Serializable]
public class SaveData
{
public Vector3 playerPosition;
public List<string> inventoryItemIds = new List<string>();
public Dictionary<string, int> questStates = new Dictionary<string, int>();
// Cursor added these fields by reading my existing Inventory
// and QuestManager scripts. I did not specify them manually.
public float playerHealth;
public int currency;
public string lastSaveTime;
}
public class SaveLoadManager : MonoBehaviour
{
public static SaveLoadManager Instance;
private const int SLOT_COUNT = 3;
private string SavePath(int slot) =>
Path.Combine(Application.persistentDataPath, $"save_slot_{slot}.json");
void Awake()
{
if (Instance != null) { Destroy(gameObject); return; }
Instance = this;
DontDestroyOnLoad(gameObject);
}
public void Save(int slot)
{
if (slot < 0 || slot >= SLOT_COUNT)
{
Debug.LogWarning($"Invalid save slot: {slot}");
return;
}
var data = new SaveData
{
playerPosition = GameManager.Instance.Player.transform.position,
// Cursor generated this by reading my Inventory class
inventoryItemIds = InventoryManager.Instance.GetAllItemIds(),
questStates = QuestManager.Instance.GetAllQuestStates(),
playerHealth = GameManager.Instance.Player.CurrentHealth,
currency = GameManager.Instance.Currency,
lastSaveTime = System.DateTime.Now.ToString("yyyy-MM-dd HH:mm")
};
string json = JsonUtility.ToJson(data, true);
File.WriteAllText(SavePath(slot), json);
Debug.Log($"Game saved to slot {slot}");
}
public bool Load(int slot)
{
string path = SavePath(slot);
if (!File.Exists(path))
{
Debug.Log($"No save file found in slot {slot}");
return false;
}
string json = File.ReadAllText(path);
var data = JsonUtility.FromJson<SaveData>(json);
GameManager.Instance.Player.transform.position = data.playerPosition;
InventoryManager.Instance.LoadFromIds(data.inventoryItemIds);
QuestManager.Instance.LoadStates(data.questStates);
GameManager.Instance.Player.SetHealth(data.playerHealth);
GameManager.Instance.SetCurrency(data.currency);
return true;
}
public bool SlotHasSave(int slot) => File.Exists(SavePath(slot));
public string GetSaveInfo(int slot)
{
if (!SlotHasSave(slot)) return "Empty";
var data = JsonUtility.FromJson<SaveData>(
File.ReadAllText(SavePath(slot)));
return data.lastSaveTime;
}
public void DeleteSave(int slot)
{
if (SlotHasSave(slot)) File.Delete(SavePath(slot));
}
}What I Got Wrong in the First Week
- I accepted completions without reading them on day two. I was moving fast and started tab accepting everything. One Cursor completion added a call to a method that did not exist yet in my QuestManager. It compiled because of a using directive issue that masked the error. The bug showed up at runtime two hours later. Still needed to read every suggestion. AI completions are not the same as verified working code.
- I asked Cursor to refactor a system that was actively broken. Asked it to improve the structure of my Inventory before fixing the underlying bug. It refactored around the bug and the refactored version was cleaner but still broken in the same place. Fix bugs before refactoring with AI. The AI works with what is there.
- I did not set up the .cursorignore file for the first ten days. Cursor was indexing my node modules folder from a previous npm install in the project root and a Packages folder with compiled dependencies. The irrelevant context was not causing wrong answers but it was slowing down indexing. Added a .cursorignore file and indexing got faster.
- I tried to stay in Visual Studio for some tasks and Cursor for others. Splitting my workflow between two editors meant neither had full context at any point. Committed to Cursor full time in week two and both the context quality and my personal consistency improved.
Six Months On: What My Cursor Unity Workflow Looks Like Now
- Cursor is open alongside Unity every session. It is my only code editor now. Visual Studio is uninstalled.
- The .cursorignore file excludes Library, Temp, Packages, and any node modules directories. Only the Assets folder and project root configuration files are indexed.
- For new scripts I start with a comment block describing what the script needs to do and what other scripts it interacts with. Cursor builds from that description.
- For debugging I paste the error message and the relevant function into Cursor chat. Not the whole script unless the error could be anywhere. Just the relevant section plus context.
- For Unity specific API questions I switch to Unity Muse Chat rather than asking Cursor. Cursor gives good general C# answers. Muse Chat gives version accurate Unity 6 API answers. Both are open every session.
Final Thoughts
The first afternoon in Cursor produced more working code than I usually generate in three days not because I was thinking less but because I was never blocked. Every time I knew what I needed but was unsure of the exact syntax or implementation, Cursor suggested it. Every time I needed to connect something to existing code, Cursor already knew the existing code. Three years of Visual Studio habit disappeared in one week because the productivity difference was too large to argue with.