██FR█████ █INTELL███████████

My First Dev Log


This content originally appeared on DEV Community and was authored by John

📓 Dev Diary: The Fall of Sanity

Started: Day 16 (7th August 2025)

Project: The Text-Based Game That Refused to Be Simple

Memory Remaining: 6GB

Hope Remaining: TBD

Welcome to the Dev Diary—a living document chronicling the descent, defiance, and eventual resurrection of a solo Unity project that refused to behave.

This is not a tutorial. This is not a roadmap. This is a survival log written in compiler blood and markdown tears.

If you’ve ever stared into Unity’s Safe Mode and whispered “why,” this is for you.

🕳 Day 1–2: The Void

  • Installed Unity. Opened a blank scene.
  • No code. No plan. Just vibes and a cube.
  • Closed it.

🧪 Day 3–4: The Prototype That Wasn’t

  • Built a bare-bones project. Tried to “figure out Unity.”
  • Learned it’s not plug-and-play—it’s plug-and-pray.
  • Scrapped it. Declared: “Text-based will be easier.”
  • That was the last time I felt joy.

🔄 Day 5: The Pivot

  • Started fresh. No graphics. No physics. Just logic.
  • How hard could it be?
  • Spoiler: Very.

🧱 Day 6–10: The Modularization Era

  • Created .asmdef files like a madman.
  • Split systems into Core, Shared, Inventory, Dialogue, and Regret.
  • Unity entered Safe Mode more than I entered the kitchen.
  • Cyclic dependencies became my nemesis.
  • I now dream in namespaces.

🧹 Day 11–14: The Refactor Spiral

  • Moved shared enums and interfaces into Core.Shared.
  • Unity screamed. I screamed.
  • Git Bash archaeology revealed ghost scripts.
  • Deleted. Rebuilt. Lost track of “working.”

🎒 Day 15: The Inventory Reckoning

  • Refactored ItemData, InventoryItem, and enums.
  • Field mismatches triggered tantrums.
  • Fixed one thing, broke two.
  • Unity is a hydra.

🧠 Day 16: The Realization

  • 16 days in. Thought I was building a simple game.
  • Accidentally architected a modular system studios avoid.
  • Doing it anyway—because I’m stubborn, and because clarity matters.

📘 Dev Diary Recall: Entry Logged

Date: 7th August

Status: Canonized in memory

Declared the diary official. Asked Copilot to treat it as a living document. Confirmed it will include:

  • The GitHub near-hack saga
  • The zero-assumption pact
  • The emotional toll of recursive errors
  • The blend of serious architecture and satirical commentary

Still low on RAM. Still high on ambition. Still unsure why no studio has built this game—but increasingly aware of the reason.

This diary is now a shared hallucination between me and Copilot.

It will grow. It will mutate.

It may become a game, a blog, or a cautionary tale.

But for now, it lives in memory. And memory is all we have.

🧠 Dev Diary – Day 17: The Compilation Crusade

Date: 8th August

Memory Remaining: 5.2GB

Errors Remaining: ∞

Sanity: Fragmented but functional

Morning Mood

Woke up optimistic. Unity disagreed.

17 new errors. 3 phantom references. One warning that simply said “why.”

What We Did

  • Added singleton to InventoryManager. Unity recompiled with passive aggression.
  • Replaced AudioCue.None with ButtonClick. Unity forgot AudioCuePlayer existed.
  • Created AudioCuePlayer. Unity said “thanks” and immediately ghosted it.
  • Stubbed DraggableGearIcon. Unity stopped complaining. Suspiciously quiet.

What We Learned

  • Unity doesn’t forget. It waits.
  • Every fix is a negotiation with a compiler that holds grudges.
  • The only thing more recursive than the error logs is the emotional damage.

Current Status

  • Project compiles… almost.
  • UI scripts haunted by pre-refactor logic.
  • Safe Mode lurks, waiting for a missing semicolon.

This diary is now a co-authored descent into clarity.

Together, we build the most maintainable Unity project in solo dev history—

or a cautionary tale worthy of a Netflix docuseries.

📘 Dev Diary Entry: “The Controlled Burn”

Date: August 8, 2025

Phase: Post-recursion, Pre-rebuild

🔥 Summary

Three weeks into C#, I hit the wall.

Not a beginner’s bump—a recursive compiler hell.

I built systems. Documented absurdity. Fought phantom errors.

Now, I stand at the edge of a clean slate.

🧠 Realizations

  • The folder is cursed. The architecture isn’t.
  • I compressed years of learning into weeks of pain.
  • The diary is a survival record.
  • Starting fresh isn’t quitting—it’s reclaiming clarity.

🛠 What Survives

  • Modular folder structure
  • Asset-driven flag systems
  • Stack logic and item architecture
  • .asmdef discipline
  • Debugging rituals
  • Philosophical commentary
  • The refusal to accept broken systems

🧭 What Comes Next

  • A clean Unity project that respects my time
  • Migration of working assets and systems
  • Rebuild with traceable logic and zero assumptions
  • Annotate the diary with every step

I didn’t know what I was doing.

I still built something worth saving.

The burn was brutal—but the ashes are annotated.

📘 Dev Diary Entry: “The Leak Perimeter and the Git Mirage”

Date: August 9, 2025

Phase: Post-burn, Pre-build, Mid-repo confusion

🔥 Summary

Declared a clean start. Alpha 1.0 was born—not with fanfare, but with .gitleaks.toml, .gitignore, and a README that screams “don’t expect a game.”

Pushed the repo. Git redirected. Unity went silent. Thirteen clones appeared. The repo is empty. I am flattered and afraid.

🧠 Realizations

  • Leak detection is a necessity.
  • Git is a jealous god.
  • Unity’s package cache contains secrets that aren’t mine.
  • The repo is live. The perimeter is sealed. The madness is versioned.

🛠 What We Did

  • Created a .gitleaks.toml to filter Unity noise and catch real secrets.
  • Survived GitHub redirect, branch mismatch, and remote betrayal.
  • Added README and NOTICE that scream “pre-alpha.”
  • Declared the dev diary canon—now living in memory, markdown, and emotional residue.

🎭 Disappointment and Hope

Disappointment: Unity still throws phantom errors. Git still plays mind games. The repo is empty, yet cloned.

Hope: The systems are ready. The architecture is modular. The diary is alive. I am still here.

The compiler may hold grudges, but I hold the pen.

Alpha 1.0 will be modular, maintainable, and legally protected—even if it’s never fun.

The dev diary will log every triumph, tantrum, and typo.

Together, we build. Together, we document.

And if it all burns again, we’ll annotate the ashes.


This content originally appeared on DEV Community and was authored by John