Explorez tous les épisodes du podcast Rethink Engineering

What happens when you actually run a software factory? Steve Yegge, creator of Gas Town and Beads, runs around 50 AI agents on his long-running online game, Wyvern. In this episode he talks with Benedikt Stemmildt about what that looks like day to day: the breakthroughs, the breakdowns, and what enterprises should learn from it before they try it themselves.

Last week Steve burned down 40% of his own software factory. His agents had added more than a hundred safety gates until nothing could move, and it took a newer model, acting like an outside consultant, to cut the system back to 14. Then, with the fences gone, the agents shipped 46 game features during a week when Steve had said "no game work".

A note for longtime listeners: Waves of Innovation is now Rethink Engineering. Same feed, new name, and a new host: Benedikt Stemmildt, founder of hackers&wizards, takes over from Deejay. The show is now powered by re:cinq and hackers&wizards. Thanks for listening, and welcome to the next chapter.

In this episode:

• Why agents need mechanical constraints (governors, quotas, pace gates, message budgets) instead of common sense
• The factory that will "never be done": how adversarial reviews and a growing backlog turn all work into more work
• Steve's rule: spend 40% of your effort on code quality, or end up spending 60%
• A look inside Wheelhouse, Steve's control room for his agent fleet, and the merge queue clearing 230+ commits a day
• Why faster engineering pushes the bottleneck downstream, onto reviewers, business teams and customers
• Why enterprise AI is arriving "upside down": production agents on ticket queues succeed straight away, while automating the build side struggles
• Why the place to start is one narrowly scoped production agent, and why outcomes, not outputs, are the new North Star

Mentioned in this episode:

