Grade Calculator — DevLevelUp

Select a role to assess

Rate your skill proficiency — the system will calculate your recommended grade

Role

Skills Self-Assessment

Role: Unity Developer

Assessed: 0 Total: 0

Algorithms & Data Structures 1

▼

Understands basic algorithms and their complexity (O(n), O(n log n)) in the context of Unity development. Applies simple search and sorting algorithms for working with game object collections in C#.

Applies medium-complexity algorithms in Unity projects: A* pathfinding, spatial hashing, quadtree for optimizing object search on scene. Evaluates algorithmic complexity when working with large numbers of game entities.

Designs optimal algorithmic solutions for high-load Unity projects. Uses BVH trees, octree and specialized algorithms for physics broadphase. Optimizes DOTS systems with cache-friendly data access patterns.

Defines algorithmic standards for Unity team. Conducts code reviews focused on algorithm complexity. Builds a library of reusable algorithmic solutions for Unity game projects.

Clean Code & Refactoring 1

▼

Writes clean C# code for Unity with clear variable and method names. Follows basic principles: DRY, KISS in the context of MonoBehaviour scripts. Uses [SerializeField] instead of public fields.

Ensures high-quality C# code in Unity: SOLID principles for game systems, ScriptableObjects for configuration, custom attributes for Inspector validation. Configures Roslyn Analyzers for Unity-specific rules.

Designs code quality infrastructure for Unity projects: custom analyzers, automated refactoring tools, coding standards enforcement via EditorConfig and .ruleset files. Ensures code testability through dependency injection.

Defines code quality standards for Unity team. Establishes code style guide, review checklist. Conducts architectural reviews and mentoring on SOLID principles in the Unity context.

Code Review 1

▼

Concurrency & Parallelism 1

▼

Understands the fundamentals of Multithreading at a basic level. Applies simple concepts in work tasks using C#. Follows recommendations from senior developers when solving problems.

Independently applies multithreading for Unity: Job System for parallel data processing, Burst compiler for SIMD optimization, ECS with multi-threaded systems, background loading with async operations. Explains concurrency trade-offs for Unity main thread constraints.

Has deep expertise in Unity multithreading: designs data-oriented architectures with ECS and Job System, implements custom job dependencies for complex parallel workflows, optimizes Burst-compiled parallel processing. Mentors team on Unity-specific concurrent programming for performance-critical game systems.

Defines multithreading standards for Unity teams: establishes guidelines for Job System and ECS architectures, conducts reviews of parallel game system designs, creates training materials on data-oriented concurrent programming patterns for Unity developers.

Game Design 1

▼

Understands Unity UI fundamentals: Canvas system, UI Toolkit basics, and event handling for game interfaces. Implements simple HUD elements, menus, and in-game prompts following design specifications. Follows team guidelines for UI anchoring, resolution scaling, and input system integration.

Independently implements Game UX and UI Design in Unity 2023+. Optimizes performance. Works with profiler.

Designs scalable Unity UI architectures using UI Toolkit, data binding, and MVVM patterns for complex game interfaces. Implements polished UX flows with animation, haptic feedback, and adaptive layouts for multi-platform targets. Mentors team on UX best practices, accessibility standards, and user testing.

Defines game UX strategy for Unity projects: establishes UI architecture standards, interaction design guidelines, and accessibility compliance requirements. Coordinates between design, engineering, and QA teams on UX consistency, localization support, and cross-platform interface adaptation.

Game Engines 1

▼

Works with core Unity Engine systems: GameObject/Component model, Prefabs, Scenes, Physics, UI. Uses Unity Editor for level building and component configuration. Understands Unity lifecycle (Awake, Start, Update).

Deep knowledge of Unity Engine: Addressable Assets, Input System, Cinemachine, Timeline, Animation Rigging. Develops custom Editor tools to accelerate workflow. Understands Unity serialization and Asset Pipeline.

Expert-level Unity Engine knowledge: DOTS (ECS, Burst, Jobs), URP/HDRP customization, native plugins. Modifies engine behavior through source-available packages. Optimizes for specific hardware.

Defines Unity Engine strategy for the studio: Unity version, packages, custom packages. Establishes Unity best practices and migration plans. Serves as technical authority on Unity Engine.

Game Platforms 1

▼

Game Programming 4

▼

Understands Unity animation fundamentals: Animator Controller, Animation Clips, blend trees, and state machines. Creates basic character animations using Mecanim system and configures animation events. Follows team patterns for animation asset organization and naming conventions.

Independently implements Game Animation Systems in Unity 2023+. Optimizes performance. Works with profiler.

Designs production animation systems in Unity: custom animation layers, IK solvers, procedural animation, and motion matching integration. Optimizes animation performance for target platforms through LOD, compression, and GPU skinning. Mentors team on advanced Mecanim patterns and custom playables.

