The bloated horizon of gaming: profit over craft

Video games are no longer a niche pastime. They are a cultural and economic powerhouse, generating more revenue than film and music combined. Franchises like Call of Duty, FIFA, or Grand Theft Auto rake in billions, and major publishers rival Hollywood studios in size and scope. On the surface, this should be a golden age for gaming: more money, more talent, more technology than ever before.

Yet beneath the glossy trailers and pre-orders lies a troubling reality. Games today are often released in a broken, unfinished state, requiring day-one patches, hotfixes, and months of debugging, if fixes ever come at all. Storage requirements have ballooned into the hundreds of gigabytes, hardware demands grow absurd with every new release, and code optimization, once the pride of the industry, has been abandoned in favor of brute force computing.

This paradox is glaring. At a time when developers have access to unprecedented tools and budgets, players encounter worse technical quality than they did decades ago. What was once a culture of ingenuity, where programmers squeezed every last drop of performance from limited hardware, has become an industry that assumes endless power and disk space are there to cover inefficiency.

And yet, hope remains. Independent studios and rare exceptions among major developers prove that optimization and artistry are still possible. With small teams, modest budgets, and constrained resources, they deliver polished, innovative games that stand in stark contrast to the bloated releases of corporate giants. The industry is profitable, but its soul seems increasingly fractured.

Monetizing an industry

Video game development has always been a business, but in recent decades it has become an industry dominated by profit-first logic, often at the expense of craftsmanship. The sums involved are staggering. The global games market surpassed $180 billion annually, eclipsing movies and music combined. Major releases can gross more than Hollywood blockbusters in their first weekend. For publishers and investors, the incentive is clear: ship fast, market hard, and monetize aggressively.

The consequences are obvious to players. Instead of being finished works of art, games are now products designed for maximum revenue extraction. Budgets that once went primarily to development are now heavily allocated to marketing, ensuring massive hype before release. Pre-orders, deluxe editions, season passes, and microtransactions dominate launch cycles, while actual game quality becomes secondary.

The business model has shifted. Where once developers succeeded by creating great experiences that earned loyal followings, today they succeed by creating hype cycles and revenue streams. Annual franchises push out installments whether they are ready or not. Online games launch half-baked, with the promise of “live service” updates to justify their unfinished state. And instead of optimizing code for efficient use of hardware, studios rely on players to upgrade PCs and consoles just to run bloated executables.

This logic rewards quantity over quality. Investors measure success in units shipped and microtransactions sold, not in player satisfaction or technical excellence. Crunch culture, forcing developers to work extreme hours, remains rampant, not in pursuit of perfection, but in pursuit of deadlines. And ironically, even with these sacrifices, the final products often launch with glaring bugs and poor optimization.

The industry of profit has also created a distorted relationship between developers and players. Once, developers were seen as craftsmen and storytellers. Now, studios too often see players as consumers to be mined. Engagement is measured in hours played and dollars spent, not in joy, immersion, or artistry. This shift explains why so many big-budget games feel interchangeable: polished marketing shells hiding technically unstable, creatively diluted content.

The tragedy is not that the industry is profitable. Profit could, in theory, fuel innovation and excellence. The tragedy is that profit has become the only priority, and the culture of optimization, creativity, and respect for the player has been left behind.

Release now, fix later

If there is one phrase that defines the modern video‑game industry, it is this: release now, fix later. What once would have been unthinkable, selling a broken product to millions of customers, has become standard practice, and it is not a rare accident; it is a business strategy.

Big‑budget games today are frequently released with bugs so severe that they compromise basic playability, graphics fail to render, quests break midway, save files corrupt, multiplayer servers collapse. Where such flaws would once have doomed a studio’s reputation, they are now shrugged off as temporary inconveniences to be “patched soon”. A notorious example is Cyberpunk 2077: marketed for years as a generational leap, it launched riddled with bugs, glitches, and performance issues so severe that Sony pulled it from the PlayStation Store, an unprecedented move for a high‑profile title. Yet, despite refunds and outrage, the game still sold millions, proving to publishers that a broken launch is still profitable if the marketing is strong enough. Cyberpunk is far from an isolated case; Assassin’s Creed Unity shipped with horrifying facial glitches that went viral as memes, Battlefield  2042 launched missing entire features, leaving fans bewildered at how a franchise with such pedigree could regress so dramatically, and even Nintendo’s Pokémon Scarlet and Violet, a company once famed for polish, were marred by performance issues and bugs that baffled players.