• Welcome to Gas Town (Steve's post): https://steve-yegge.medium.com/welcome-to-gas-town-4f25ee16dd04
• Gas Town: https://yegge.ai/gastown
• Welcome to Gas City: https://yegge.ai/essays/welcome-to-gas-city/
• Beads, the agent issue tracker: https://github.com/gastownhall/beads
• Dolt, the versioned database behind Beads: https://www.dolthub.com
• Wyvern, Steve's game: https://yegge.ai/wyvern
• Output to Outcome by Mik Kersten: https://outputtooutcome.org

Guest: Steve Yegge

Host: Benedikt Stemmildt, founder of hackers&wizards

Rethink Engineering, powered by re:cinq and hackers&wizards, is about how AI is changing the way software gets built. New episode every month.

WATCH THE FULL EPISODE HERE: https://re-cinq.com/podcast/steve-yegge-software-factory

The episode begins with a candid look at Dominic Warchalowski and his evolution from a staunch AI skeptic to a lead engineer driving a massive velocity increase at Odevo. Dominic recounts his early and frustrating experiences with isolated AI prompts, which frequently yielded hallucinations and eroded his trust. A significant pivot occurs when he is introduced to Claude Opus within a modern IDE environment, triggering an aha moment that fundamentally shifted his perspective on the capability of AI to handle complex engineering tasks.

The Technical Core
The heart of the episode explores the friction between legacy development methodologies and modern agentic speed. The duo laments the loss of traditional Kanban workflows, noting that when AI agents generate code at unprecedented speeds, conventional small batch pull requests quickly become massive bottlenecks. Dominic explains that you cannot simply fit AI into an existing process; the process must be redesigned around the AI. He details the ambitious project at Odevo to rebuild a five year old legacy system in just eleven months. This involves a rigorous and almost waterfall like upfront discovery phase where domain logic is extracted, meetings are transcribed, and AI structures the output into strict epics and stories. Dominic also dives into the repository architecture, explaining their use of a hub repo with submodules to perfectly scope context for agents, ensuring low entropy outputs regardless of whether an engineer uses SpecKit, a Ralph Wiggum loop, or raw terminal commands.

Philosophical/Human Implications
A fascinating philosophical discussion emerges around the nature of software complexity and human communication. Deejay and Dominic reflect on how rigid and upfront specification is now a superpower in the agentic era. Because the transaction cost of writing code has plummeted, the premium is now placed on clear communication, structured domain modeling, and human in the loop oversight to manage irreducible complexity.

Future Outlook
The conversation concludes with a look at the diversity of tooling. Rather than forcing a single automated factory pipeline, the approach at Odevo standardizes the inputs while allowing engineers the freedom to choose their preferred agentic tools. This flexibility, grounded in strict architectural rules, points to a future where developers act more like orchestrators and reviewers of highly capable autonomous systems.

Key Themes Explored

The Breaking Point of Agile
Traditional small batch workflows and Kanban boards create severe pull request bottlenecks when paired with agentic coding speeds. Engineering teams must redesign their entire software development lifecycle around AI velocity rather than forcing AI into legacy processes.

Upfront Discovery as an AI Superpower
While heavy upfront specification resembles outdated waterfall methodologies, it is essential for agentic coding. By investing time in structured domain modeling and precise acceptance criteria, teams can drastically reduce AI entropy and hallucination.

Architecting Codebases for Agents
Modern repositories must be designed from the ground up to support AI context management. Utilizing hub repositories, submodules, and strict architectural golden rules ensures that agents have the exact context needed to generate accurate and low entropy code.

The conversation begins with an inside look at Odevo, a massive Swedish property technology company managing residential assets globally. Tomasz outlines the early days of their AI adoption, characterized by an internal AI team building bespoke document sorting tools and a secure internal GPT instance. However, a significant pivot occurs when casual Slack debates about engineering productivity evolve into a structured realization: the rules of software development are fundamentally changing, and unstructured experimentation is no longer sufficient.

The Technical Core
The heart of the episode explores the mechanics of the comprehensive AI training rollout at Odevo. Tomasz and Deejay dissect the deliberate choices made during the enablement program, such as rejecting compressed three-day bootcamps in favor of spaced, bi-weekly modules. This pacing allowed engineers to digest concepts and test them in real-world scenarios. The duo delves into the tangible outcomes of this structured approach, noting that pull request volume increased by up to ten times while merge times plummeted by fifty percent. Importantly, they discuss how AI adoption actually reinforced foundational engineering practices, making tedious tasks like unit testing and documentation effortless rather than burdensome. Tomasz emphasizes that the training was not just about syntax, but about establishing a baseline of good and bad practices for utilizing tools like Claude Code and GitHub Copilot.

Philosophical and Human Implications
A fascinating shift in the narrative happens when the discussion moves beyond the engineering department. Tomasz highlights the democratization of software creation, detailing how financial managers, product owners, and HR professionals are leveraging platforms like Lovable to build functional applications. This introduces a new paradigm of ownership, encapsulated by the you build it, you own it philosophy. The duo explores the psychological impact of AI, noting a marked increase in developer boldness. Engineers are no longer paralyzed by the fear of starting; instead, they are proactively rewriting legacy applications and exploring new architectures because the barrier to entry has evaporated.

Future Outlook
Looking ahead, Tomasz advocates for a culture of enablement over restriction. He argues against heavy-handed governance and token rationing, comparing AI access to basic utilities like Microsoft Office. The focus remains on fostering curiosity, sharing wins and failures openly, and allowing teams to push the boundaries of what is possible as the industry accelerates toward an agentic future.

Key Themes Explored

• Structured Enablement Over Organic Adoption
  Relying on developers to figure out AI tools independently leads to uneven adoption and amplified bad practices. A guided, paced training program establishes a baseline of quality and accelerates true organizational fluency.

• The Rise of the Bold Developer
  AI tools significantly lower the activation energy required to start complex tasks. This results in engineers taking more calculated risks, prototyping faster, and tackling legacy debt with renewed confidence.

• Democratization of Software Creation
  No-code and agentic tools are turning product managers and operational staff into functional developers. This shift requires a new approach to governance, emphasizing personal ownership and collaborative refinement over traditional IT gatekeeping.

• Treating AI as a Fundamental Utility
  Restricting token usage or imposing heavy red tape stifles innovation and limits ROI. Forward-thinking enterprises view access to frontier models as a basic operational necessity rather than a heavily audited expense.

The episode begins by addressing a stark new reality for engineering teams: AI agents are writing code at an unprecedented pace, leading to pull requests that are 150 percent larger and review times that have doubled. Deejay and Jaime Jorge unpack this sudden shift, noting how the friction of software development is being removed faster than ever before. However, this frictionless environment introduces a dangerous side effect known as automation bias, where developers might blindly merge massive blocks of AI-generated code simply because a machine wrote it.

The Technical Core
A significant pivot occurs when the conversation moves from identifying the problem to exploring architectural solutions. Jaime introduces the cyborg approach to code analysis. He explains that while AI models are incredibly powerful, their non-deterministic nature means they cannot reliably enforce consistent coding standards. To counter this, engineering teams must maintain deterministic rules as a structural backbone. The duo explores how tools like Model Context Protocol servers are allowing AI agents to run local static analysis and security checks before a pull request is ever created. Instead of discarding traditional CI/CD pipelines, Jaime argues that these deterministic gates are becoming even more critical, acting as necessary friction to ensure that AI-generated software is actually secure.

Philosophical and Human Implications
The heart of the episode explores the evolving role of the software developer. Jaime likens managing modern AI coding tools to opening loot boxes, where the output is a gamble that requires constant supervision and orchestration. As coding becomes less about typing syntax and more about acting as an agent herder, the fundamental principles of software engineering—like rigorous test coverage and clear specifications—are proving more vital than ever. The discussion also touches on the anxiety surrounding software as a defensive moat. If anyone can spin up a prototype over a weekend, the true differentiator for a business becomes trust and reliability, rather than just the codebase itself.

Future Outlook
Looking ahead, the conversation shifts toward the concept of software factories and autonomous agents operating in isolated environments. Jaime anticipates a future where systemic failures in code quality will no longer be blamed on individual human error, but on poorly designed automated workflows. The episode concludes with a grounding reminder for tech leaders: while the pace of AI innovation is relentless and impossible to track hourly, embracing the change and implementing robust, automated guardrails will be the key to surviving and thriving in this new era.

Key Themes Explored

• The Cyborg Approach to Analysis. Combining deterministic security rules with non-deterministic AI models ensures consistent code quality without sacrificing development speed.
• The Danger of Automation Bias. As AI generates massive pull requests, developers risk blindly trusting machine output, making rigorous and automated review gates essential.
• Coding as Agent Orchestration. The developer role is shifting from writing syntax to guiding multiple AI agents, requiring a renewed focus on strict testing and clear specifications.

The Opening Context
The conversation begins with a critical look at how engineering organizations measure success in the era of AI. Lauren Peate CEO of Multitudes joins Deejay to unpack their recent mixed methods research on the real world impact of agentic coding on software delivery. The duo quickly establishes that the headline grabbing promises of AI often clash with the lived realities of developers. Lauren emphasizes that relying solely on telemetry data can paint a misleading picture necessitating a blend of quantitative metrics and qualitative interviews to uncover what is actually happening within engineering teams.

The Technical Core
A significant pivot occurs when Lauren reveals one of the most surprising findings of the study: a 19.6 percent increase in out of hours commits among developers using AI tools. While many leaders assumed this spike was driven by the sheer joy of using new technology the qualitative data told a different story. Developers are struggling to balance existing delivery pressures with the steep learning curve of rapidly evolving AI models. The heart of the episode explores how organizations can mitigate this burnout. Lauren advocates for structured peer to peer learning noting that engineers trust AI demos from their codebase peers far more than top down mandates or static playbooks. Deejay parallels this with the military concept of commanders intent arguing that leaders must clearly communicate the why behind AI adoption rather than just dictating the how.

Philosophical and Human Implications
The discussion deepens as they examine the psychological toll of AI mandates and the shifting dynamics of psychological safety. They lament the disconnect between senior leadership who often view AI as a sheer productivity multiplier and the individual contributors on the ground who feel their job security is threatened. Lauren points out that unaddressed fears stifle adoption making it crucial for leaders to be authentic about economic realities and organizational goals. Deejay highlights the importance of creating spaces for developers to voice their anxieties and share their AI failures transforming skepticism into collective problem solving.

Future Outlook
Looking ahead the conversation addresses the precarious future of the junior developer pipeline. Lauren shares upcoming research indicating that while senior leaders rarely mention the impact of AI on entry level talent individual contributors are deeply worried about who will mentor the next generation. Deejay voices a dystopian concern: if AI abstracts away the foundational coding work we risk building critical societal infrastructure on layers of digital cruft that no human truly understands. Ultimately they conclude that the successful integration of AI relies not on the tools themselves but on preserving the human elements of mentorship intentional leadership and community learning.

The conversation begins by tracing the professional trajectories of Daniel Jones and Benedict Stemmelt, two practitioners who found common ground in the shared Slack channels of the AI-native movement. The opening context establishes a relatable pivot for senior leaders: the rediscovery of the joy of creation. Both hosts describe how agentic tools allow architects and CIOs to bypass the friction of environment setup and syntax memory, returning to the core act of building. However, this initial excitement quickly shifts into a more rigorous technical analysis of the state of the art in early 2026.

The technical core of the episode centers on the transition from individual productivity to systemic organizational efficiency. Benedict laments the loss of focus when teams treat AI tools as mere copy-paste assistants rather than integrated agents. A significant pivot occurs when the duo discusses the Paradox of Detail in context management. They debunk the common advice of stuffing every instruction into an agents.md file, noting that reasoning capabilities often hit a cliff after 30,000 tokens. Daniel highlights research showing that over-loading context actually confuses models, making aggressive context curation a more vital skill than prompt engineering.

The heart of the episode explores the human and behavioral implications of non-deterministic development. The duo discusses the Ralph Wiggum loop—an experiment in unattended programming—to illustrate how agents can shake themselves out of local maxima through iterative failure. Benedict likens the process of steering an agent to reverse engineering; the developer must understand the model’s default training path to effectively nudge it toward a specific architectural vision. This requires a fundamental behavior change: the willingness to throw away agent-generated code and reset the slate rather than manually fixing every hallucination.

The future outlook presented is one of Software Factories. The conversation concludes with a vision of engineers moving from manual labor to machine design. They argue that the job of an engineering leader is no longer just shipping features, but building the machine that ships the features. They warn that according to DORA 2025 data, this transition will widen the gap between high-maturity teams and those struggling with legacy bottlenecks. The episode ends as a call to action for leaders to treat AI adoption not as a tool purchase, but as a total organizational redesign centered on flow efficiency and automated throughput.

• The Shift to Software Factories: Engineers are transitioning from writing individual lines of code to designing autonomous systems that manage feature production. This requires a mindset shift where the primary product is the factory itself rather than the code it produces.
• The Context Reasoning Cliff: Reasoning capabilities often degrade significantly once a context window exceeds 30,000 tokens, regardless of the theoretical maximum limit. Technical leaders must focus on context pruning and relevance rather than simply increasing the volume of provided data.
• Behavioral Reverse Engineering: Success with agents depends on identifying a model's default behaviors and intentionally steering them toward project-specific requirements. This iterative process uses non-determinism as a feature, allowing agents to find creative solutions through multiple loops.

The episode opens with urgency as Daniel Jones and Mike Gehard reflect on a fortnight of agentic breakthroughs—specifically "dark factories" where humans are barred from the inner workings of code production. Daniel cites milestones from OpenAI and Strong DM, noting the industry has moved past simple completion tools into autonomous, multi-agent systems. Mike connects his chemical engineering roots to the current AI landscape, suggesting software is finally colliding with the mature feedback loops of physical refineries and the Toyota Production System.

The technical core focuses on the shifting bottleneck of software production. Applying the Theory of Constraints, they argue that because LLMs have solved the "output problem"—generating code faster than any human—the constraint has moved upstream to specification and downstream to validation.

Mike shares experiments building a handcrafted software factory, using agents to retrospect on their own traces and PRs. They dismantle traditional reliance on unit tests, highlighting the "holdback set" approach: keeping a human-language specification hidden from the coding agent as a blind validator. This shifts focus from "transmogrifying widgets" to measuring real-world outcomes and user behavior.

The dialogue explores human implications of this transition, discussing the "death of legacy lore"—whether TDD and complex architectural patterns remain relevant when an agent can refactor an entire codebase in seconds. Mike introduces Minimum Viable Architecture, positing that while agents need structure to stay within context windows, the mental overhead of traditional architecture is shrinking.

They analyze the addictive nature of "vibe coding" and the psychological relief of staying present with family while agents churn through tasks in the background.

The future outlook envisions radical software abundance—a world where software has zero market value because it's instantly reproducible, shifting the corporate moat to data, networks, and relationships. They foresee democratization where non-technical domain experts express business logic without the gatekeeping of a "priestly developer class." The episode concludes with a call to abandon dogmatic practices, embrace the role of the Editor, and use these tools to solve persistent human problems like hunger and housing through frictionless, bespoke creation.

Key Themes

• The Industrialization of Logic: Software is moving from artisanal process to closed-loop system modeled after chemical refining, requiring engineers to act as systems designers managing automated loops.
• The Theory of Relocated Constraints: With code generation solved, the primary hurdles are clarity of specification and rigor of validation—encoding human intent into high-fidelity prompts without ambiguity.
• Architecture as Context Management: Traditional architecture managed human mental limits; in the agentic era, it prevents LLMs from getting lost mid-file. Structure optimizes the agent's attention.
• The Economic Collapse of Software Value: As software becomes a commodity generated for token costs, proprietary codebases lose competitive advantage. Future value resides in proprietary data and human relationships.

The episode opens with Amy Heineike outlining Tessl's core mission: building documentation registries optimized for coding agents. Daniel Jones notes the pervasive frustration of API hallucinations, where models invent idealized but non-existent methods that waste developer cycles. Amy explains that models often struggle with APIs too new or too old for their training sets, creating a critical need for external grounding. The duo laments lost efficiency when agents trawl through bloated web pages or unoptimized node modules. Amy introduces the Registry as a version-locked context provider that prevents agents from polluting context windows with raw text. Using an MCP server, agents access summary documentation, staying grounded without token-heavy web crawls.

The discussion pivots to verification methodology. Amy likens the shift from unit testing to evaluations as moving from hard logic to biological science. In traditional engineering, a unit test fix remains fixed, but in agentic systems, success is measured across a basket of scenarios. This requires developers to think like statisticians, examining success averages and variance rather than binary pass-fail states. The episode explores the paradox of detail: providing more task instructions can cause agents to ignore broader system-level steering. Amy shares research showing that as task prescriptiveness increases, agents weigh local context over global rules.

The conversation deepens around non-deterministic high-performing systems. They discuss the Ralph Wiggum loop and Steve Yegge's Gastown framework, illustrating how agentic head-banging against errors can lead to superior, anti-fragile outcomes. Daniel introduces the Van Halen Brown M&M feedback loop as a psychological steering mechanism, where developers can use emoji-triggers to verify if a model respects the context window.

The dialogue concludes with forward-looking organizational analysis. As AI capabilities coalesce, rigid boxes of product, design, and engineering begin to merge. Amy and Daniel envision the rise of the Product Engineer, a role focused on intentionality and outcomes rather than syntax. They argue that defining what a good outcome looks like becomes the primary lever of control. Amy encourages embracing the chaos of transition, suggesting stability is found in accepting variability rather than fighting for perfect determinism.

Key Themes Explored:

• Machine-Optimized Contextual Grounding: Tessl provides unpolluted, machine-ready registries that prevent token-heavy hallucinations in cutting-edge or legacy APIs.
• Probabilistic Verification: Engineering is shifting from binary unit tests toward statistical evaluation modeling, treating systems as biological entities requiring constant observation.
• The Paradox of Detailed Steering: Hyper-prescriptive prompts often cause loss of global instruction adherence. Architects must balance task detail with system steering.
• Anti-Fragility via Non-Determinism: Embracing non-deterministic loops allows systems to escape local maxima and discover stable solutions through learning from failures.
• Outcome-Focused Engineering: AI is merging product management and development into a single outcome-oriented discipline focused on defining intentionality.
• Multi-Pass Agentic Architectures: Breaking logic, security, and performance into specialized sequential passes prevents cognitive overload and improves reliability.

In this week's episode of Waves of Innovation, host Daniel Jones reconnects with "Big" Rob Edwards, a Google Cloud expert, DORA contributor, and long-time collaborator. Their history goes back a decade to the trenches of early cloud platform delivery, giving them a shared language for the massive shifts occurring in the industry today.

Rob brings a rare dual perspective to the podcast. By day, he works with enterprises across North America to optimize their software delivery using Google Cloud. By night, he has recently completed a Master’s degree in Psychology, where his thesis focused specifically on "Developer Productivity in the Age of Generative AI."

The conversation kicks off with a deep dive into Rob’s contributions to the upcoming DORA report. While the industry obsesses over code generation, Rob and Daniel argue that "writing code faster" is rarely the bottleneck.

They explore the critical importance of Value Stream Management (VSM). Rob shares real-world anecdotes—including drawing process maps on glass windows in major banks—to illustrate how invisible friction points kill velocity.

They discuss a specific case study where a customer thought they had a CI/CD problem, but VSM revealed they had five manual merges on the critical path to production. The key takeaway from the DORA research? AI is an amplifier. If applied to a bad process, it simply creates a larger pile of inventory at your bottlenecks. VSM is the "force multiplier" that allows AI teams to actually ship value rather than just generating PRs.

The heart of the episode is a fascinating exploration of Rob’s academic thesis. Interviewing senior engineers, he uncovered that the identity of a developer is fundamentally changing from a "Coder"—measured by syntax and output—to a "Conductor."

Rob explains the concept of "metacognition" (thinking about how we think). As developers move to agentic workflows, they are forced to stop thinking about the for loop and start thinking about system architecture and intent. Rob notes that participants in his study stopped reading technical manuals and started reading architectural books to better direct their AI agents.

Key Themes Explored:

• The "Safe Space" of AI: Rob reveals a surprising psychological benefit: introverted developers are using AI as a non-judgmental "cognitive partner" to validate their ideas. This pre-validation gives them the confidence to speak up in group settings, leading to better team outcomes.
• The Baseline Trap & Burnout: The discussion takes a serious turn regarding mental health. As AI handles the grunt work, the "baseline" for productivity shifts upward. If you aren't doing 3x the work, you feel unproductive. Rob and Daniel discuss the dangers of this "new normal" and the "J-Curve of Learning" where productivity temporarily dips as we adjust to new tools.
• The Junior Developer Crisis: If senior engineers are operating at a high level of abstraction, how do juniors learn? The duo laments the loss of "learning by osmosis"—sitting next to a senior dev and watching them work—and questions if the next generation will miss out on foundational struggles that build resilience.
• Agentic Exhaustion: Daniel shares anecdotes about the mental load of managing multiple AI agents, comparing it to the intense focus required for pair programming. It’s not necessarily easier; it’s just different work.

Whether you are a CTO looking to interpret the DORA metrics, or a developer trying to navigate your changing identity in an AI world, this episode offers a blend of hard data and human insight you won't find anywhere else.

Why do so many digital transformations hit a wall? You can have the fastest cloud platform or the most advanced AI agents, but if you ignore the humans responsible for using them, you are destined to struggle.

In this episode of Waves of Innovation, host Daniel Jones reconnects with his former business partner and long-time collaborator, Dan Young. Ten years ago, they set out to transform companies using Cloud Native technology. They quickly realized that the biggest blockers weren't technical—they were psychological.

As the industry shifts from Cloud Native to AI Native, the lessons they learned are more relevant than ever. DJ and Dan dive deep into the messy reality of organizational change, exploring why mandates fail and why "invitation" is the secret weapon of successful modern leadership.

In this episode, we cover:

• The Identity Crisis of Change: Why developers and managers resist new workflows—not because they are stubborn, but because it threatens their professional identity.
• Invitation-Based Change: How to stop dragging people to meetings and start creating spaces where people choose to engage using Open Space technology.
• Liberating Structures: Practical tools (like TRIZ and 1-2-4-All) you can use tomorrow to break down power dynamics and let the quietest voices in the room solve your biggest problems.
• The "Make It Fail" Exercise: A counterintuitive strategy to identify organizational weaknesses by asking how to ensure a project fails spectacularly.
• Leading with Vulnerability: Why the "Iron Triangle" of certainty kills innovation, and how listening can be a leader's most powerful tool.

About the Guest: Dan Young is a technologist turned organizational change expert. Formerly the co-founder of Cloud Native consultancy EngineerBetter, he now runs When & How Studios. He specializes in the human side of technology, helping organizations navigate the complex web of motivations, identities, and power dynamics to create healthier, more effective teams.

Resources & Links Mentioned:

• Inviting Leadership: https://www.amazon.co.uk/Inviting-Leadership-Invitation-Based-ChangeTM-World/dp/0984875352
• Liberating Structures: https://www.liberatingstructures.com/
• Open Space Technology: https://en.wikipedia.org/wiki/Open_space_technology
• When & How Studios - Book Of Prompts: https://www.whenandhowstudios.com/book-of-prompts
• Article: Are you growing something that matters? (The pandemic/Telco story): https://medium.com/needs-workshop/are-you-growing-something-that-matters-78a7f3a79838
• Article: Helping the NHS take care of itself (The shielding story): https://medium.com/needs-workshop/helping-the-nhs-take-care-of-itself-4643c0d3f20f

What happens after you go "all in" on AI coding assistants?

In this episode, Deejay catches up with Elliott Beatty, host of the Agentic CTO podcast, and VP of Engineering at Fruition, to review his organization’s aggressive adoption of agentic AI. Several months ago, the goal was full automation. Today, the reality is more nuanced. While velocity is up tremendously, the team has hit a new ceiling: the human element.

Elliott pulls back the curtain on the unintended consequences of hyper-productivity, including developer burnout, "context switching" fatigue, and the massive bottlenecks created in QA and User Acceptance Testing (UAT) when code is written faster than it can be checked.

In this episode, we cover:

• The Human Cost of Velocity: Why running multiple agents simultaneously led to engineer burnout and mandatory time off.

• Frontend vs. Backend: Why AI agents excel at React and Flutter "monkey-see-monkey-do" tasks but struggle with complex backend microservices and scalability logic.

• The "Logjam": How a 100% increase in coding speed exposed critical weaknesses in QA, UAT, and stakeholder approval processes.

• Tooling Shifts: Why the team ditched Jira for Linear, embraced Model Context Protocol (MCP) servers, and the critical importance of Feature Flags (LaunchDarkly) in an AI-driven workflow.

• Leadership Advice: Why you need an "AI Quarterback" to manage the friction between engineering, product, and marketing.

Tools & Resources Mentioned:

• Qase: The test management tool mentioned by Elliott (Qase.io).

• Linear: For issue tracking with AI integrations.

• Granola: For AI note-taking and meeting summaries.

• N8n: For workflow automation in QA.

• Cursor / Windsurf / Claude Code: The current stack of coding assistants.

Contact & Feedback:Have you experienced AI burnout in your team? Let us know.Email: wavesofinnovation@re-cinq.comWebsite: re-cinq.com

Don't forget to subscribe to catch the next wave of innovation.

Why do AI projects feel so unpredictable? If you've ever been frustrated by a machine learning project that shows "nothing, nothing... then suddenly, something," this episode is for you. We move past the hype to explore the "fuzzy" reality of building with AI and why it’s a fundamentally different discipline from traditional software engineering.

Discover why you can't just apply Agile sprints to ML development and why models need to be "massaged and babied" rather than simply "built." We break down the practical engineering challenges of MLOps, from the difficulties of testing non-deterministic systems (where "pass/fail" doesn't apply) to the complexities of safely deploying them.

