Learning field
Build clear, maintainable runtime patterns with focused examples.
0/35 learned
Unity & Development
GameObjects, components, scenes, hierarchy, and prefabs - the mental model every Unity project is built from, before you write a single system.
Unity & Development
Input, physics, UI, data, and scene flow - the gameplay systems every Unity game actually needs, with ownership kept explicit.
Unity & Development
Pooling, profiling, saves, builds, and a ship checklist - the last mile between a working prototype and a released Unity game.
Eliminate frame stutter and thermal throttling by keeping batches under 100 and Update heap allocations at 0 Bytes.
See how the Editor, the runtime engine, and your project files divide responsibility before you write a line of code. Short card.
Compose behavior from small components instead of inheriting it, and see why that split shapes every Unity project.
Read a scene as a saved GameObject tree, and see why hierarchy position controls more than you expect.
Separate local from world space before a parented object starts moving in ways you did not expect.
Separate the source prefab from its instances and overrides before scripting starts touching either one.
Give one invented runtime component one clear responsibility. Short card.
Separate a named action from the device binding that triggers it so your input keeps working across devices.
Give physics, shape, and reaction each their own owner before two colliders start fighting over the same event.
Keep reaction ownership on the event that caused the change, not a polling Update.
Anchor UI to the screen it should survive, and keep the canvas a dumb view instead of a second source of truth.
Move shared config into a ScriptableObject asset so invented economy data stops living inside a MonoBehaviour.
Carry state across scenes with one narrow persistent manager instead of a single object that owns everything.
Keep acquire, reset, and return ownership visible when reusing objects.
Compare a coroutine's linear wait against an explicit state machine's named states before sequencing gets tangled.
Find the frame's actual cost in the profiler before guessing which system to optimize first.
Decide what state must survive a restart before picking a save format for it.
See which decisions move from the Editor to build settings once you target a real platform.
Work through the technical checklist that turns a vertical slice into a submittable build.
Place MCP between an agent and approved game-development context without treating the connection as autonomous judgment.
Choose the smallest MCP primitive for an action, a readable context source, or a reusable interaction template.
Separate live capabilities, standing instructions, reusable expertise, and deterministic automation before adding another layer.
Expose a narrow Unity context surface, verify it read-only first, and keep every mutation behind an explicit review boundary.
Compare how four coding clients expose the same MCP server through different setup, approval, and control surfaces.
Give each MCP tool one bounded job, an explicit input contract, and a result small enough to review before widening permissions.
Use filtering, pagination, summaries, and progressive discovery so only decision-relevant Unity context reaches the model.
Turn an agent request into an inspect, plan, approve, change, test, and review sequence with evidence at every boundary.
Apply narrow MCP capabilities to console triage, scene inspection, prefab review, build checks, and tests without granting broad control.
Keep least privilege, secret custody, untrusted tool output, and human approval explicit before an MCP workflow can mutate a project.
Design the server boundary from initialization and capability negotiation through transport-safe operation and shutdown.
Keep tool inputs, structured outputs, errors, and cancellation behavior predictable as clients and servers evolve.
Partition files, evidence, and write authority so parallel agents can hand work off without silently overwriting one another.
Trace progress, logs, tool results, verification gates, and user outcomes without mistaking call volume for useful work.
Harden version, authorization, secret, network, cancellation, and failure boundaries before a server reaches real projects.
Combine bounded diagnosis, ownership, an approved mutation, tests, build evidence, and human review into one end-to-end Unity workflow.
