Waves of Innovation by re:cinq

Deejay

A monthly podcast about the shift from Cloud Native to AI Native. Hosted by Deejay, each episode features a guest picked by our community—engineers, leaders, and thinkers sharing how they’re adapting, experimenting, and figuring it out as they go. Real stories, practical lessons, and things we’re all still learning.

  1. 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.

    1h 47m

  2. 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.

    1h 12m

  3. 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.

    55 min

  4. 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.

    1h 9m

  5. 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.

    1h 13m

  6. Feb 18

    Software Factories: From Outputs to Business Outcomes

    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.

    1h 13m

  7. Jan 29

    Evals, reducing hallucinations, & AI-native development

    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.

    1h 1m

  8. 12/23/2025

    DORA 2025, the Psychology of Agentic Coding, and Value Stream Management

    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.

    1h 4m
See All (17)

About

A monthly podcast about the shift from Cloud Native to AI Native. Hosted by Deejay, each episode features a guest picked by our community—engineers, leaders, and thinkers sharing how they’re adapting, experimenting, and figuring it out as they go. Real stories, practical lessons, and things we’re all still learning.

Information

You Might Also Like