We also go deep on Reinforcement Learning (RL), a powerful but high-stakes branch of AI. You'll learn:

• What makes RL unique (its "agency to explore").

• Why live testing in industrial settings "could be catastrophic."

• How "Offline RL" allows us to train powerful agents from simple log files.

• The surprising role RL plays in training the large language models (LLMs) we use every day.

Tune in for a practical, engineering-focused look at what it really takes to get AI from a concept to a reliable, production-ready product.

How do you implement cutting-edge AI in one of the world's most regulated and secure environments?

In this episode, Deejay talks to Mike Gehard, Director of R&D at Rise 8, a custom software development firm that is all-in on developing AI solutions for the US federal government. Mike shares how his team is tackling the "nightmare difficulty" of using generative AI for both internal software development and for building AI-powered features for government agencies.

This is a masterclass in pragmatic AI adoption, moving beyond the hype to solve real-world security, process, and human challenges. Mike details the practical steps Rise 8 is taking, from running Claude Code securely in containers to his ambitious goal of enabling a single person to take a feature from idea to production.

In this episode, you will learn about:

• Practical strategies for using AI securely in highly regulated industries like government, finance, and healthcare.

• Why Mike believes "inside-out" test-driven development is dead in the age of AI.

• The power of custom slash commands and MCP servers to amplify developer effectiveness and share knowledge.