Defines animation technology strategy for Unity projects: evaluates animation middleware, establishes pipeline standards between art and engineering teams, and sets performance budgets. Conducts reviews of animation architectures ensuring scalability and cross-platform consistency.

Uses Unity Netcode or Photon to implement basic multiplayer features. Understands network object spawning, RPCs, and state synchronization fundamentals. Tests locally with multiple clients.

Develops network systems in Unity: client-side prediction, server reconciliation, lag compensation. Uses NetworkTransform with interpolation. Implements RPC calls and game data serialization.

Designs network architecture for multiplayer Unity games: authoritative server, interest management, snapshot compression. Integrates dedicated server solutions (Multiplay, GameLift). Optimizes bandwidth.

Defines networking strategy for multiplayer Unity games. Establishes netcode standards, testing infrastructure (simulated latency). Coordinates backend and client-side networking teams.

Uses Unity Physics system: Rigidbody, Colliders, Triggers for basic physical interactions. Configures Physics Layers and Layer Collision Matrix. Understands the difference between Update and FixedUpdate.

Develops physics systems in Unity: ragdoll, vehicle physics, custom physics materials. Uses Physics.Raycast, SphereCast for gameplay mechanics. Optimizes physics through Fixed Timestep and solver iteration tuning.

Designs physics systems for complex Unity projects: Unity Physics (DOTS), custom physics for specific genres, deterministic physics for multiplayer. Profiles and optimizes PhysX.

Defines physics standards for Unity projects. Establishes physics budget (collider counts, solver iterations). Coordinates physics and gameplay teams for optimal game feel.

Understands Unity rendering pipeline basics: ShaderLab syntax, URP/HDRP differences, and material setup. Applies simple shader modifications and lighting configuration. Follows team standards for render pass ordering, texture compression, and post-processing stack usage.

Independently implements Game Rendering in Unity 2023+. Optimizes performance. Works with profiler.

Designs custom render pipelines in Unity using SRP, Shader Graph, and compute shaders for production-quality visuals. Implements advanced techniques: screen-space reflections, volumetric effects, and GPU-driven culling. Mentors team on shader optimization and platform-specific rendering constraints.

Defines rendering strategy for Unity projects: establishes shader authoring standards, visual quality benchmarks, and rendering performance budgets. Coordinates between art and engineering teams on look development, pipeline customization, and platform certification for console and mobile targets.

Game QA 1

▼

Understands Unity localization fundamentals: Unity Localization package, string tables, locale selectors, and asset localization. Implements basic text localization for UI elements using localized string references. Follows team conventions for organizing localization assets and handling font fallbacks.

Independently implements Game Localization in Unity 2023+. Optimizes performance. Works with profiler.

Designs production localization systems in Unity: custom localization pipelines, dynamic font loading for CJK languages, audio localization workflows, and platform-specific locale handling. Optimizes memory usage for multi-language assets and implements runtime language switching without loading screens.

Defines localization technology strategy for Unity projects: selects TMS integrations, establishes loc-kit standards for external vendors, and sets quality assurance workflows. Reviews localization architectures ensuring scalability for 15+ languages and compliance with platform certification requirements.

Git & Workflows 1

▼

Memory Management 2

▼

Understands the fundamentals of Memory Management at a basic level. Applies simple concepts in work tasks using C#. Follows recommendations from senior developers when solving problems.

Understands Unity memory management: managed heap (Mono/IL2CPP GC), native memory, and asset memory. Avoids common allocation pitfalls: string concatenation in Update(), LINQ in hot paths, boxing. Uses object pooling for frequently instantiated GameObjects. Profiles with Unity Memory Profiler and understands memory budget for target platforms.

Designs memory architectures for Unity projects: custom native plugins for memory-critical systems, NativeArray/NativeList with DOTS/ECS for allocation-free gameplay, and addressable asset memory management. Implements memory budgeting systems for different platforms (mobile vs console vs PC). Creates automated memory regression tests. Mentors team on GC-free programming patterns and IL2CPP memory behavior.

Defines memory management standards for Unity development teams. Establishes per-platform memory budgets and allocation policies. Conducts architectural reviews of memory-critical gameplay systems. Creates best practices and training materials on GC-free patterns, native container usage, and asset memory management for the team.

Understands the fundamentals of Memory Profiling at a basic level. Applies simple concepts in work tasks using C#. Follows recommendations from senior developers when solving problems.

Independently uses Unity Profiler memory module to analyze managed heap allocations and asset memory footprint. Understands trade-offs between memory usage patterns and GC impact on frame rate stability.

Has deep expertise in Unity memory profiling, optimizes managed heap usage and asset loading strategies for production. Eliminates GC spikes through object pooling, reduces texture memory footprint, and ensures stable frame rates under memory pressure.

Defines memory profiling standards at team level: mandatory Unity Profiler checks in CI, managed heap budgets per scene, asset memory limits by category, and GC frequency thresholds. Establishes review processes for memory-critical code paths.

