There’s something extraordinary about watching a game like Grand Theft Auto VI come together. Beyond the obvious spectacle of its enormous environments, character detail and visual fidelity, what fascinates me most as a developer is the sheer number of decisions required to make something of this scale feel coherent. Every street, interaction, animation and seemingly insignificant object represents another layer of design, engineering and creative problem-solving.
I’ve been watching reviews and footage, and I keep finding myself looking past the obvious things. Rather than focusing on the size of the city or the action unfolding on screen, I’m looking at the rubbish on the pavement, the reflections in shop windows, the tiny details in character animations and the way the environment appears to respond to what’s happening around it.
Somewhere in that production process, someone has thought about how a drinks can should look, how its material reacts to lighting, where it belongs in the environment and potentially how it behaves when disturbed. It might seem like an insignificant detail, but multiply that thinking across thousands of objects and interactions, and you begin to appreciate the scale of the undertaking.
What impresses me isn’t simply that Rockstar has the resources to create something enormous. It’s the apparent commitment to following so many individual ideas through to a level of detail that most players will never consciously notice.
And I think there’s an important lesson here for indie developers.
The Compounding Complexity of Game Development
One of the most fascinating aspects of game development is how quickly relatively simple systems become interconnected.
Consider something as straightforward as a character walking through an environment. Initially, you might implement a movement controller, basic collision detection and a handful of animations. That’s enough to establish a functioning mechanic, but it’s only the beginning.
Introduce different surfaces and suddenly you need to consider footstep sounds, material properties and animation blending. Add rain and you might need wet surface shaders, particle effects, changes to audio and environmental reactions. Introduce NPCs and those systems must coexist with navigation, collision avoidance, animation states and behavioural logic.
None of these features exists entirely in isolation.
In a well-structured project, developers might use component-based architecture, event-driven systems, animation state machines and data-driven configurations to keep that complexity manageable. The goal is to make individual systems reusable and loosely coupled, so adding a new environmental interaction doesn’t require rewriting half the game.
Yet even with good architecture, the cost of complexity grows. A new mechanic might affect save systems, networking, physics, UI, accessibility, performance and testing. A feature that sounds simple during a design meeting can introduce weeks of work once all its dependencies are considered.
That’s why the apparent cohesion of a game like GTA VI is so impressive. We can’t know every detail of Rockstar’s internal implementation, but producing a world of that complexity requires extraordinary coordination between artists, designers, programmers, animators and technical teams.
The achievement isn’t merely creating thousands of features. It’s making those features work together convincingly.
The Invisible Engineering Behind the Details
Modern open-world development is an exercise in managing enormous technical constraints.
A detailed world can’t simply load every texture, mesh, animation and NPC into memory simultaneously. Engines need strategies for streaming assets, managing memory budgets and determining what the player can actually see.
Level of detail systems allow distant objects to use simplified geometry. Texture streaming helps prioritise the assets currently needed. Occlusion culling avoids rendering objects hidden behind other geometry, while world streaming allows different areas to load and unload as the player moves through the environment.
These systems aren’t glamorous, but they’re fundamental to creating the illusion of a continuous world.
There’s a similar challenge with NPC behaviour. A convincing city needs more than characters walking between predefined points. Developers must account for navigation, environmental awareness, scheduling, animation transitions and reactions to unexpected player behaviour.
Even relatively modest AI systems can produce surprisingly convincing results when combined thoughtfully. A behaviour tree controlling an NPC, for example, might be straightforward on its own. But connect it to environmental triggers, animation systems, dialogue and nearby characters, and suddenly that NPC begins to feel like part of a larger living environment.
The same principle applies to physics, audio and lighting.
It’s not necessarily the sophistication of any single system that makes a world believable. It’s the consistency with which those systems acknowledge one another.
And that’s where development time becomes particularly valuable.
The Dangerous 80%
We’ve probably all played games where the central idea is excellent, the technical foundation is solid and the environments look fantastic, yet something still feels incomplete.
Perhaps there’s a beautiful city where very little can be interacted with. Maybe an interesting mechanic is introduced early but never meaningfully expanded. Perhaps NPCs appear convincing until the player does something unexpected, at which point their behaviour exposes the limitations of the simulation.
Sometimes you can almost see where development had to stop.
That isn’t necessarily evidence of poor development. More often, it’s the reality of budgets, production schedules and difficult decisions about scope.
But there’s a particularly frustrating kind of game that feels 80% of the way towards something extraordinary.
The missing 20% isn’t always additional content. Sometimes it’s the refinement of existing systems, better feedback, more consistent environmental interactions or simply giving players more opportunities to explore the mechanics already present.
Technical polish also extends beyond appearance. It means predictable input handling, reliable state management, consistent frame pacing, robust save systems and the removal of frustrating edge cases.
A game can be visually spectacular and still feel unfinished if its underlying systems don’t behave consistently.
Conversely, a relatively simple game can feel wonderfully complete when every mechanic has been carefully considered.
The final stages of development aren’t always about adding more. Sometimes they’re about making everything already there feel intentional.
Why Indie Developers Should Still Make Small Games
Of course, there’s an enormous difference between admiring Rockstar’s ambition and attempting to reproduce it.
For independent developers, reducing scope remains some of the most valuable advice available. A smaller game can be developed, tested, marketed and released within a realistic timeframe. It allows developers to learn from actual players rather than spending years making assumptions about what those players might enjoy.
And financially, finishing matters.
There’s little value in building the foundations of an extraordinary game if the project becomes impossible to sustain.
At Sharkbowl Games, developing different types of games has reinforced how much knowledge transfers between projects. A puzzle game teaches lessons about readable environments, interaction feedback and level progression. An arcade game introduces different challenges involving physics, difficulty curves and responsive controls. More ambitious projects then benefit from those earlier experiences.
The technical foundations can compound too.
Reusable input systems, camera controllers, save architectures, editor tools, shader knowledge and production workflows can all reduce the cost of future development. A system built for one project may not transfer directly to another, but the experience of designing and maintaining it certainly does.
There’s a reason developers frequently recommend finishing small projects before attempting something enormous.
You learn how to complete the final stages of production, not merely the exciting beginning.
But I think we should be careful not to confuse reducing scope with reducing ambition.
Build a Smaller World, Not Necessarily a Shallower One
Imagine developing a game set entirely inside a single pub.
You don’t need an enormous city, hundreds of NPCs or a complicated open-world streaming system. Your entire game might take place in a handful of rooms.
But within that limited space, you could create something remarkably detailed.
Perhaps the regular customers have routines. Maybe the landlord remembers previous interactions. The music changes depending on the time of night. Characters react differently when a glass breaks, an argument begins or somebody enters the building.
From a technical perspective, you could achieve much of this with relatively modest systems: trigger volumes, finite state machines, event dispatchers, dialogue variables and persistent world states.
The complexity comes from designing how those systems interact.
A single event, such as knocking over a drink, might trigger an audio cue, change an NPC’s behaviour, update a relationship variable and create a new dialogue opportunity.
Suddenly, the environment feels responsive.
You haven’t built a larger game. You’ve built a deeper one.
And for smaller teams, that distinction can be incredibly powerful.
A tightly controlled environment allows developers to spend more time on the details players will encounter repeatedly. Instead of distributing resources across dozens of locations, you can concentrate on making a smaller number of spaces genuinely memorable.
It’s a different approach to ambition, but no less creatively valuable.
The GTA Approach: Building on What Came Before
Another thing I find fascinating about Grand Theft Auto is that the series didn’t begin with the scale or complexity we associate with it today.
The original games established the foundations of an idea. GTA III transformed the series through its move into a fully realised 3D environment. Vice City and San Andreas expanded its identity, atmosphere and possibilities. Subsequent entries continued developing the technology, simulation and presentation.
Each generation built upon lessons learned from the previous one.
This is worth remembering when planning an ambitious independent project.
Your first game doesn’t necessarily need to be your ultimate creative achievement.
Perhaps the first project establishes a movement system or combat mechanic. The next explores more complicated AI behaviour. Another introduces narrative systems or environmental simulation.
Over time, you develop both technical expertise and a better understanding of what actually makes your ideas enjoyable.
You might even discover that the enormous project you originally imagined becomes more manageable once you’ve developed several smaller games.
Not because the ambition has changed, but because your ability to realise it has improved.
Of course, there’s a limit to how much can be reused. Technology changes, codebases become outdated and different genres introduce different architectural requirements.
But experience compounds in ways that individual assets and scripts cannot.
Knowing When to Keep Developing
There is, however, another side to the conversation.
If a project has the funding, a sustainable production plan and a genuinely compelling creative direction, perhaps there are circumstances where continuing development is the right decision.
It’s easy to become obsessed with release dates, milestones and the pressure to get something onto Steam. Those pressures are real, particularly for independent studios where revenue from one release may determine whether another project can happen.
But releasing prematurely carries risks of its own.
Players generally experience the game as it exists on release day, not as the developer imagined it might eventually become.
If a central mechanic is underdeveloped, an important narrative sequence feels rushed or the technical foundation remains unreliable, those compromises can fundamentally change the player’s experience.
This doesn’t mean endlessly adding features.
In fact, feature creep can be one of the most destructive forces in development. Every additional system introduces testing requirements, dependencies and potential bugs. Beyond a certain point, more features can actively make a game worse.
The challenge is knowing the difference between adding unnecessary complexity and completing the original creative vision.
That requires honest playtesting, clear design pillars, technical discipline and the willingness to remove features that don’t contribute enough.
Sometimes the best decision is to cut something.
Sometimes it’s to spend another month making an existing mechanic feel wonderful.
And sometimes, if the circumstances allow it, it’s to keep developing because you know the project hasn’t yet reached its potential.
Making Games Worth Remembering
Watching GTA VI has reminded me why I love game development.
It’s not simply the technology, although the engineering is fascinating. It’s the idea that hundreds of small decisions can eventually produce something that feels greater than the sum of its parts.
A texture artist spends time refining a surface. A programmer improves the transition between two animation states. A designer adjusts an interaction that players might only encounter once. Someone spends an afternoon fixing an edge case that most people will never know existed.
Individually, those contributions might seem insignificant.
Collectively, they create the experience.
As indie developers, we can’t always afford that level of production. We have limited budgets, limited time and often an enormous number of responsibilities competing for our attention.
But we can adopt the underlying philosophy.
We can build smaller worlds with more deliberate interactions. We can develop reusable technical foundations, improve our production processes and allow each finished project to teach us something about the next.
Most importantly, we can recognise when an idea deserves additional attention rather than automatically moving on because the basic functionality is complete.
There’s a balance to find between finishing games and giving them the development time they deserve.
I don’t think every game needs to become a decade-long masterpiece. In fact, most probably shouldn’t.
But when you’ve found an idea that genuinely excites you, something with the potential to become much more than its initial prototype, I think there’s value in following that thought as far as your circumstances reasonably allow.
Make games small enough to finish, but give the ideas within them enough room to become something special.
Because sometimes the difference between a good game and a memorable one isn’t another enormous feature.
It’s the thousand tiny decisions that somebody cared enough to get right.
— Sharkbowl Games