To mitigate the fallout, developers now lean on massive day‑one patches, enormous downloads released alongside the game, as the industry’s safety net. They ship an incomplete build to meet release dates, then scramble to fix glaring issues at the last minute, meaning that for players without high‑speed internet, buying a game can literally mean purchasing something that does not work as intended out of the box. This culture normalizes incompetence: instead of “gold‑master” discs being a sign of quality assurance, they become placeholders, dependent on future patches to become functional, and physical ownership itself loses meaning if the product inside is unplayable without a download.

Even more troubling, many titles are never fully fixed, even years later. Some limp along with partial updates, while others are abandoned outright. Promises of “live‑service updates” often translate into half‑hearted bug fixes and a quick pivot to monetization, turning the player into a beta tester who paid for the privilege. This model erodes trust: trailers, previews, and even early reviews frequently showcase an idealized version of the game, while the reality at launch is messy and incomplete. Studios rely on the inertia of hype; by the time players realize how broken the product is, the sales have already been booked.

The persistence of the “release now, fix later” mindset is rooted in financial incentive. Pre‑orders guarantee revenue before word‑of‑mouth spreads, marketing budgets dwarf development budgets, ensuring that hype drowns out criticism at launch, and investors favor predictable release schedules over unpredictable polish. Most players, though frustrated, continue to buy the next installment, hoping this time will be different. Consequently, studios are rewarded not for delivering finished products but for managing expectations; as long as players tolerate broken launches, publishers have little reason to change.

Behind these broken releases lie exhausted developers. Crunch culture forces teams to work extreme overtime, yet deadlines remain immovable because marketing campaigns are locked months in advance. Developers know the game isn’t ready, but management ships it anyway, resulting in a double betrayal: players receive a broken product, and developers see their hard work ridiculed in memes of glitched characters and broken AI.

Over time, this culture gnaws at the relationship between creators and consumers. Once, developers earned loyalty by delivering polished, finished works that exceeded expectations. Today, players approach major releases with cynicism, waiting weeks or months to see if the game will “actually work”. Trust, once broken, is hard to regain, but as long as profits keep rolling in, the industry seems willing to gamble with it. The tragedy is not merely technical; it is cultural. Games have become disposable experiences: launched broken, patched partially, and swiftly replaced by the next installment, eroding the sense of permanence and the feeling of owning and treasuring a complete work.

Hardware as a crutch

In the early days of gaming, developers had no choice but to optimize ruthlessly. Consoles and computers shipped with kilobytes of RAM, limited storage, and processors that look feeble by today’s standards, so every line of code mattered. Entire worlds were crafted with painstaking efficiency, fitting inside cartridges that rarely exceeded a few megabytes. Those constraints became a source of creativity, pushing developers toward elegant solutions, clever compression techniques, and inventive design.

Today the situation has reversed. Rather than squeezing performance out of modest hardware, developers simply offload inefficiency onto the player’s machine. Modern games arrive with enormous storage requirements, often 100 GB or more, and demand top‑tier GPUs and CPUs. What once was a feat of software engineering has turned into a brute‑force operation.

Modern releases are frequently bloated with unused assets, uncompressed textures, and inefficient code paths. Instead of polishing shaders, studios assume players will upgrade their graphics cards; instead of refining AI logic, they let raw CPU horsepower handle messy calculations. This shift places the burden on consumers, who must purchase ever‑more powerful hardware to compensate for lazy code. The proof is everywhere: old games a few kilobytes inside showcase what elegance and restraint can achieve, while contemporary AAA titles require 150 GB installs, half of which may consist of poorly compressed audio or redundant data. Games like Call of Duty: Warzone have ballooned past 200 GB, consuming nearly half the capacity of a console’s drive. This is not innovation, it is complacency.