• How to address "AI hesitancy" and encourage adoption among skilled software craftspeople.

• The story of the "Brian Bot" and what it reveals about AI's powerful pattern-matching capabilities.

• Mike’s vision for a single person to take a product from idea to production using AI.

About Our Guest:Mike Gehard is the Director of R&D at Rise 8, a custom software development firm focused on delivering AI-powered solutions for the US federal government. With a background as a software craftsman at Pivotal, Mike is now focused on transforming the software development lifecycle by integrating AI at every step, navigating complex security requirements to deliver value to the US taxpayer.

In this episode, we sit down with Nick Gushchin, founder of the Swiss AI Chatbot Factory, to hear his incredible story of career transformation. After nearly 18 years in the banking industry, Nick embarked on a journey to teach himself Python, using ChatGPT as his primary tutor.

Nick shares how a chance conversation on an airplane introduced him to the coding capabilities of ChatGPT 3.5, sparking a realization that he could build his own projects much faster than the 9-12 month timelines he was used to in banking. This led him to take a sabbatical, dedicate himself to learning, and eventually develop over 20 of his own pet projects.

Discover how one of these projects, an AI chatbot on Telegram, gained over 100,000 users and became the catalyst for him to leave banking for good. Nick also details the founding of the Swiss AI Chatbot Factory, a platform that uses AI agents to automate the creation of smart, reliable chatbots in under three minutes. He explains the multi-layered approach his factory uses to prevent AI "hallucinations" and ensure chatbots provide accurate, context-aware answers without being "dumb".

