Rethink Engineering

re:cinq & hackers&wizards
  • 0.0 (0)
  • Management
  • Biweekly

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

  1. 5d ago

    Patrick Debois: Your Software Factory Should Be a Dream Factory

    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

  2. Oct 13

    Sam Newman on Software Factories: Why AI Can't Fix Your Production Incidents (Yet)

    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

  3. Sep 20

    Inside Steve Yegge's Software Factory: Lessons from Running 50 Agents

    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

  4. May 19

    72x Faster Software Delivery with a Former AI Skeptic

    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.

  5. Apr 30

    Scaling AI Enablement: How Odevo Upskilled Engineering

    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.

  6. Apr 10

    Scaling Code Review When AI Writes the Software

    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.

  7. Mar 25

    From Telemetry to Empathy: Measuring AI in Your Teams

    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.

  8. Mar 4

    Bridging the Skills Gap: Insights from Agentic Coding Training

    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.

See All (20)

About

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

Information

  • Creator
    re:cinq & hackers&wizards
  • Years Active
    2025 - 2026
  • Episodes
    20
  • Rating
    Explicit
  • Copyright
    © 2026 re:cinq & hackers&wizards
  • Show Website
    Rethink Engineering

You Might Also Like