1858965344
Rethink Engineering

Advertise on podcast: Rethink Engineering

This podcast has
20 episodes
Language
English
Explicit
No
Date created
2025/12/05
Latest episode
2026/10/29
Average duration
68 min.
Release period
29 days

Description

From AI-native software development to engineering leadership and organizational transformation, we explore what it takes to build the next generation of engineering organizations.

Unlock Rethink Engineering podcast Email contact info,
Listeners & Audience details

Email contact information

Direct podcast contact details

Listeners

Audience numbers & engagement insights

Audience details

Podcast Insights

Podcast episodes

Check latest episodes from Rethink Engineering podcast


Patrick Debois: Your Software Factory Should Be a Dream Factory
2026/10/29
Patrick Debois, who organised the first DevOpsDays in 2009 and is now an independent advisor and Product DevRel Lead at Tessl, joins Benedikt Stemmildt to look at software factories and dark factories through a DevOps lens. Most factories automate the same loop of writing, reviewing and deploying code. Patrick argues that the harder question is when a change can reach customers without a human reviewing it, and that this is a question of risk rather than of code. From there, he explains why he turns whatever he can into deterministic checks, why a factory should explore as well as build, and how factories change the size of teams, the roles inside them and the way organisations share what they build. In this episode: Why risk, not code, decides what a dark factory can ship on its ownHow architecture absorbs risk, and why dark factories come in gradationsDeterministic checks, and why loose orchestrators turn into state machinesResearch loops and the idea of a dream factorySmaller teams, fused roles and why Patrick would not go below four peopleFactories as platforms, and why model upgrades are major upgradesTwo metrics for a factory: human touches and reuse across the organisationChapters: 00:00 Intro 02:16 Software Factories Through a DevOps Lens 04:13 Risk Is the Real Merge Decision 06:52 Not Every Part of the Code Carries the Same Risk 11:15 Dark Factories Come in Gradations 12:23 Deterministic and Non-Deterministic Checks 14:06 Orchestrators vs. State Machines 17:04 Local Iteration vs. Autonomous Factories 19:12 Research Loops and the Dream Factory 21:32 Pipelines Beyond Code 22:46 Smaller Teams, Fused Roles 26:24 Solo Developers and the Bus Factor 28:29 System Thinkers and Chaos Engineers 31:40 Factories as Platforms 34:57 Model Upgrades Are Major Upgrades 37:36 What Happens to Juniors? 44:19 How Companies Should Start 46:23 Two Metrics: Human Touches and Reuse 47:52 From Solo to Multiplayer Factories 49:39 Deploying Skills, Installing Loops 51:10 Patrick's Advice 52:38 Wrap-Up Mentioned in this episode: AI Native DevCon NYC, 2 to 4 November 2026: https://tessl.io/devconAI Native Dev: https://ainativedev.ioTessl: https://tessl.ioDevOpsDays: https://devopsdays.orgGuest: Patrick Debois · https://jedi.beHost: Benedikt Stemmildt, founder of hackers&wizards Rethink Engineering is powered by re:cinq and hackers&wizards. All episodes: https://re-cinq.com/podcast
Sam Newman on Software Factories: Why AI Can't Fix Your Production Incidents (Yet)
2026/10/13
Sam Newman, author of Building Microservices and the new Building Resilient Distributed Systems, joins Benedikt Stemmildt to talk about resilience engineering now that AI writes more of our software and runs inside more of our products. Resilience isn't about making sure nothing goes wrong. It's about making sure as many things go right as possible. From Google's Velcro-strapped servers to a network outage caused by rabbits eating cables, Sam explains why systems, and the people who run them, have to be built for surprise. Then he applies the same lens to AI: model providers that aren't yet cloud-grade, why automated remediation with AI is still a long way off, and why your software factory is a production system in its own right. In this episode: Why resilience focuses on what goes right, not only on preventing failureDavid Woods' four concepts: robustness, rebound, graceful extensibility and sustained adaptabilityWhy LLM providers aren't cloud-grade yet, and how to hedge across models and vendorsWhy AI can help during an incident, but can't fix it for you (yet)Why you can't one-shot a large-scale system, and the modular on-ramp to software factoriesTeam Topologies vs. top-down AI mandatesShip fast enough to care: burnout, cognitive debt and Peter Naur's theory buildingChapters: 00:00 Intro 01:17 Sam's New Book on Resilient Distributed Systems 06:10 Making Sure Things Go Right 08:33 Why Failure Is a Numbers Game 11:31 Robustness and Rebound 13:20 LLM Providers Aren't Cloud-Grade Yet 16:04 Multi-Model, Multi-Vendor 19:45 Why AI Auto-Remediation Is a Long Way Off 24:10 Agent Retries vs. Production Retries 28:24 Building With AI vs. Building AI Into Products 30:04 Rabbits, Burning SSDs and the Unexpected 32:46 Sustained Adaptability and Psychological Safety 34:10 Is a Software Factory Resilient? 40:10 Dark Factories and the Modular On-Ramp 44:27 Teams, Not Top-Down AI Mandates 49:56 Ship Fast Enough to Care 52:15 Cognitive Debt and Theory Building 55:21 Don't Go All In 57:47 Wrap-Up Mentioned in this episode: Building Resilient Distributed Systems: https://www.oreilly.com/library/view/building-resilient-distributed/9781098163532/Four Concepts for Resilience, David Woods: https://www.sciencedirect.com/science/article/abs/pii/S0951832015000848Cognitive debt, Margaret-Anne Storey: https://margaretstorey.com/blog/2026/02/09/cognitive-debt/Guest: Sam Newman · https://samnewman.io Host: Benedikt Stemmildt, founder of hackers&wizards Rethink Engineering is powered by re:cinq and hackers&wizards. All episodes: https://re-cinq.com/podcast
Inside Steve Yegge's Software Factory: Lessons from Running 50 Agents
2026/09/20
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 senseThe factory that will "never be done": how adversarial reviews and a growing backlog turn all work into more workSteve'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 dayWhy faster engineering pushes the bottleneck downstream, onto reviewers, business teams and customersWhy enterprise AI is arriving "upside down": production agents on ticket queues succeed straight away, while automating the build side strugglesWhy 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-4f25ee16dd04Gas Town: https://yegge.ai/gastownWelcome to Gas City: https://yegge.ai/essays/welcome-to-gas-city/Beads, the agent issue tracker: https://github.com/gastownhall/beadsDolt, the versioned database behind Beads: https://www.dolthub.comWyvern, Steve's game: https://yegge.ai/wyvernOutput 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
72x Faster Software Delivery with a Former AI Skeptic
2026/05/19
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.
Scaling AI Enablement: How Odevo Upskilled Engineering
2026/04/30
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.
Scaling Code Review When AI Writes the Software
2026/04/10
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.
From Telemetry to Empathy: Measuring AI in Your Teams
2026/03/25
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.
Bridging the Skills Gap: Insights from Agentic Coding Training
2026/03/04
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. Key Themes ExploredThe 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.
Software Factories: From Outputs to Business Outcomes
2026/02/18
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.
Evals, reducing hallucinations, & AI-native development
2026/01/29
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.
DORA 2025, the Psychology of Agentic Coding, and Value Stream Management
2025/12/23
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.
From Tech Stacks to Mindsets: The Psychology of Transformation
2025/12/05
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/0984875352Liberating Structures: https://www.liberatingstructures.com/Open Space Technology: https://en.wikipedia.org/wiki/Open_space_technologyWhen & How Studios - Book Of Prompts: https://www.whenandhowstudios.com/book-of-promptsArticle: Are you growing something that matters? (The pandemic/Telco story): https://medium.com/needs-workshop/are-you-growing-something-that-matters-78a7f3a79838Article: Helping the NHS take care of itself (The shielding story): https://medium.com/needs-workshop/helping-the-nhs-take-care-of-itself-4643c0d3f20f
From Coding to Context Switching: An AI Retrospective
2025/11/13
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: [email protected]: re-cinq.com Don't forget to subscribe to catch the next wave of innovation.
Why AI Isn't Just More Software: A Guide to ML, MLOps, and Reinforcement Learning
2025/10/28
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.
AI on Nightmare Difficulty: Secure Code Generation in the US Government
2025/09/20
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.

Podcast reviews

Read Rethink Engineering podcast reviews


0 out of 5
0 reviews

Podcast sponsorship advertising

Start advertising on Rethink Engineering relevant audience podcasts


What do you want to promote?