Each new console generation is marketed with promises of “next‑gen graphics” and “unprecedented realism”, yet many of those advances are purely cosmetic, masking the fact that basic optimization has regressed. Players marvel at cinematic cutscenes while enduring frame drops, texture pop‑ins, and loading stutters. Performance issues that would have been unthinkable on 8‑bit hardware are now excused as “normal for launch”. The message is clear: instead of doing more with less, the industry does less with more, trading ingenuity for hardware escalation.

Even astronomical budgets and cutting‑edge hardware requirements cannot rescue a project lacking solid fundamentals. The most recent cautionary tale is Concord, Sony’s heavily marketed live‑service shooter. Though positioned as a PlayStation flagship, it was effectively stillborn, plagued by poor reception, technical missteps, and a lack of originality. Millions were poured into development and promotion, yet the game faltered almost immediately. The irony is stark: Concord had the hardware, the budget, and corporate backing, but it lacked the optimization, innovation, and polish that give a title staying power. It is not alone; countless big‑budget projects collapse under their own weight, delivering gigantic installs and staggering system requirements without substantive content.

Contrast this with FromSoftware’s Dark Souls, released over a decade ago. Despite its vast, interconnected world, the game occupied a fraction of the disk space of modern titles and ran on modest hardware. Its seamless design, no loading screens between zones, carefully engineered memory management, was a triumph of programming. Classics like Doom have been famously ported to everything from calculators to pregnancy tests, demonstrating that well‑optimized code can be lightweight and universal.

Relying on hardware to compensate for sloppy software alienates the audience. Players who cannot afford the latest graphics card or a console with terabytes of storage are left behind, raising the barrier to entry not because games are truly more sophisticated, but because they are more bloated. This mindset also fuels a cycle of waste: bigger files, bigger patches, bigger requirements, all masking modest gains in genuine innovation.

At its heart, the reliance on hardware is not merely a technical issue but a cultural one. It reflects a loss of pride in craftsmanship. Where once developers competed to fit complex worlds into tiny cartridges, today they compete to see how much disk space they can justify. The artistry of coding has been replaced by the assumption that the player will buy a larger hard drive. In that assumption, something vital has been lost: the belief that software should respect the limits of machines, not abuse them.

The lost art of coding

In the early decades of video games, programming was as much an art form as a technical discipline. Developers wrestled with brutal hardware limits, 8‑bit processors, cartridges measured in kilobytes, and minuscule memory, and those constraints actually fueled creativity. Every byte mattered, every instruction had to be efficient, and games became miracles of optimization and ingenuity, built by people who treated the machine not as a brute‑force tool but as a precise canvas.

The contrast between those early efforts and today’s sprawling installations is staggering. Super Mario Bros. for the NES was just 40 KB, small enough to sit inside a modern text file; The Legend of Zelda: Ocarina of Time ran on a 32 MB cartridge; Half‑Life shipped on a single CD‑ROM occupying 400 MB. None of those titles were simplistic, they were expansive, immersive, and innovative, proving that limitations breed brilliance. By comparison, even modest modern titles routinely balloon to 100 GB or more, and a single update for a multiplayer shooter can eclipse the total size of those classics. Rather than shrinking code and data through clever compression, many developers now lean on terabyte drives and high‑speed internet to mask inefficiency.

This 1 KB chess example captures the lost spirit perfectly: a fully functional chess game in JavaScript fits into a single kilobyte, reminding us that elegant logic and careful design can achieve wonders in tiny spaces. Yet today even basic games sometimes ship with requirements that dwarf entire operating systems of the past, showing that inefficiency is a choice, not a necessity:

