Suicide Squad development felt ‘like I wasn’t making games anymore,’ says director

"It felt like I wasn't making games anymore. " That single, damning quote from Suicide Squad: Kill the Justice League director Axel Rydby cuts to the heart of what has become an industry-wide crisis. When triple-A budgets meet live-service imperatives, creativity doesn't just bend-it breaks. As a senior engineer who has survived three live-service launches, I know that feeling intimately: the moment your sprint board becomes a funeral list for features that once sparked joy. Rydby's confession isn't merely a lament; it's a postmortem of an engineering culture gone wrong.

The game, released in early 2024 after years of development, was supposed to be Warner Bros. Games' crown jewel of recurring revenue. Instead, it became the latest cautionary tale in a graveyard that includes Anthem, Marvel's Avengers, Babylon's Fall. Underneath the glossy trailers and superhero branding lay a technical stack burdened by live-service mandates that clashed directly with the studio's heritage of story-driven, single-player experiences. Rydby's words echo what many developers whisper in private: when every feature must drive daily active users and engagement metrics, you stop engineering games and start manufacturing retention loops.

This article isn't a review of Suicide Squad-you can find those elsewhere. Instead, I want to unpack the systemic engineering failures that Rydby implicitly calls out. We'll look at technical debt accrual, misapplied Agile rituals. And the sociological collapse of a team forced to serve two masters: creative ambition and recurring revenue targets. If you're a tech lead, a product manager. Or a developer staring at a similarly troubled roadmap, read closely. The lessons from Rocksteady's ordeal are transferable to any software project where "minimum viable product" becomes an excuse for permanent beta.

The Soul-Crushing Reality of Live-Service Development

Rydby didn't specify the exact moment his soul-checked out. But we can infer the timeline. Rocksteady built its reputation on tightly crafted, single-player narratives: the Batman: Arkham series. Transitioning to a live-service model required not just a shift in design philosophy but a fundamental rewrite of the engineering pipeline. Instead of building a story that could be shipped once, the team had to architect a persistent world with seasonal content, monetization hooks. And daily challenges-all while maintaining the Rocksteady polish that fans expected.

From a software engineering perspective, this is a nightmare of competing constraints. Every new "season" is essentially a mini-release that must integrate with a constantly evolving codebase. In production environments, we've seen live-service games collapse under the weight of technical debt because feature teams rush to meet quarterly roadmaps. Rydby mentioned feeling disconnected from the craft of game-making. I suspect that disconnection came from watching features designed to Surprise players be gutted by monetization requirements-like skins replacing story beats, or progression systems being balanced around store purchases rather than fun.

The result is a dissonance that engineers at every level recognize: you're writing code not to delight a user. But to meet a churn threshold. Your daily stand-up discussions aren't about design elegance; they're about "How do we get the player to open the battle pass three times a week? " That shift, often subtle at first, is what Rydby means when he says, "like I wasn't making games anymore. "

Technical Debt: The Silent Killer of Creative Vision

Every game ships with some technical debt. But live-service titles accumulate it at an alarming rate because the business model demands concurrent features-new characters - map updates, seasonal events-all while patching bugs from the previous update. In Suicide Squad, early reports described a networking layer that struggled with player synchronization, leading to desyncs in co-op sessions. This is classic accumulation: the team prioritized content over infrastructure, betting that they could refactor later. "Later" never comes when quarterly earnings are at stake.

From an engineering management standpoint, this is a textbook failure of prioritization. The 2023 State of Software Engineering report by Stripe found that teams spending more than 30% of their sprint capacity on refactoring saw significantly lower burnout rates. But in live-service games, that number often hovers below 10% because product owners view refactoring as "non-visible" work. Rydby's lament suggests Rocksteady may have fallen into this trap: instead of allocating time to clean up the architecture, they piled new features onto a shaky foundation. The result? A game that feels technically dated despite modern graphics.

To make matters worse, the tooling for debugging live-service multiplayer stacks is notoriously poor. Unlike single-player games where you can reproduce a crash with a save file, multiplayer desyncs require distributed trace dumps and replay systems that most studios can't afford to build in-house. The technical debt spiral in AAA game development is well-documented-and Rydby's comments confirm that Rocksteady wasn't immune.

Why 'Games as a Service' Often Becomes 'Games as a Chore'

The phrase "games as a service" (GaaS) was originally coined to describe a revenue model: you ship a base game and sustain it with paid expansions. Over the past decade, however, it has mutated into a design philosophy that prioritizes retention over satisfaction. The game becomes a platform-and the platform's purpose is to keep players logging in, not to give them a meaningful experience. Rydby's quote implies that Rocksteady's team was forced to design systems that maximized engagement metrics rather than player joy.

Consider the infamous "daily challenge" loop. From a software engineering perspective, implementing a daily challenge system is trivial-a cron job, a set of event flags, some UI. But the engineering ease belies the design burden: every feature that's "daily" creates obligation. Players feel pressure to return. And developers feel pressure to maintain the treadmill. Over months, the core engineering team becomes a maintenance crew, patching the treadmill rather than building new rides. This is why many GaaS games feel soulless: the codebase is optimised for habit, not wonder.

Rocksteady's prior success with single-player games meant their internal culture was built around shipping a cohesive vision. When forced to adopt a live-service model, those engineers had to unlearn everything they knew about scope and finality. The cognitive load of constantly thinking about "what comes next" instead of "is this experience complete" is enormous. Rydby didn't just feel he wasn't making games-he felt he was maintaining a platform that happened to have superhero skins.

Lessons from the Trenches: Avoiding the Live-Service Trap