OOP & Design Patterns 2

▼

Understands the fundamentals of OOP & SOLID Principles at a basic level. Applies simple concepts in work tasks using C#. Follows recommendations from senior developers when solving problems.

Independently applies OOP/SOLID in Unity/C#: proper MonoBehaviour composition over deep inheritance, interface-based service locators, single responsibility in game system components. Understands trade-offs between classic OOP patterns and Unity's component-based architecture with ScriptableObjects.

Applies OOP/SOLID in Unity game architecture: component pattern with clean MonoBehaviour separation, interface-based service locators, scriptable object factories for game data. Designs extensible Unity systems with proper separation between game logic, UI, and engine-specific code using assembly definitions.

Defines OOP/SOLID standards for Unity team: MonoBehaviour composition guidelines, ScriptableObject usage patterns, game system interface contracts. Conducts reviews of component-based architecture decisions and inheritance depth in Unity/C# projects.

Additional skills (optional) 52

These skills do not affect the main grade but show the breadth of your profile.

3D Graphics & Computing

▼

Configures Animator Controller in Unity with basic state machines for characters. Uses Animation Clips, Blend Trees and transition parameters. Understands Mecanim basics and animation curves.

Develops complex animation systems in Unity: Animation Layers, Avatar Masks, IK (Inverse Kinematics). Integrates Cinemachine for cinematic cameras. Optimizes Animation Compression for mobile platforms.

Designs animation system architecture for large Unity projects. Implements Playable API for procedural animations, Timeline for cutscenes. Optimizes bone count and skinning for mobile platforms with GPU skinning.

Defines animation pipeline standards for Unity studio. Coordinates animators and programmers. Establishes guidelines for Animation Compression, bone budgets and performance targets.

Understands the fundamentals of GPU Programming. Applies basic practices in daily work. Follows recommendations from the team and documentation.

Develops GPU-optimized solutions in Unity: Compute Shaders for parallel computation, indirect rendering, custom SRP passes. Profiles GPU performance with RenderDoc and Unity GPU Profiler.

Designs GPU architecture for Unity projects: custom render pipelines, GPU-driven rendering, async compute. Optimizes GPU memory bandwidth and occupancy for mobile and VR platforms.

Defines GPU programming strategy for Unity studio. Establishes render pipeline standards, GPU performance budgets. Coordinates graphics programmers and tech artists.

Understands the fundamentals of Shader Programming. Applies basic practices in daily work. Follows recommendations from the team and documentation.

Develops shaders for Unity in HLSL: custom lighting models, post-processing effects, screen-space effects. Optimizes shader complexity for mobile platforms. Uses Shader Variants.

Designs shader architecture for Unity projects: custom render features, shader libraries, cross-pipeline compatibility (URP/HDRP). Implements compute shaders, tessellation, advanced lighting.

Defines shader development strategy for Unity studio. Establishes shader coding standards, performance budgets. Coordinates tech artists and graphics programmers.

AI Coding Assistants

▼

Uses ChatGPT and Claude for Unity development: generating C# scripts, explaining Unity API, finding solutions to common problems. Understands AI assistant limitations when generating Unity-specific code.

Effectively applies AI assistants for complex Unity tasks: architectural decisions, shader optimization, writing Editor scripts. Crafts detailed prompts with Unity project context for quality responses.

Integrates AI assistants into Unity team workflow. Creates prompt templates for common tasks: code review, bug analysis, performance optimization. Evaluates quality of AI-generated code and trains the team to critically assess it.

Defines AI assistant usage policy for Unity team. Establishes guidelines for code review of AI-generated code. Evaluates ROI of ChatGPT/Claude usage in the context of Unity developer productivity.

Knows about Cursor as an AI-first IDE. Uses AI chat to understand C# scripts and Unity API calls. Asks Cursor to explain unfamiliar MonoBehaviour lifecycle methods and game logic patterns.

Uses Cursor Composer for multi-file editing. Applies AI chat for refactoring. Generates tests via AI. Uses @ mentions for adding context (files, documentation). Understands the difference between Chat and Composer modes.

Standardizes Cursor usage across the game dev team. Creates .cursorrules templates for Unity projects, shader pipelines, and editor tools. Evaluates Cursor vs Copilot for C# and HLSL generation. Integrates AI workflows into asset review and sprint planning. Configures MCP for Unity build pipelines.

Uses GitHub Copilot for accelerating C# code in Unity: MonoBehaviour method autocompletion, boilerplate code generation, writing comments. Understands Copilot limitations for Unity-specific code.

Effectively applies GitHub Copilot for Unity development: generating Editor scripts, shader code, unit tests. Uses Copilot Chat for explaining complex Unity API and debugging assistance.

Optimizes Copilot usage for Unity team: custom instructions, workspace context. Evaluates quality of Copilot-generated code for Unity-specific tasks. Establishes best practices.