for(B=y=u=b=0,x=10,z=15,I=[],l=[];l[B]=("ustvrtsuqqqqqqqq"+"yyyyyyyy}{|~z|{}@G@TSb~?A6J57IKJT576,+-48HLSUmgukgg OJNMLK IDHGFE").charCodeAt(B)-64,B++<120;I[B-1]=B%x?B/x%x<2|B%x<2?7:B/x&4?0:l[u++]:7);X=(c,h,e,S,s)=>{c^=8;for(var T,o,L,E,D,O=20,G,N=-1e8,n,g,d=S&&X(c,0)>1e4,C,R,A,K=78-h<<9,a=c?x:-x;++O<99;)if((o=I[T=O])&&(G=o&z^c)<7){A=G--&2?8:4;C=9-o&z?l[61+G]:49;do{R=I[T+=l[C]];g=D=G|T+a-e?0:e;if(!R&&(G||A<3||g)||(1+R&z^c)>9&&G|A>2){if(!(2-R&7))return K;for(E=n=G|I[T-a]-7?o&z:6^c;E;E=!E&&!d&&!(g=T,D=T<O?g-3:g+2,I[D]<z|I[D+O-T]|I[T+=T-O])){L=(R&&l[R&7|32]*2-h-G)+(G?0:n-o&z?110:(D&&14)+(A<2)+1);if(S>h||1<S&S==h&&L>2|d){I[T]=n,I[g]=I[D],I[O]=D?I[D]=0:0;L-=X(c,h+1,E=G|A>1?0:T,S,L-N);if(!(h||S-1|B-O|T-b|L<-1e4))return W(I,B=b,c,y=E);E=1-G|A<7|D|!S|R|o<z||X(c,0)>1e4;I[O]=o;I[T]=R;I[D]=I[g];D?I[g]=G?0:9^c:0}if(L>N||!h&L==N&&Math.random()<.5)if(N=L,S>1)if(h?s-L<0:(B=O,b=T,0))return N}}}while(!R&G>2||(T=O,G|A>2|z<o&!R&&++C*--A))}return-K+768<N|d&&N};Y=(V)=>{X(8,0,y,V);X(8,0,y,1)};Z=(U)=>{b=U;I[b]&8?W(I,B=b):X(0,0,y,1)}

The classic Doom illustrates how efficient, well‑structured code travels everywhere, it has been ported to calculators, printers, refrigerators, and famously a pregnancy test. This isn’t just a meme; it demonstrates that optimization grants software a universality that bloated modern games can never achieve.

Consider Dark Souls, released in 2011. In just a few gigabytes, FromSoftware built a vast, interconnected world with no loading screens between zones (except when fast‑traveling). The game streams environments seamlessly, managing memory and assets so elegantly that it feels endless despite its compact footprint. That level of craftsmanship, creating expansive experiences without overwhelming hardware, was once the norm.

By abandoning optimization, the industry has also abandoned respect for the machine. Programmers once took pride in outsmarting hardware limits; today the assumption is that hardware will simply get stronger, storage cheaper, and bandwidth wider. This false economy raises costs for players, increases environmental waste, and discourages true innovation. Optimization is not merely about smaller files; it embodies discipline, elegance, and respect for the player, distinguishing code that lasts decades from code that clogs hard drives until the next update.

What we have lost, therefore, is not just technical efficiency but a mindset: the belief that every byte counts, that software should be a lean masterpiece rather than a bloated commodity. The masterpieces of the past, the 1 KB chessboard, the 40 KB Super Mario Bros., the 32 MB Ocarina of Time, the endlessly portable Doom, are not relics but reminders of a forgotten ethic of programming. In their place, we are left with gigabyte monsters that strain even the most powerful hardware, often without delivering comparable leaps in design or gameplay. The artistry of code has been sacrificed on the altar of profit and speed.

The hope of indies

Amid the excesses of bloated AAA development, a countercurrent of hope persists: independent studios and smaller teams, often working with limited budgets and skeletal staff, continue to demonstrate what can be achieved when craftsmanship, focus, and optimization take precedence over profit‑driven bloat.