This is a must-listen for anyone interested in AI, career changes, and the power of leveraging new technology for rapid innovation.

What's the most important skill for building reliable AI? It might not be what you think.

In this episode, we sit down with Qamir Hussain, Head of AI at Arisa (formerly of Webio), who shares incredible insights from building AI for the high-stakes world of debt collection. He argues that a QA mindset is more critical than any other skill for an engineer in the AI space.

We dive into the real-world war stories of developing AI-driven tools that assist agents in navigating difficult and sensitive financial conversations.

In this episode, you'll learn:

Tune in for a masterclass in the practical engineering and strategic thinking required to make AI work in the real world.

Feeling overwhelmed by the new wave of AI jargon? You're not alone. In this episode, we're joined by Hannah Foxwell, a tech leader who, after feeling "bamboozled" at an AI conference, founded the "AI for the Rest of Us" community. Her mission: to help everyone, not just the deep experts, develop the "AI fluency" needed to navigate this new era.

Hannah draws fascinating parallels between the current messy, opportunity-rich moment and the early, culture-driven days of the DevOps movement. In a candid conversation, she argues that the era of "coddled developers" is over and that the industry's focus must shift from simply writing code to delivering measurable business impact. She warns that without this cultural shift, AI's productivity gains will only turn us into "AI-powered feature factories," doing the wrong things faster than ever before.