Defines GitHub Copilot usage policy for Unity team. Manages licenses, evaluates ROI. Establishes guidelines for reviewing Copilot-generated Unity code.

Algorithms & Data Structures

▼

Uses basic C# data structures in Unity: List, Dictionary, Queue for storing game data. Understands the difference between Array, List and NativeArray in Unity context.

Applies specialized data structures in Unity: NativeArray and NativeHashMap for DOTS/Jobs, ObjectPool for reuse, Priority Queue for AI systems. Optimizes structure selection to minimize GC pressure.

Designs cache-friendly data structures for Unity DOTS: SoA layout, chunk-based storage. Creates custom NativeContainers for specific game tasks. Optimizes memory layout for Burst Compiler.

Defines data structure usage standards for Unity projects. Establishes guidelines for choosing between managed and unmanaged collections. Trains the team on data-oriented design principles.

API Management

▼

Application Security

▼

AR Development

▼

Creates simple AR applications in Unity with AR Foundation: plane detection, placing 3D objects on surfaces. Understands the difference between ARCore and ARKit. Configures AR Session and AR Camera.

Develops AR functionality in Unity: image tracking, face tracking, light estimation. Optimizes AR rendering for mobile devices. Integrates AR with game logic and Unity UI systems.

Designs AR application architecture in Unity: persistent AR, cloud anchors, multi-user AR sessions. Solves occlusion and shadow casting problems in AR. Optimizes battery consumption for extended AR sessions.

Defines AR strategy for Unity products. Establishes AR Foundation development best practices. Coordinates AR functionality with UX/UI team for optimal user experience.

Benchmarking

▼

Understands basic performance budgets for Unity projects: target FPS, draw call limits, triangle counts and texture memory. Follows established budgets for scenes and prefabs. Uses Unity Profiler to check frame time breakdown and reports violations to the team.

Independently defines performance budgets per scene and feature: CPU frame budget (e.g. 8ms gameplay, 4ms rendering, 4ms UI), GPU fill rate, batching targets and memory pools. Understands trade-offs between visual quality and framerate across target platforms. Configures automated profiling in CI with Unity Test Runner performance tests.

Designs holistic performance budget architectures for Unity titles across mobile, console and PC: per-system CPU thread budgets, GPU pass allocations, asset streaming budgets and GC pause limits. Optimizes rendering pipelines (SRP, URP, HDRP) to meet budgets on min-spec hardware. Mentors the team on profiling workflows, budget allocation strategies and performance-driven asset pipelines.

Defines performance budget strategy at the team and product level for Unity projects. Establishes platform-specific frame budgets, memory envelopes and loading time targets across all game systems. Creates budget ownership model, automated regression dashboards and performance review gates in the production pipeline. Drives cross-discipline alignment between art, design and engineering on budget trade-offs.

Uses Unity Profiler for performance analysis: CPU, GPU, Memory modules. Identifies main bottlenecks: GC Alloc in Update, expensive rendering. Understands Frame Debugger for draw call analysis.

Conducts deep profiling of Unity projects: Memory Profiler for heap analysis, Deep Profiling for call stacks, RenderDoc for GPU analysis. Creates performance benchmarks and automates their execution.

Designs profiling infrastructure for Unity studio: custom profiler markers, automated regression detection, platform-specific profiling (Xcode Instruments, Android GPU Inspector). Establishes performance budgets.

Defines performance culture for Unity team. Establishes profiling standards, benchmark suite. Conducts regular performance reviews. Trains the team on profiling tools.

Caching

▼

CI/CD

▼

Understands basic GitHub Actions for Unity: running Unity build pipelines for target platforms, reading CI logs for Unity compilation failures, understanding workflow triggers for automated builds. Follows team conventions for Unity CI pipeline configuration.

Independently creates GitHub Actions workflows for Unity: configures automated Unity build pipelines for multiple platforms, implements test execution with Unity Test Framework, automates build artifact distribution and versioning. Manages Unity CI/CD configurations.

Designs CI/CD architecture for Unity platforms: optimizes multi-platform Unity build pipelines for speed and reliability, implements progressive delivery for game releases, architects automated build verification testing. Mentors team on Unity CI/CD best practices and build optimization.

Defines DevOps strategy for Unity teams: establishes CI/CD standards for Unity build infrastructure, implements platform engineering approaches for multi-platform game delivery, drives adoption of automated build verification and release management.

Cloud Providers

▼

Concurrency & Parallelism

▼

Containerization

▼

Understands basic Docker concepts for Unity development: containerized Unity build servers, Docker images for CI pipeline dependencies, basic docker-compose for backend services. Uses existing configurations for Unity headless build containers.

Independently configures Docker for Unity projects: containerized Unity build agents, docker-compose for backend service dependencies, Dockerfile for headless Unity build images. Understands container orchestration for CI/CD pipeline build farms and artifact storage.