If Rydby's experience resonates, how do we avoid it? The first step is to acknowledge that not every IP belongs in a live-service ecosystem. Suicide Squad was a perfect mismatch: a dark, narrative-heavy property forced into a bright, loot-driven world. For engineering teams, this translates to validating whether your technical architecture can support sustained iteration without collapsing under its own weight. Perform a live-service readiness audit before committing: can your CI/CD pipeline handle weekly patches? Do you have a feature flag system robust enough to toggle broken content without a hotfix? If the answer is no, you're building a house of cards.

Second, fight for dedicated refactoring time. I've seen teams allocate "hack weeks" or "innovation sprints" to pay down technical debt, and this isn't a luxury; it's risk managementFor live-service projects, you should automatically reserve 20% of each sprint for bug fixes, architectural improvements. And tooling enhancements. Without that buffer, your codebase will degrade to the point where adding a new weapon requires touching 15 files-and that's when productivity nosedives and morale follows.

Third, ensure your product owners understand the difference between "engineering work" and "feature work. " All too often, technical debt tickets are de-prioritized because they don't move the engagement needle. But as Rydby's story shows, ignoring tech debt eventually makes the game unshippable. The best way to get buy-in is to quantify the risk: "If we don't refactor the matchmaking module now, we will hit a scalability wall at 50,000 concurrent users. " Use data and projections to justify the cost of inaction.

How Agile Methodologies Fail When Misapplied in Game Development

Agile was designed for software projects where requirements evolve rapidly. But game development isn't software development in the traditional sense-it involves art, narrative. And design loops that resist rigid two-week sprints. When Rocksteady tried to apply Agile to a live-service transformation, they likely encountered the friction of "story points" being assigned to creative tasks that cannot be broken down into discrete units. A cutscene isn't a user story; it's a complete experience that emerges from collaboration.

Rydby's feeling of disconnection may also stem from Agile ceremonies that replace creative review with status updates. Instead of playing the game and feeling the magic, teams spend hours estimating backlog items. The Scrum Guide explicitly warns against using Agile as a straightjacket, yet many studios enforce it as dogma. For a live-service title, this can be catastrophic: the gameplay loop is the product. And if you aren't iterating based on feel, you're iterating based on metrics that may not correlate with fun.

The fix is to adopt a hybrid model-sometimes called Water-Scrum-Fall-where the creative phase is allowed to be messy and unbounded before locking into sprints for technical implementation. Rocksteady's history suggests they had strong creative rituals from the Arkham days. A move to pure Scrum may have dismantled those rituals without replacing them with something better. Rydby's complaint isn't that Agile is bad. But that it was applied to the wrong layer of the development stack.

The Role of Management in Killing Developer Morale

Rydby didn't name specific executives. But the pattern is familiar: upper management sets revenue targets far exceeding realistic player acquisition, then exerts pressure on directors to compromise on quality. In Suicide Squad, We saw reports that Rocksteady struggled with frequent pivots-from the game's tone to its monetization strategy. Each pivot created cascading technical changes: character kits had to be rebalanced, progression systems redesigned. And server logic rewritten. For the engineering team, this mean rewrites of features they had already shipped, erasing their sense of progress.

In my own experience, nothing kills morale faster than building a system and then being told to throw it away because management changed the business model. It's not just wasted effort-it's a loss of ownership. Engineers stop caring about code quality because they assume it will be scrapped anyway. Rydby's quote suggests this cynical mindset settled over Rocksteady: why polish a weapon when next quarter's loot box rework will gut it? The result is a soulless product built by people who have emotionally checked out.

To prevent this, management must commit to a stable product vision before engineering begins. This is easier said than done. But the cost of indecision is clear in Rydby's story. One practical tool is a "decision record" similar to an Architecture Decision Record (ADR): when pivoting, document the cost of the change in engineering hours and morale impact. If the business still decides to pivot, at least the team sees the tradeoff made transparently. Rocksteady's culture of secrecy around its direction likely exacerbated the problem.

What Suicide Squad Teaches Us About Sustainable Engineering Culture

Sustainable engineering culture means holding space for craft. At Rocksteady, that space was eroded by the relentless demand of live-service updates. The irony is that a sustainable pace actually produces better business outcomes: games like No Man's Sky and Final Fantasy XIV turned around from disastrous launches by respecting developer time and iterating thoughtfully. Both of those teams had the luxury of being their own bosses, not beholden to a corporate quarterly cycle. But Warner Bros likely wanted a hit live-service game immediately-and that impatience is what crushes engineering culture.

One concrete recommendation for studio leadership: add a "no crunch" policy enforced by technical means. For example, require all builds to pass automated tests before deployment; this shifts quality left and removes the need for last-minute fixes that trigger death marches. The Continuous Delivery book by Jez Humble describes how automated pipelines give teams confidence to ship frequently without panic. If Rocksteady had such a pipeline, perhaps Rydby would have spent more time playing the game and less time firefighting deployment issues.

Additionally, consider rotating "innovation sprints" where developers can work on passion projects free from live-service constraints. This is common at Google and Atlassian, but rare in games. Yet those small bits of autonomy are exactly what Rydby says he lost: the feeling of making something for the joy of it, not for the metrics dashboard. Without that joy, even the best engineers burn out,

Is There a Future for Single-Player Experiences in a Live-Service World?

Rydby's story suggests that the industry is at a binary fork. On one path, studios accept that live-service games require a fundamentally different engineering culture-one built around constant iteration, high tolerance for technical debt. And a team that values operations over artistry. On the other path, studios double down on single-player, premium experiences that can be polished and shipped, knowing they won't generate recurring revenue but will preserve developer sanity.

The data favors the latter. According to a 2024 report from market analyst firm Newzoo, the fastest-growing segment of the PC/console market is premium single-player games, driven by titles like Elden Ring, Baldur'