So, how do we move forward? Hannah offers practical patterns for leaders and engineers, from the critical role of "enabling teams" (citing Team Topologies) to the non-negotiable need for "slack in the system" to foster real innovation. This is a must-listen for anyone looking for an honest, hype-free guide to the cultural, career, and strategic challenges of the AI Native wave.

What would it take to have your engineering team write almost no code by the end of 2026? That's the audacious goal tech leader Elliot Beaty set for his team after realizing the industry was at a critical inflection point. In this episode, Elliot takes us deep inside his journey of transforming a development team into an AI-first powerhouse, detailing the pivot that began with reluctance 3 and has led to a fundamental shift in how they build software.

The results have been staggering: a nearly 250% increase in team velocity, even while tackling more complex features. Elliot shares the landmark moment when an AI agent fixed a complex, two-day bug in just 30 minutes, all initiated from a single Jira ticket. He also reveals the surprisingly crucial role that high-quality documentation now plays, providing the essential context that AI agents need to succeed and turning a once-dreaded task into a high-value activity.

But this transformation isn't just about productivity gains. Elliot offers a hype-free look at the real-world challenges, from the "multitasking overload" and mental fatigue caused by managing AI agents to the unexpected bottleneck this new speed has created for his QA team. Learn why current AI is still largely "monkey see, monkey do," and how his team is wrestling with agents that often build

This conversation is an essential playbook for any technology leader, manager, or engineer. Tune in for a practical discussion on adoption strategies, the evolving role of the senior developer, and the potential engineering skills gap we may face in the coming decade.

Welcome to the first episode of Waves of Innovation.

This podcast, and the community around it, started with a simple question:
What if we could approach the next technological transformation differently this time?

In this opening conversation, Pini Reznik (Author of Cloud Native Transformation: Practical Patterns for Innovation) shares the story behind his upcoming book Waves of Innovation, the thinking that shaped it, and why the shift toward AI Native is about much more than just a passing trend.

Together with your host Deejay, he reflects on a decade of helping companies navigate their Cloud transformations, and what we need to do differently in this next wave. Pini emphasizes that if you ignore this wave now, you will soon suffer from the repurcussions.

If you're curious about the ideas behind the book, the meaning, or the people shaping this movement, this is where it begins. And we’re only getting started.

Have thoughts, suggestions, or feedback?

Reach us anytime at: wavesofinnovation@re-cinq.com