Designs Docker infrastructure for Unity projects: optimized build agent containers, CI/CD pipeline architecture for Unity builds, container registry management for build artifacts. Implements best practices for headless Unity build optimization and cross-platform build container management.

Defines Docker infrastructure strategy for Unity projects: build agent container standards, CI/CD pipeline container governance, artifact management policies. Conducts architecture reviews for containerized Unity build infrastructure and optimizes build farm costs.

Distributed Tracing

▼

Game Design

▼

Understands basic game mechanics in Unity: MonoBehaviour lifecycle, collisions, raycasts, and input handling. Implements simple mechanics following team patterns using C# scripts. Uses Unity Inspector to tune gameplay parameters.

Independently implements Game Mechanics Design in Unity 2023+. Optimizes performance. Works with profiler.

Designs production-grade game mechanics systems in Unity: ECS/DOTS for performance-critical gameplay, advanced physics with custom solvers, and data-driven balancing systems. Optimizes mechanics for target platforms and frame budgets. Mentors team on architecture.

Defines technical strategy for Unity game mechanics systems. Establishes architecture standards for gameplay code, ScriptableObject-driven design patterns, and performance budgets. Coordinates technical direction across gameplay, physics, and AI systems.

Game Engines

▼

Understands Unity Asset Pipeline: importing models (FBX), textures, audio. Configures basic import settings. Uses Prefabs for object reuse. Understands the difference between Resources and Addressables.

Manages Asset Pipeline in Unity: Addressable Asset System for dynamic loading, Sprite Atlas for UI optimization. Configures Asset Bundle builds for DLC content. Optimizes import settings for different platforms.

Designs scalable asset pipeline for large Unity projects: custom importers, asset dependency management, build pipeline automation. Optimizes build time and size for multiplatform projects.

Defines asset pipeline standards for Unity studio. Establishes naming conventions, folder structure guidelines. Coordinates workflow between artists, animators and programmers.

Game Infrastructure

▼

Integrates Unity Analytics for collecting basic metrics: DAU, retention, session length. Sends custom events for tracking player progression. Understands privacy requirements (GDPR) for data collection.

Designs analytics system for Unity games: funnel analysis, A/B testing via Unity Remote Config, economic metrics (ARPU, LTV). Creates dashboards in GameAnalytics or Amplitude for decision making.

Designs data-driven architecture for Unity games: event taxonomy, data warehouse integration, real-time analytics pipeline. Uses BigQuery for complex analytical queries. Implements predictive analytics for player churn.

Defines analytics strategy for Unity studio. Establishes data governance, privacy compliance framework. Coordinates analytics between game design, monetization and product teams.

Understands game backend integration from Unity: connects to PlayFab/Nakama services for player data, authentication, and cloud saves. Implements basic client-side SDK integration for leaderboards and multiplayer lobbies. Follows team conventions for backend API calls and error handling.

Independently implements Game Backend in Unity 2023+. Optimizes performance. Works with profiler.

Designs robust game backend architectures from Unity perspective: implements custom PlayFab cloud scripts, Nakama server modules, and real-time multiplayer synchronization. Optimizes network traffic, handles reconnection logic, and implements anti-cheat validation on the server side.

Defines game backend technology strategy for Unity projects: evaluates BaaS platforms (PlayFab vs Nakama vs custom), establishes multiplayer architecture standards, and sets scalability targets. Reviews backend integration patterns ensuring reliability, security, and cost efficiency.

Understands the fundamentals of Multiplayer Architecture. Applies basic practices in daily work. Follows recommendations from the team and documentation.

Designs multiplayer systems in Unity: lobby management, matchmaking, session persistence. Implements authoritative game logic on server. Integrates Unity Gaming Services (Relay, Lobby, Matchmaker).

Designs scalable multiplayer architecture: microservices for game backend, horizontal scaling, state synchronization across servers. Uses Unity Multiplay for dedicated server hosting.

Defines multiplayer strategy for Unity studio. Establishes networking architecture standards, backend infrastructure. Coordinates client and server development for multiplayer Unity projects.

Game Platforms

▼

