Scrum Master Toolbox Podcast: From Deterministic to AI-Driven—The New Paradigm of Software Development

Guest: Markus Hjort (CTO, Bitmagic)
Host: Vasco Duarte
Date: October 9, 2025

Episode Overview

In this bonus episode, Vasco Duarte speaks with Markus Hjort, CTO of Bitmagic and a veteran developer, about the current transformation in software development brought on by AI-assisted coding. They explore “vibe coding” (sometimes called “wipe coding”)—the practice of specifying software through prompts while AI generates most of the implementation. Markus shares his hands-on experience navigating this paradigm shift, lessons learned, changing team dynamics, and predictions for the near future.

Key Discussion Points & Insights

Defining "Vibe Coding" in Practice

• Hybrid Model: Markus describes "vibe coding" as working between a product owner’s perspective and a technical coder.
  • “For me it is that I am specifying the features by prompting using different agent tools. The agent is producing the code. I will check how it works and then also kind of a glance on a code.” [03:21]
• Levels of Engagement: Sometimes, he closely inspects architectural decisions; other times (e.g., with CSS), he trusts the AI as long as visual results look right.
• Adaptable Approach: The task dictates how much Markus relies on the AI versus intervening.
  • “I relax sometimes also more and do more.” [07:58]

The Evolution: From Copilot to Full Agentic Coding

• Multiple Phases:
  1. Early AI tools like GitHub Copilot did code completion—useful but incremental improvement. [09:12]
  2. Chatbots like ChatGPT and Claude: valuable for learning and generating code snippets for unfamiliar domains.
  3. Agentic Coding Tools (e.g., Cursor, Claude Code): Markus’s workflow now, with agents writing upwards of 90% of his code.
  • “It’s just that I can’t beat AI anymore… it’s just like, be faster.” [12:44]
  • The reality of working “unplugged” (without AI assistance) now feels awkward and limiting.
    • “Should I start coding by hand? Coding by hand?” [13:12]

Paradigm Shift: From Deterministic to Probabilistic Programming

• Analogy to Past Innovations: Transition to AI coding is like moving from assembly to higher-level languages, but with a key difference—LLMs are non-deterministic.
  • “When you’re moving from low level language to higher, they are still deterministic… but now the LLMs, it’s not deterministic anymore, and it actually changes how you have to think about.” [14:47]
• Managing Unpredictability: Need to learn new habits, such as when and how to reset context, and accept that the same prompt may yield different results.

Practical Habits for AI-Assisted Coding

• System Prompts and Context: Use system prompt files to anchor AI behavior, and reset context when things go off the rails.
• Multiple AIs for Tough Problems:
  • Discuss design/architecture in one (e.g., ChatGPT/Claude).
  • Use a code-oriented agent for implementation (e.g., Cursor/Claude Code).
• Frequent Version Control:
  • “Use local commits with git or something because there is a challenge that sometimes AI goes into this kind of loop that it tries to fix and whatever you do it just makes more and more mesh…” [20:00]
  • Markus’s “rule of thumb”: commit every ~30 minutes or after ~5 AI iterations, whichever comes first.
• Working in Small Steps:
  • Even though each commit may comprise more lines of code than in classical TDD, breaking work into manageable pieces remains essential.

Impact on Team Processes & Agile Practices

• Task and Story Sizing:
  • Stories can be much larger; individual developers can independently accomplish what used to require a team for a week.
    • “You have to give more freedom to individual developers... you have to get bigger tasks.” [26:10]
  • Detailed story splitting becomes less necessary and may even bottleneck productivity.
• Pair Programming with AI:
  • “That’s one metaphor… now the AI assistant is just like pair programming, except it’s much faster at typing.” [28:50]
  • Psychological barrier to working closely with humans doesn’t exist with AI—AI is always agreeable and never judgmental.
    • “It’s always like it never complains which is nice.” [30:03]
  • But, the human aspect is lost—AI “pairing” is not the same as real human rapport.
• Revisiting Reviews & Testing:
  • Code Reviews:
    • The high volume of code generated could overwhelm manual review processes.
    • Solution: More reliance on AI for reviews.
      • “We have to use more AI for reviewing code… have the different AI doing the review and so on…” [33:05]
  • Testing:
    • Increased manual/exploratory testing by developers—engaging more with the product itself.
    • AI is effective at generating unit tests but must be checked for validity (e.g., AI might write useless “assert true” tests if allowed).
    • Markus suggests it’s more important to review the tests than the main code.
      • “Reviewing the test code is actually often more important than actual that you’re actually testing the real test.” [35:32]
    • Incorporate process checks, e.g., “Test fails, then passes,” to ensure tests aren’t superficial.

Workflow Tips & Observations

• Manage Tool Limitations: LLM agent speed can block workflow—waiting for AI to respond interrupts flow.
• Leverage New Tool Capabilities: Some agent tools can automatically monitor running systems for errors during user testing, closing the loop between code generation and validation.

Predictions & Trends (Next 6–12 Months)

• Faster LLMs: Inference time is still an issue—future tools need to improve both speed and quality for less interrupted flow.
  • “I really hope that the elements don’t just get better… but they also improve the inference speed…” [37:56]
• Smarter Agents: Expect agents that not only code but also analyze, test, and possibly debug automatically as part of their workflow.
• Tooling Innovators: Markus calls out Replit as pushing boundaries with experimental new features. [39:43]
• Upskilling Approach: Instead of reading resources, try AI-driven agents hands-on for real tasks to truly understand and adapt to the new paradigm.

Notable Quotes & Memorable Moments

• “I now think always like, okay, should I code this like by hand? But then... it’s just that I can’t beat AI anymore. I mean it’s just like, be faster.” — Markus [12:44]
• “If every team member… have very strict code reviews… and you end up having like a 100 pull requests per day, so you’re in big trouble again.” — Markus [33:05]
• “Reviewing the test code is actually often more important than actual that you’re actually testing the real test.” — Markus [35:32]
• “I really recommend people to try some Claude code or cursor to do something even small with yourself and in a way that you don’t code yourself at all so that you get the experiments.” — Markus [40:15]

Suggested Timestamps for Important Segments

• [02:37] — Markus describes “vibe coding” and his approach.
• [09:12] — Three phases of adopting AI-assisted coding.
• [14:47] — Deterministic vs. probabilistic paradigm in software development.
• [19:17] — Using different AIs for design vs. implementation.
• [20:00] — Importance of version control and small steps.
• [26:10] — How AI changes task splitting and team collaboration.
• [33:05] — Rethinking code reviews and testing with AI-generated code.
• [37:56] — Hopes and predictions for the evolution of tools and workflow.

Resources and Links Mentioned

• Cursor
• Claude (by Anthropic)
• Replit
• Bitmagic (Markus’ game startup): bitmagic.ai
• Markus Hjort on LinkedIn: Markus Hjort LinkedIn

Final Takeaway

AI-assisted software engineering is not just a productivity tool—it’s an entirely new way of thinking, collaborating, and building software. As Markus and Vasco discuss, the paradigm is evolving rapidly, and the best way to keep pace is to get hands-on, share experiences, and remain mindful about the resulting risks, team impacts, and the profound shift towards non-determinism in software creation.