Vibe Coding SimCity II: Injecting Chaos with Natural Disasters and AI Tools

In this episode of AI Native Dev, Simon Maple and Joe Holdcroft return for a chaotic continuation of their previous challenge. Having each created a town simulator app using BASE44 and Bolt.new, they now swap codebases and attempt to implement natural disasters using two different AI tools: Cursor and Windsurf. The twist? Neither developer knows what feature they’ll be adding until it's revealed live, and neither has seen the other’s code. The result is a candid, sometimes frustrating, and often hilarious exploration of how AI development tools perform in messy real-world contexts.

The Role of Disposable Code in Prototyping

This episode centers on disposable code: code written quickly to test ideas rather than built for long-term maintenance. Simon and Joe dive headfirst into modifying auto-generated, brittle applications, trusting AI to carry out changes on unfamiliar projects. Simon remarks on the benefit of BASE44 in building a prototype with minimal effort, noting, “I didn’t even look at the code.” This hands-off approach highlights the power of disposable code—how AI tools can generate working apps quickly with minimal developer intervention. However, the moment these apps require real changes or sustained iteration, cracks appear. The ease of creation masks fragility under the surface.

Challenges of Code Quality and Maintenance

The episode underscores the tension between rapid generation and reliable maintenance. Simon encounters repeated issues using Cursor to modify Joe’s app, getting stuck in feedback loops where the tool claims to apply fixes that never take effect. “Every time I was in that horrible, frustrating loop… it says it’s made it, but it hasn’t.” Joe, using Windsurf, sees a similar breakdown: linting conflicts, duplicated functions, and unclear working state. Both developers conclude that while AI tools excel at early prototyping, extending that code demands precision, validation, and patience—things often absent in disposable workflows.

The Importance of Context in AI Development

AI tools often struggle with contextual awareness, particularly when codebases are inconsistent or bloated. Windsurf, in particular, falls into multiple loops trying to fix ESLint issues it didn’t introduce, making repetitive and sometimes conflicting changes. Joe theorizes that Windsurf is analyzing its own diffs and erroneously flagging them as new bugs. Simon notes that context issues also affect output relevance: “It’s using that as context, so it would almost confuse itself a little bit with that potentially.” Without firm architectural boundaries and consistent naming conventions, AI tools lose track of intent, making reliable automation difficult.

Exploring Workflow Dynamics with LLMs

Simon and Joe both deviate from traditional workflows in this challenge. Neither reviews the unfamiliar code base; instead, they jump straight into issuing high-level prompts to modify features. This choice reflects a belief that the LLM can abstract away code understanding—until it can’t. As Joe remarks, “I’m not here to maintain this nice garden of code,” echoing a sentiment many prototype-driven developers share. But this blind trust quickly falters. Eventually, both revert to more manual strategies: inspecting UI, editing logic directly, and validating changes line by line—reintroducing human oversight as essential in the AI-assisted workflow.

The Impact of AI on Development Practices

Cursor and Windsurf offer different interpretations of what AI-assisted coding should look like. Cursor prioritizes speed and minimal friction—ideal for iterative prompting—but it struggles with large, compounding requests. Windsurf is more assertive and autonomous but overreaches, often rewriting massive code sections or enforcing strict linting prematurely. Both tools highlight AI’s current strengths and weaknesses: they are fast, flexible, and impressive in narrow scopes, but brittle and error-prone in broad or multi-step tasks. Simon sums it up: “Had I asked Bolt or BASE44 to do this from scratch, it would probably be more successful than asking Cursor to build on broken ground.”

Navigating Unforeseen Obstacles and AI Failure Modes

The devs encounter a variety of unanticipated challenges—many introduced by the tools themselves. Simon discovers that disasters resolve without the correct emergency services. Joe faces repeated compile issues due to out-of-order function declarations. Both observe that asking for multiple logical changes in one prompt results in partial or faulty implementation. Perhaps most revealing, both tools misreport what they’ve changed, making it hard to trust that fixes are actually present. Windsurf gets stuck in a lint-fix loop; Cursor repeatedly fails to update runtime behavior despite promising otherwise. The core insight: AI tools are fallible collaborators, and developers must expect and plan for this.

The Future of AI Coding Tools

As the episode winds down, Simon and Joe reflect on the current state and future promise of LLM-powered tools. They agree that today’s tools work best for generating greenfield prototypes but are less effective at building sustainable, editable codebases. Joe suggests these tools will shine most in one-off projects or when helping non-developers scaffold apps. Simon, despite his frustrations, notes how far the tooling has come, imagining how magical this would have seemed even four years ago. Both agree that tooling must improve in state tracking, context retention, and change validation to fully integrate into robust workflows.

Summary and Key Takeaways

In this feature-rich episode, the AI Native Dev team showcases the reality of AI-assisted coding in unpredictable terrain. Key lessons include:

• Disposable code excels at rapid scaffolding but collapses under feature extensions without solid foundations.
• Code quality and linting rules often conflict with AI-generated outputs, especially in multi-file changes.
• Context loss in tools like Cursor and Windsurf results in loops, misapplied fixes, and broken logic.
• AI tools must be scoped precisely; vague or compound prompts lead to inconsistent results.
• Human intervention remains essential for debugging, validation, and steering complex edits.

Ultimately, the episode is a candid snapshot of where AI dev tools succeed, where they break, and how real developers adapt in the face of both magic and mess.