Lesson 2: Unity Setup, Repo Structure, and Task Board

Your Lesson 1 brief is useless if the project lives in chaos. This lesson gives you a repeatable factory floor: the right Unity template, a folder layout that scales, version control that does not fight binary assets, and a task board that maps work to outcomes.

Lesson Objective

By the end of this lesson you will have:

A Unity project aligned with your rendering and platform goals
A repository-ready folder structure and ignore rules
A simple task board where every card traces back to scope or metrics

Why This Matters

Indie teams lose time to merge conflicts, lost scenes, and vague tickets. Investing one hour in structure now prevents days of archaeology later.

Step-by-Step

Step 1: Install Unity Hub and Pick an Editor Line

Install Unity Hub if you have not already.
Add an editor that matches your target (Unity 6.x / 2026-era LTS when available for your platform).
Install modules for your build targets (Windows, macOS, WebGL, or console support as needed).

Pro tip: Pin the exact editor version in your team notes so everyone opens the same project without silent upgrade drift.

Step 2: Create the Project With the Right Template

In Hub, click New project.
Choose 2D or 3D (URP) based on your Lesson 1 core promise, not on what looks coolest in the template gallery.
Name the project using your working title slug (e.g., floating-village-v1).
Place the repo root outside cloud-synced Desktop folders when possible to avoid Library corruption (OneDrive/Dropbox can fight Library/).

Step 3: Establish a Production-Grade Assets Layout

Inside Assets/, create a root namespace folder so third-party assets never mix with yours:

Assets/
  _Project/
    Scenes/
    Scripts/
    Prefabs/
    Art/
    Audio/
    UI/
    Settings/
    Docs/

Move the default SampleScene into _Project/Scenes/ and rename it to something meaningful (Boot, Main, or VerticalSlice_01).

Step 4: Initialize Git and Unity Ignore Rules

Initialize Git at the repository root (the folder that contains Assets, Packages, and ProjectSettings).
Add a Unity .gitignore. The official template excludes Library/, Temp/, Obj/, Build/, Builds/, Logs/, and user-specific IDE files.
Commit Packages/manifest.json and packages-lock.json so package versions reproduce across machines.

Common mistake: Committing Library/. It will bloat the repo and cause painful merges.

Step 5: Optional Git LFS for Large Binaries

If you expect large audio, video, or high-res textures:

Enable Git LFS for extensions like .wav, .mp3, .fbx, .psd (choose patterns your team agrees on).
Document the rule in Assets/_Project/Docs/CONTRIBUTING.md so new contributors do not bypass LFS.

Step 6: Branch and PR Rhythm

Keep it boring and effective:

main: always buildable
develop (optional): integration branch for small teams
feature/short-name: one feature or lesson milestone per branch

Require a quick self-review checklist before merging: scene loads, no console errors, brief still matches scope.

Step 7: Build the Task Board

Use GitHub Projects, Linear, Jira, or Trello with five columns:

Backlog – ideas not yet ready
Ready – clear acceptance criteria
In Progress – owned by one person
Review – buildable, needs test or art pass
Done – matches your Definition of Done

Each card should link to either:

A line item from your Lesson 1 scope (in scope for v1), or
A metric checkpoint (production, quality, or launch)

Step 8: Wire the Lesson 1 Brief Into the Workflow

Add a pinned issue or doc link: Scope brief (Lesson 1) in the repo README.md or _Project/Docs/.
Create your first three Ready cards:
- Import or block out placeholder art pass for vertical slice
- Implement minimal core loop scene
- Add smoke-test checklist (load scene, no errors, frame time sanity)

Mini Challenge

Create one Definition of Done checklist in your docs (five bullets max) and apply it to your first merged task. If a task cannot meet the checklist, send it back to Ready with clearer criteria.

Pro Tips

Name scripts and prefabs with a consistent prefix (PV_ for project code, vendor assets untouched).
Keep a Boot scene that only loads essentials; avoid bloating it with debug-only objects.
Snapshot ProjectSettings when you change input or physics defaults so diffs tell a story.

Common Mistakes

Mixing third-party folder renames after import (breaks updates).
Using personal Unity accounts for organization-owned projects without a license plan.
Task cards that say "make fun combat" instead of observable outcomes.

Troubleshooting

"Unity Hub will not install the editor."

Check disk space, disable VPN briefly, and verify admin rights. Download the editor .dmg / .exe manually from Unity if Hub stalls.

"Git repo is huge after one commit."

You probably committed Library/ or a Build/ folder. Remove them from history with git rm -r --cached on those paths, fix .gitignore, and recommit.

"My teammate gets different package errors."

Align editor versions and commit both manifest.json and packages-lock.json. Run Window > Package Manager > Resolve after pull.

Recap

You installed a coherent Unity baseline, created a scalable Assets layout, protected the repo with ignore rules, and connected real tasks to your scope brief.

Next Lesson Teaser

Next, you will prototype the core game loop in a single scene so players can experience your fantasy in minutes, not months.

FAQ

Which is better for a small 3D indie game, Built-in or URP?
URP is the practical default for stylized or mobile-friendly 3D; choose Built-in only if you have a specific reason and documented tradeoffs.

Should I use Plastic SCM instead of Git?
Plastic is strong for artists-heavy teams. Git plus clear LFS rules works well for code-led indies; pick one and commit to training.

How many cards should be In Progress per person?
One or two. More than that usually means multitasking, not throughput.