For years, every new game project I started in Unreal Engine followed the same painful pattern:
- New project
- Rebuild the same systems
- Re-solve the same problems
- Lose momentum
- Start over, convinced this time would be different
Inventory systems. Interaction systems. Save logic. Input handling. UI glue.
I rebuilt them every single time.
I told myself it was part of learning, or that I was just “doing it cleaner this time.” And while I was improving, none of that progress ever really carried forward.
The breakthrough came when I stopped thinking in terms of projects and started thinking in terms of plugins.
The Old Way: Reinvent Everything, Every Time
My old workflow looked like this:
- Create a new Unreal Engine project
- Prototype the core idea
- Start hacking together systems
- Realize I need inventory, weapons, interaction, persistence
- Rewrite everything from scratch
- Hit friction
- Restart with a “better” foundation
I repeated this cycle for years.
Looking back, I don’t think I was restarting because I didn’t know what I was doing.
I was restarting because starting over felt safe.
A fresh project gives you momentum without commitment. Everything still has potential. Nothing is finished enough to be judged — by others or by yourself. Each restart felt like progress, even when it wasn’t building anything durable.
The Shift: Systems First, Games Second
The mental shift was simple, but uncomfortable:
Stop building games. Start building systems.
Instead of thinking:
- “This game needs an inventory system”
I started thinking:
- “I need an inventory plugin I should never have to rewrite again”
That led to a rule I now follow almost religiously:
If I build a system twice, it becomes a plugin.
Once I adopted that rule, the way I approached Unreal Engine changed completely.
Why Plugins Changed Everything in Unreal Engine 5
Unreal plugins force discipline in a way projects don’t:
- Clear module boundaries
- Explicit dependencies
- Isolation from game-specific logic
- Reusability across projects
- Easier refactoring without fear of breaking everything
Instead of dumping logic into a project’s Source/ folder, I now ask a simple question:
- Does this belong to this game?
- Or does this belong to every game I’ll ever make?
If it’s the second one — it’s a plugin.
That question alone has saved me hundreds of hours.
My New Workflow (And Why It Finally Stuck)
Today, my workflow looks like this:
- Start a minimal game project
- Add my core plugins:
- Inventory
- Interaction
- Weapons / tools
- Save & persistence
- Common UI helpers
- Build only game-specific logic in the project
- Improve plugins as real needs emerge
- Carry those improvements forward forever
Every new project now starts ahead of the last one.
That was the missing piece for years — believing that future-me would actually benefit from the work I was doing today.
Plugins only make sense when you trust that you’re going to keep going.
Where AI Fits Into This (And Where It Doesn’t)
AI didn’t replace my thinking — it accelerated it.
I use AI to:
- Bounce architecture ideas
- Sanity-check plugin boundaries
- Recall Unreal Engine APIs faster
- Refactor or clean up repetitive code
- Keep momentum when I’d otherwise stall
I don’t use it to:
- Blindly generate systems
- Skip understanding
- Make architectural decisions for me
The biggest benefit hasn’t been code generation — it’s been not being alone with every decision. When uncertainty doesn’t stop you, progress compounds.
The Compound Effect of Reuse
Once systems became plugins, something unexpected happened:
- Bugs got fixed once
- Improvements paid off forever
- Prototypes became production-ready faster
- New ideas no longer required rewrites
Each plugin became a force multiplier instead of a sunk cost.
For the first time, my work started compounding instead of resetting.
From “Game Projects” to a Framework
I no longer think of myself as:
- “Working on a game”
I’m:
- Building a framework
- With games as implementations
- And plugins as the foundation
That shift — more than any engine feature or tutorial — unlocked sustainable momentum.
Final Thoughts
If you’ve been restarting projects over and over, ask yourself:
- What systems am I rebuilding?
- Why aren’t they reusable?
- What would change if they were plugins?
For me, the answer wasn’t technical — it was psychological.
Once I committed to continuity, the architecture followed.
Games come and go.
Frameworks get better forever.
And with Unreal Engine 5, a plugin-first mindset, and AI as a thinking partner, I finally feel like I’m building on my work instead of constantly starting over.