Take Mortal Shell (2020) from Cold Symmetry, a team of fewer than twenty people. They delivered a tight, atmospheric Souls‑like experience that rivaled projects built by hundreds of developers. While not flawless, the game proved that discipline and vision can outshine scale and budgets, because every element had to be carefully considered, there was simply no room for waste. A similar story unfolded with Lies of Pi (2023) from Neowiz. Though larger than most indies, the studio still operated with modest resources and crafted a polished title that surprised critics and players alike. Its success rested not on gimmicks or marketing hype but on refined gameplay and respect for the genre’s traditions.

Even among bigger studios, a few remain committed to the old ethic of optimization. FromSoftware, with titles (in addition to Dark Souls) such as Bloodborne, Sekiro, and Elden Ring, continues to amaze not only with design but with technical elegance. Dark Souls became a touchstone because of its seamlessly interconnected world, compact size, and intelligent memory use; Elden Ring, despite being vastly larger, still runs within a fraction of the space consumed by other open‑world behemoths. These are programming marvels achieved not by brute force but by careful engineering.

What unites indies and studios like FromSoftware is their embrace of constraints as creative fuel. They cannot afford to waste gigabytes on sloppy assets or assume players possess infinite hardware power. Instead, they optimize, refine, and polish, producing works that feel tighter, smarter, and more enduring than the disposable blockbusters of larger publishers. This echoes the spirit of the early gaming era: doing more with less, treating code as craft rather than mere production.

Contrast this ethic with high‑budget disasters such as Concord. Despite enormous financial backing and industry hype, the project collapsed almost instantly, remembered as a stillborn title that offered nothing new. The lesson is clear: money and manpower do not guarantee quality, and smaller, more disciplined teams often deliver more meaningful results.

Players are not blind to these differences. The rise of indie hits like Hollow Knight, Celeste, and Undertale shows that audiences hunger for polish, creativity, and substance over spectacle. Built with limited resources, these games command loyalty because they respect the player’s time and the machine they run on. The hope embodied by indies lies not merely in commercial success but in the reminder that the lost art of coding and optimization is still alive wherever passion outweighs profit.

However, this hope is fragile. Independent developers face financial precarity, burnout, and the risk of being crushed by the marketing juggernauts of larger publishers. Their survival depends on loyal audiences and platforms willing to showcase them. If corporate monopolies crowd them out, the industry risks losing its last connection to its own craft.

For now, the indie spirit persists, proving that great games do not need to be massive, bloated, or broken. They need vision, discipline, and the courage to put artistry before profit.

Culture vs craft

If the lost art of optimization still thrives in indies and a handful of dedicated studios, why has it all but vanished from the mainstream? The answer lies in the culture of corporate game development, a culture that rewards speed, marketability, and monetization far more than artistry or discipline.

AAA studios today are massive operations. A single blockbuster may involve hundreds or even thousands of employees spread across multiple continents, all coordinated under the tight grip of publishers and investors. In such environments, the notion of programming as craft is drowned out by management priorities: ship the game by the end of the fiscal quarter, hit sales projections to satisfy shareholders, and integrate revenue streams such as microtransactions, DLC, or live‑service models. Craftsmanship, writing elegant, efficient code, refining mechanics until they shine, optimizing performance, is seen as a luxury; what matters is launching on time with enough content to generate buzz and monetization hooks firmly in place.

Corporate reward structures exacerbate this trend. Managers and executives are compensated for meeting deadlines and maximizing revenue, not for nurturing technical excellence. Developers who cut corners to hit milestones may be praised, while those who argue for extra time to polish code are labeled “obstacles”. The result is a culture where shortcuts become institutionalized: why spend weeks refining memory management when you can demand players upgrade to the latest GPU? Why compress assets when storage is cheap and download speeds are high? Optimization, once the hallmark of good programming, becomes economically irrational in a system that prizes speed over craft.

The infamous crunch culture, excessive overtime in the final months before release, is another symptom. Crunch does not exist to perfect code or polish mechanics; it exists to push incomplete products across the finish line in time for marketing campaigns. Developers work themselves to exhaustion, but the time is spent firefighting, patching, and meeting arbitrary deadlines rather than crafting elegance.

