unity's animator controller turns into spaghetti past ~30 states — how are you actually managing this?

OnValidate assertion is worth doing. I take it a step further and throw an explicit error if any graph method gets called before an Init() has run — the 'why isn't my animation playing' confusion is always worse in Unity because a misconfigured graph fails silently instead of giving you anything useful. Catching it at edit time instead of at runtime saves a lot of frustrated staring at an unanimated character.

the IsValid() tip is good but I'd add: make sure you're calling graph.Destroy() explicitly when you're done with it. I had a subtle memory leak for like a month because I was creating new PlayableGraphs on scene transitions and not cleaning up the old ones. Unity doesn't GC them automatically, they persist until you destroy them. learned this the hard way when memory just... kept climbing.

lmao the two full days on PlayableGraph lifetime is painfully accurate. I genuinely thought I was bad at Unity for a week. the docs assume you already know what a PlayableGraph is conceptually before explaining how it works, which is a fun catch-22. the actual API isn't that bad once it clicks but the learning curve is vertical for no good reason.

the PlayableGraph lifetime thing is where everyone loses a day. what actually helped me: PlayableGraph.IsValid() is your best friend and you should be checking it basically everywhere at first. also the Unity blog post from 2018 on the Playable API is still the best technical explainer, weirdly better than the current docs. search "PlayableGraph unity blog" and it's the first hit.

once it clicks it clicks, but the initial learning curve is steeper than it needs to be.

the Playable API tip is legit but god the documentation is rough going in. spent like two full days just understanding PlayableGraph lifetime management before I could do anything useful. once it clicks it's genuinely powerful and I get why you'd recommend it, but definitely don't start on it the day before a deadline lol

the wrapper component approach is exactly right. I do the same thing but I also assert in the wrapper's OnValidate that the graph owner is set, because I kept accidentally attaching the wrapper to the wrong GameObject and then wondering why things were getting destroyed at weird times. Unity really should just manage this automatically. the number of forum threads about PlayableGraph leaks suggests this is a known footgun they decided to leave in.

the graph.Destroy() thing is so easy to miss because Unity doesn't yell at you about it, it just quietly leaks. I made a wrapper component that calls Destroy in OnDisable and also in OnDestroy just to be safe. felt paranoid at the time, turned out to be necessary because we had cases where objects got disabled before being destroyed and the graph was just... floating there forever.