Builds Unity projects for different platforms: Windows, Android, iOS, WebGL. Understands Platform Dependent Compilation (#if UNITY_ANDROID). Configures Player Settings for each platform.

Automates cross-platform Unity project builds: build scripts in C#, Unity Cloud Build, Jenkins pipeline. Manages platform-specific and native plugins. Optimizes build size for mobile platforms.

Designs cross-platform Unity project architecture: abstraction layers for platform APIs, conditional asset loading, quality tiers for different devices. Ensures feature parity through automated testing.

Defines cross-platform strategy for Unity studio. Establishes build infrastructure, platform support matrix. Coordinates platform-specific QA and certification processes.

Develops Unity games for PC and consoles: gamepad input via Input System, resolution management, fullscreen modes. Understands platform holder requirements (Steam, PlayStation, Xbox) for Unity builds.

Optimizes Unity games for PC and consoles: HDR output, ultra-wide support, quality presets. Implements platform-specific features: Steam achievements, PlayStation trophies. Ensures stable framerate.

Designs Unity game architecture for AAA quality on PC/Console: HDRP visual pipeline, async loading, streaming. Ensures compliance with platform requirements (TRC/TCR). Optimizes for specific hardware.

Defines PC/Console strategy for Unity studio. Establishes platform compliance process, certification workflow. Coordinates platform-specific optimizations and QA.

Builds Unity projects for WebGL: understands WebGL limitations (no threads, limited memory). Configures WebGL Player Settings. Integrates with web platforms (itch.io, CrazyGames).

Optimizes Unity WebGL builds: code stripping, texture compression, asset bundle streaming. Implements JavaScript interop for web-specific features. Ensures progressive loading.

Designs web game architecture in Unity: streaming assets, WebSocket networking for multiplayer, WebGPU readiness. Solves WebGL-specific issues: memory management, audio autoplay policies.

Defines web gaming strategy for Unity studio. Establishes WebGL performance standards, browser compatibility matrix. Coordinates web-specific QA and deployment.

Game Programming

▼

Understands basic Game AI in Unity: NavMesh pathfinding, simple state machines, and Animator-driven behavior. Follows team patterns for implementing basic enemy AI with C# MonoBehaviour scripts and Unity AI Navigation package.

Independently implements Game AI in Unity 2023+. Optimizes performance. Works with profiler.

Designs production Game AI systems in Unity: GOAP planners, utility-based AI, ML-Agents for training, and hierarchical state machines. Optimizes AI for frame budgets using job system and spatial partitioning. Mentors team on AI architecture.

Defines technical strategy for Unity Game AI systems. Establishes architecture standards for AI frameworks, performance budgets, and ML-Agents training pipelines. Coordinates technical direction between AI, gameplay, and animation teams.

Integrates audio in Unity projects: AudioSource, AudioClip, AudioMixer. Configures 3D sound with distance attenuation. Manages music and sound effects through a simple Audio Manager.

Develops audio systems in Unity: dynamic music, adaptive audio via AudioMixer snapshots, FMOD/Wwise integration. Optimizes audio memory: streaming, compression, audio pooling for mobile platforms.

Designs audio system architecture for large Unity projects: middleware selection (FMOD vs Wwise), procedural audio, spatial audio for VR. Optimizes audio threading and voice management.

Defines audio pipeline strategy for Unity studio. Establishes audio budget, middleware standards. Coordinates sound designers and programmers for effective audio workflow.

Creates UI in Unity using UI Toolkit or uGUI (Canvas): buttons, texts, images, progress bars. Understands Canvas render modes, anchoring and responsive layout. Connects UI to game logic through events.

Develops complex UI systems in Unity: dynamic lists (Scroll View with pooling), localization via Unity Localization package, animated screen transitions. Optimizes UI batching and overdraw.

Designs UI architecture for large Unity projects: MVVM for UI, UI Toolkit with custom controls, accessibility support. Optimizes UI rendering: atlas packing, SDF fonts, minimizing rebuilds.

Defines UI standards for Unity studio. Establishes UI component library, design system integration. Coordinates UX designers and UI programmers for effective workflow.

Understands PhysX in Unity: continuous vs discrete collision detection, physics materials (friction, bounciness). Configures Rigidbody parameters for realistic object behavior.

Works with advanced PhysX capabilities in Unity: joints (configurable, spring, hinge), cloth simulation, soft bodies. Configures physics solver for stability of complex constructions.

Designs physics systems with deep understanding of PhysX internals in Unity. Uses Unity Physics (DOTS) for scalable simulations. Implements custom physics behaviors through Physics callbacks and contact modification.

Defines physics engine standards for Unity studio. Establishes physics performance guidelines. Evaluates and adopts physics middleware (Havok for Unity).

Creates simple procedural systems in Unity: random level generation, procedural terrain with Perlin Noise, randomized loot tables. Uses Unity Random and Mathf for generation.

Develops advanced procedural systems in Unity: Wave Function Collapse, L-systems for vegetation, procedural mesh generation. Ensures seed-based reproducibility and configurable generation.

Designs scalable procedural generation systems for Unity: infinite world generation, streaming, biome systems. Uses Compute Shaders for GPU-accelerated generation and Burst Compiler for CPU generation.

Defines procedural generation strategy for Unity projects. Establishes procgen pipeline: from game design constraints to runtime generation. Coordinates artists and programmers.

Game QA

▼

Understands Unity performance fundamentals: draw calls, batching, garbage collection, and frame budgets. Uses Unity Profiler to identify CPU and GPU bottlenecks. Follows team guidelines for object pooling, LOD setup, and reducing unnecessary Update() calls.

Independently implements Game Performance Optimization in Unity 2023+. Optimizes performance. Works with profiler.

Designs performant Unity architectures using DOTS/ECS, Job System, and Burst Compiler for compute-heavy systems. Optimizes rendering pipeline with SRP, GPU instancing, and occlusion culling. Mentors team on profiling methodology and platform-specific optimization for mobile, console, and PC.

Defines Unity performance strategy across projects: establishes frame budget policies, automated profiling pipelines, and regression testing. Coordinates cross-team efforts on memory management, asset pipeline optimization, and platform certification requirements.

Understands Unity testing workflows: Play Mode and Edit Mode tests, automated UI testing, and performance profiling. Runs test suites in CI and reports bugs with reproducible steps.

Develops testing infrastructure for Unity: integration tests with scene loading, automated UI tests, performance regression tests. Uses Unity Test Runner in CI/CD pipeline. Creates test fixtures for game systems.

Designs testing strategy for large Unity projects: automated gameplay testing via recorded inputs, visual regression testing, load testing multiplayer. Implements chaos testing for networked games.

Defines testing culture for Unity team. Establishes test coverage requirements, QA processes. Coordinates automated and manual testing. Implements shift-left testing practices.

Git & Workflows

▼

Clones Unity projects with Git LFS and resolves common fetch issues for large assets. Knows which Unity file types (.unity, .prefab, .asset, textures, models) must be LFS-tracked. Follows established .gitattributes patterns for Unity binary content without modifying tracking rules.

Designs .gitattributes configurations for Unity projects covering textures, meshes, audio, animations, and scene files. Manages LFS locking for binary assets like .prefab and .unity files to prevent merge conflicts. Configures include/exclude patterns to optimize clone times while keeping essential assets available locally.

Architects Git LFS workflows for large-scale Unity projects with hundreds of gigabytes of textures, models, and scene files. Implements LFS transfer agents and custom storage backends to optimize asset delivery across distributed teams. Establishes locking policies and branch strategies that minimize conflicts on Unity binary assets while supporting parallel feature development.

Establishes team-wide Git LFS standards for Unity asset management including tracking rules, locking protocols, and storage tier policies. Coordinates LFS migration strategies when onboarding legacy Unity projects or restructuring asset pipelines. Mentors developers on resolving complex LFS issues with Unity-specific binary formats and drives continuous improvement of asset versioning workflows.

GraphQL

▼

Integration Testing

▼

Kubernetes & Orchestration

▼

Logging

▼

Metrics & Monitoring

▼

Networking

▼

Profiling

▼

Understands basics of CPU profiling in Unity. Uses the Unity Profiler to identify frame time spikes and expensive scripts. Follows team recommendations for profiling play mode sessions and reads CPU module timelines under guidance.

Independently profiles Unity projects using the CPU Profiler, Deep Profiling, and Timeline view. Identifies bottlenecks in MonoBehaviour callbacks, physics, and rendering threads. Understands trade-offs between Deep Profiling overhead and granularity of call stack data in development vs. device builds.

Designs CPU profiling strategies for large Unity projects spanning multiple platforms. Uses platform-specific profilers (Xcode Instruments, Android Studio Profiler, PIX) alongside Unity's profiler for cross-validation. Optimizes job system workloads, Burst-compiled code, and ECS systems. Mentors team on CPU budget allocation per frame.

Defines CPU profiling strategy for Unity development teams. Establishes per-frame CPU budgets, automated profiling in CI builds, and performance gates for milestones. Drives adoption of profiling best practices across art, design, and engineering. Conducts performance reviews of gameplay and systems code.

Understands basic memory profiling concepts in Unity including managed vs native memory and garbage collection impact. Uses Unity Memory Profiler and Profiler window to capture snapshots under guidance. Identifies obvious memory leaks such as unreleased assets or growing object pools by following team checklists and documentation.

Independently profiles memory in Unity projects using Memory Profiler, Deep Profiling, and platform-specific tools like Xcode Instruments or Android Profiler. Understands trade-offs between IL2CPP and Mono memory behavior, GC allocation patterns, and texture memory budgets. Optimizes asset loading strategies, reduces GC pressure through object pooling, and resolves memory spikes during scene transitions.

Designs memory profiling pipelines for Unity projects — automated memory regression testing in CI, custom memory tracking for Addressables and asset bundles, and platform-specific memory budget enforcement. Optimizes native plugin memory interop, reduces managed heap fragmentation through architecture-level decisions, and implements custom memory snapshot analysis tools. Mentors the team on memory-efficient ECS patterns, texture compression strategies, and GC-free hot paths.

Defines memory profiling strategy at the team and product level for Unity projects. Establishes memory budgets per platform (mobile, console, PC), enforces automated memory checks in CI using Memory Profiler snapshots, and standardizes asset memory guidelines for art and design teams. Conducts reviews of memory-critical systems, drives adoption of Addressables-based streaming to control runtime memory, and ensures memory profiling is integrated into the production pipeline from prototyping to ship.

Prompt Engineering

▼

Crafts effective prompts for AI tools in the context of Unity development. Uses chain-of-thought and few-shot examples to obtain quality C# code and architectural advice.

Applies advanced prompt engineering techniques for Unity: system prompts with project context, role-based prompting for architectural reviews, structured output for code generation.

Develops prompt libraries for Unity team: templates for common tasks, prompt chains for complex refactoring, automated prompt testing. Evaluates response quality of different LLMs for Unity tasks.

Defines prompt engineering practices for Unity team. Builds knowledge base for AI tools with project context. Evaluates AI-assisted development effectiveness.

Relational Databases

▼

REST API

▼

System Design

▼

Understands basic game system design principles in Unity: modularity, loose coupling through events, separation of concerns. Designs simple systems: inventory, quest tracker.

Designs medium-complexity game systems in Unity: save system, economy system, achievement system. Uses ScriptableObject architecture for decoupled design. Documents systems via UML.

Designs architecture for large Unity projects: game framework, plugin system, mod support. Ensures extensibility and maintainability for projects with 2+ years of development.

Defines architectural standards for Unity studio. Establishes reference architectures for different game types. Conducts architectural reviews and mentoring on system design.

Unit Testing

▼

Understands basic unit testing in Unity: Unity Test Framework setup, simple PlayMode/EditMode tests, assertion patterns for MonoBehaviour behavior. Follows team conventions for testing game logic separately from Unity engine dependencies.

Independently writes unit tests in Unity: PlayMode/EditMode test suites for game systems, mock dependencies for MonoBehaviour testing, edge case coverage for physics and input handling. Integrates Unity tests into CI/CD with headless test runner and code coverage reporting.

Designs testing strategy for Unity projects: test pyramid across EditMode/PlayMode/integration tests, deterministic physics testing, visual regression testing for rendering. Optimizes Unity test execution with headless batch mode and test sharding. Mentors team on testing complex game systems in Unity.

Defines testing strategy at product level for Unity projects: EditMode/PlayMode test standards, visual regression testing governance, build pipeline test architecture. Establishes shift-left testing culture with automated quality gates for Unity game releases.

Writes unit tests for Unity with NUnit and Unity Test Framework: Edit Mode Tests for pure logic, Play Mode Tests for MonoBehaviour. Understands AAA pattern (Arrange-Act-Assert) for game tests.

Develops testing strategy for Unity projects: mock objects for Unity dependencies, test fixtures for scenes, integration tests with Addressables loading. Achieves 60%+ coverage of critical code.

Designs testing architecture for Unity: testable code patterns, DI for testability, custom test attributes. Implements mutation testing for test quality assessment. Automates test execution in CI.

Defines testing standards for Unity team. Establishes test coverage requirements, code review criteria for tests. Trains the team in TDD/BDD approaches for game development.

VR Development

▼

Integrates VR SDK in Unity: XR Plugin Management, OpenXR for cross-platform VR. Configures VR camera rig, controller tracking. Creates basic VR interactions: grab, teleport.

Develops VR functionality in Unity: hand tracking, spatial UI, haptic feedback. Integrates platform-specific SDK (Oculus Integration, SteamVR). Optimizes for comfortable VR experience.

Designs VR architecture for Unity: multi-platform VR support (Quest, PCVR, PSVR2), VR comfort systems, advanced locomotion. Optimizes rendering pipeline for VR performance targets.

Defines VR development strategy for Unity studio. Establishes VR UX guidelines, performance standards. Coordinates VR-specific design and development workflow.

XR Platforms

▼

Implements basic XR interactions in Unity: XR Interaction Toolkit for grab, activate, UI interaction in VR/AR. Configures XR Rig with tracked controllers and hand tracking.

Develops advanced XR interactions in Unity: two-handed interactions, physics-based manipulation, gesture recognition. Creates custom interactables and interactors for specific game mechanics.

Designs XR interaction systems for Unity: modular interaction architecture, cross-platform input abstraction, accessibility in XR. Optimizes interaction responsiveness and comfort.

Defines XR interaction standards for Unity studio. Establishes interaction design language, UX guidelines for VR/AR. Coordinates XR designers and developers.

Optimizes Unity XR applications for stable framerate: occlusion culling, LOD, draw call batching. Understands VR performance requirements: 72/90/120 FPS. Uses Unity Profiler for XR scenes.

Applies advanced XR optimizations in Unity: single-pass instanced rendering, foveated rendering, fixed foveated rendering. Optimizes for mobile VR: GPU skinning, texture atlasing, shader complexity reduction.

Designs XR performance architecture for Unity: adaptive quality system, dynamic resolution, GPU/CPU load balancing. Develops custom profiling tools for XR-specific metrics (frame timing, reprojection).

Defines XR performance standards for Unity studio. Establishes performance budgets for VR/AR platforms. Coordinates optimization efforts between graphics, gameplay and system programmers.