Large studios also struggle under layers of bureaucracy. Teams scattered across the globe each handle tiny slices of a project, making it nearly impossible to foster holistic craftsmanship. A shader programmer in Montreal may never interact with the AI team in Tokyo or the quest designers in San Francisco. Codebases fragment, coordination becomes cumbersome, and optimization suffers amid the chaos. By contrast, small indie teams, though resource‑constrained, often share direct communication and ownership of their projects. A single programmer may handle multiple systems, gaining a holistic view of performance and design, which fosters efficiency because everyone sees the full picture, not just their isolated piece.

Marketing further drives the problem. In the AAA space, games are treated as products to be sold before they are played. Cinematic trailers, pre‑orders, and influencer campaigns build hype months or years ahead of launch. By the time the game reaches players, the profit is already locked in. This incentivizes surface‑level polish, beautiful trailers, flashy demos, while allowing the actual product to launch broken. Developers know they can patch later; marketers know the sales are secured. The result is a disconnect between craft and commerce.

What has been lost above all is pride in craft. In the early days of gaming, programmers took pride in squeezing miracles out of machines; code was elegant not just out of necessity but out of ethos. Today, in AAA culture, pride has shifted to sales figures, marketing campaigns, and franchise profitability. The erosion of this cultural value explains why optimization has disappeared. It is not a lack of talent, the industry is full of brilliant programmers, but the structures above them do not reward their brilliance, and often actively discourage it.

The cost of losing craft is felt not only in bloated file sizes and buggy launches but in the soul of the medium. Games cease to feel like carefully built works of art and increasingly resemble disposable products churned out for quarterly earnings. Players notice the difference between a world built with care and one assembled to meet a deadline. When trust erodes, the entire industry suffers.

Profit without skill

The paradox of the modern video‑game industry is that it has never been more profitable, and yet it has rarely felt so careless. Billions are spent on development and marketing, launches are more spectacular than Hollywood premieres, and studios employ thousands across the globe. Yet when the dust settles, what reaches the player’s hands is too often a product riddled with bugs, bloated beyond reason, and reliant on brute‑force hardware to compensate for what once would have been seen as amateurish inefficiency.

The culture of release now, fix later has normalized the idea that unfinished software is acceptable as long as it can be patched later. The faith once placed in developers as craftsmen has been eroded by the logic of quarterly deadlines and investor satisfaction. Players are no longer treated as an audience to delight, but as a captive market whose wallets can be mined through pre‑orders, DLC, and microtransactions. And when trust erodes, when launches like Concord collapse into failure despite astronomical budgets, the tragedy is not just financial; it is cultural. What dies in those moments is the sense that games are art, built with respect for both machine and player.

But the hope is still visible. Independent studios, often working with budgets that wouldn’t cover the marketing spend of a AAA release, continue to craft experiences that resonate deeply. Their survival depends on polish and ingenuity, because they cannot afford to rely on hype alone. When Cold Symmetry built Mortal Shell, or when Neowiz released Lies of P, what players found was not bloat but discipline, not excess but focus. And FromSoftware stands as a reminder that even within the larger industry, excellence is still possible when code is treated as craft. In just a few gigabytes, Dark Souls or Elden Ring create worlds more alive and interconnected than many blockbusters hundreds of gigabytes in size. That is not a matter of money, but of philosophy.

What gaming has lost is not technology, but restraint. Once, developers competed to see how much they could fit into how little. Today, they compete to see how much they can demand from hardware and from their players’ patience. The art of optimization, symbolized in something as small as a 1 KB chess game or in the timeless portability of Doom, is a cultural ethic the industry has allowed to decay. The result is not only technical waste, but a loss of respect, for machines, for developers, and for players.

If the industry wishes to recover its integrity, it must once again put talent above deadlines and craft above profit. It must rediscover pride in writing efficient code, not in marketing inflated trailers. Profit will always matter, but profit without craft is hollow. The proof is in every stillborn failure, every bloated launch, every patch that arrives too late. The future of gaming cannot be built only on hype and money. It must be built on the same principle that once defined the medium: the belief that every line of code counts, and that respect for the player begins not in the marketplace, but in the craft itself.