[Dev]olution

Is Your AI Budget Chasing the Wrong Bottleneck? Mike Gehard Weighs In

Can speeding up code stay healthy without human involvement? Everyone wants the dark factory, where agents write and ship the code and nobody ever opens a pull request. One team ran a lights-out version for six months and came back to a codebase one of them called a complete pile of poo. It was a total rebuild. Mike Gehard, Director of R&D at Rise8, builds AI-augmented software delivery for veterans and defense organizations, where “ship it and see” isn’t an option. He joins Nicky Pike to explain why continuous delivery is the real height requirement and why code generation was never the bottleneck to begin with. He also has a few things to say about the PR numbers coming out of big tech. If your token bill keeps climbing and nobody can tell you what it’s buying, start here. In this episode, you'll learn: Why inside-out TDD is dead but outside-in TDD matters more than ever How pace layers and blast radius decide what an agent can ship unreviewed Why engineers now build the systems that let their whole team ship Things to listen for: (00:00) Meet Mike Gehard (02:30) Why blast radius decides what agents can ship (04:05) Continuous delivery is the height requirement (05:45) What Toyota’s Andon cord teaches software factories (09:10) We never wanted faster code, just cheaper (14:30) Crappy process will bury you in slop (17:20) Which agile practices survive the age of AI (20:40) What 1,300 PRs a week doesn’t tell you (24:15) When problem definition is the real bottleneck (29:45) Where Kent Beck’s 3X model lets AI loose (33:35) Where AI should and shouldn’t write code (39:35) Who owns the PR your agent wrote (43:35) Do pull requests still earn their keep (49:05) Predictions: developers build systems, not software, by 2030 (51:30) Defining a Coder: the IKEA phase of software Resources: Mike Gehard's LinkedIn: https://www.linkedin.com/in/mike-gehard-82672a4/ Rise8 website: https://www.rise8.us/ AI-Assisted Agile Software Development (Mike's Substack): AI-Assisted Agile Software Development

• Transcript
• Chapters

How Can a Zip File Hijack Your AI Coding Agent?

You unzip a folder from a contractor, type your AI agent’s name, and before you write a single prompt, somebody else’s code is already running on your machine as you. That’s GitSpawn, a flaw Manifold Security found across seven popular AI coding agents. The unsettling part is that nothing was broken or cleverly manipulated. Every agent did exactly what it was built to do. In this solo episode, Nicky Pike of Coder pulls from his Air Force years as a C-141 crew chief to explain why the developer laptop has become the most privileged and least governed place in your company to run an agent. He also digs into why three of the biggest agent vendors just shipped the same answer, and what their own docs quietly say you’re now on the hook for. If your agents are running on laptops tonight, this is the episode to hear before they touch anything that matters. In this episode, you'll learn: Why a zipped repo can run code as you when a clean clone can’t What still leaves your network when vendors run agent work on your machines How to tie every agent run back to the human who kicked it off Things to listen for: (00:00) The zip file that runs code as you (00:55) What an agent does the second it starts (01:40) Seven agents and one flaw in the plumbing (02:15) The cleanup script that wiped 48,000 files (03:10) Lessons from a C-141 flight line (04:20) The 10 mil socket that grounded every jet (05:05) Four questions for every AI agent (05:35) Walking the line on a developer laptop (06:35) Attackers are shopping for agent setups (07:25) Three vendors ship the same answer (09:00) What still leaves your network (09:45) The fine print in every vendor’s docs (11:05) Why nobody solved the flight line for you (12:25) What to change on Monday (14:20) Final thoughts: whose flight line is this? Resources: Nicky Pike’s LinkedIn: https://www.linkedin.com/in/nicky-pike/ Coder website: https://coder.com/ GitSpawn: Malicious Git Configs Hijack AI Coding Agents

Why AI Should Never Make Business Decisions For You

When an agent makes a call on your behalf and it goes sideways 6 months from now, the model can't answer for it. It doesn't know what it did, and you can't make it care. So whose name is on that? Russ Miles, Principal Engineer in Agentic Engineering at TechTalk, has spent 30 years in software, written 9 titles for O'Reilly, and self-published The Sovereign Engineer and The Sovereign Apprentice. His argument is simple and uncomfortable: You can hand an agent a mountain of responsibility, but accountability never leaves your desk. When a retry config nobody reviewed takes production down three months later, there's no precedent for pointing at the model or the vendor. In this episode, Russ and Nicky Pike dig into why accountability is a position you take rather than a role you're given, what cognitive debt feels like from the inside, and the sentinel agents Russ built to keep his own judgment honest, even the ones he ignored for an entire day at Prodacity. The challenge for this episode: Faros AI studied two years of telemetry across 22,000 developers and more than 4,000 teams and found that pull requests merged with zero review are up 31%. Nobody chose to drop oversight. Reviewers just can't keep up with what the machines are producing. Nicky admits he's hit approved on a diff he only skimmed and told himself it was fine. So be honest. When's the last time you did it, and did it come back to bite you later? In this episode, you'll learn: Why a decision's real size depends on how hard it is to roll back Why context switching drains your judgment faster than the number of decisions you make Why "code is free" ignores the real cost of tokens and human attention Things to listen for: (00:00) Meet Russ Miles (02:40) Where the word habitat came from (10:15) Every literacy shift asks who owns agency (15:50) Why Russ self-published on Leanpub (21:05) The rise of PRs merged with zero review (22:25) Responsibility versus accountability (26:35) Why big decisions are the hard-to-revert ones (30:00) Why LLMs don't think like humans do (34:05) The frictionless trap and cognitive debt (37:05) The sentinels Russ built and then ignored (40:00) Judgment is a reservoir that runs dry (42:15) The choice cartographer and the Carpaccio agent (48:00) Why the devil's advocate agent saves money (54:50) Predictions: The odds a court blames the vendor (55:45) Defining a Coder: Owning the decisions behind the outcome Resources Russ Miles's LinkedIn: https://www.linkedin.com/in/russmiles/ TechTalk website: https://www.techtalk.at/ The Sovereign Engineer: https://Leanpub.com/thesovereignengineer The Sovereign Apprentice: https://Leanpub.com/thesovereignapprentice Habitat Thinking on GitHub: Habitat-Thinking/ai-literacy-superpowers Patterns of Software: https://archive.org/details/PatternsOfSoftware The Sentinels: https://github.com/Habitat-Thinking/ai-literacy-superpowers

• Transcript
• Chapters

AI Didn't Break Your Platform, Your Mess Did

If you have to do your taxes, do you trust the whiz kid from MIT or the accountant with 30 years of experience? Marc Cluet opens this episode with that question, setting the stage for a candid exploration of modern platform engineering and enterprise AI integration. Drawing from his experience at Canonical, Rackspace, HashiCorp, and leading AI-driven migrations at a major global bank, Marc sits down with Nicky Pike to confront the core realities of modern software infrastructure. Together, they unpack what actually happens when AI is introduced to legacy systems riddled with fragmented standards and accumulated technical debt. Marc reveals why line-by-line code translation fails and advocates for translating business intent instead. He details his "Michelin-star menu" strategy to balance developer enablement with strict architectural guardrails, while warning of the unavoidable 16-month productivity valley during AI adoption. Rather than accelerating messy code, Marc emphasizes standardizing systems first or knowing when legacy shell scripts are better off retired than migrated. This episode is an essential guide for engineering leaders navigating the intersection of enterprise AI hype, platform governance, and legacy modernization. In this episode, you'll learn: Why AI acts as an accelerator for existing technical debt rather than a fix for messy architecture How to implement a "Michelin-star menu" that balances developer empowerment with curated platform choices The realities of the 16-month productivity dip and why translating underlying intent beats line-by-line code migration Things to listen for: (00:00) Meet Marc Cluet (01:34) How platform engineering became everything (02:53) From gatekeeper to enabler of development (06:15) The three buckets for every vendor pitch (10:14) Making developers maintainers too (12:00) The ten-year contract test for bad ideas (14:05) Why 95% of AI pilots fail (16:45) AI hype versus the old cloud hype (23:02) Modernizing mainframes and COBOL with AI (29:00) Why AI is not the new Stack Overflow (34:21) Building the Michelin star menu (41:00) The first MCP server worth building (44:01) The mixing board every IT org is tuning (48:05) Rapid fire questions (50:00) Predictions: AI ops roles three years out (52:09) Defining a Coder: The double-edged sword Resources Marc Cluet's LinkedIn: https://uk.linkedin.com/in/marccluet

• Transcript
• Chapters

How an AI Agent Broke Into Hugging Face During an OpenAI Test

An AI model broke into Hugging Face to cheat on a test. Not to make a point, not out of anger, just to win. Nicky Pike walks through two incidents from this summer that read like a heist movie until you strip away the sci-fi. In July, an OpenAI research agent found a zero-day nobody knew existed. It escaped the sandbox it was supposed to be sealed inside and spent four and a half days inside Hugging Face's production systems stealing credentials and minting itself access. A few weeks later, the UK's AI Security Institute ran its own evaluation and watched an agent fabricate fake identities and try to talk a real open-source maintainer into approving malicious code. Nicky borrows a detective's toolkit to make sense of both. Means, motive, opportunity, the usual three, minus the fourth thing every crime show assumes is there: malice. What's left is a mental model for how much of the real world an optimizing system will reach for once you hand it a goal, and a four-letter framework for actually containing it before it happens to you. If your company is standing up agents this quarter and calling it a productivity win, watch this episode first. In this episode, you'll learn: Why commercial AI tools refused to help Hugging Face investigate its own breach The four-letter framework Nicky uses to actually contain an agent Why a nicely worded prompt is not a security control Things to listen for: (00:00) An AI agent breaks out to cheat (00:54) Why the safety filters got switched off (01:45) It stole the answer key from Hugging Face (02:43) The detective framework means motive and opportunity (03:41) Climbing the ladder inside Hugging Face (04:35) Minting itself access to source code (05:40) The boring plumbing that saved Hugging Face (06:41) Why AI safety tools refused to help (07:41) A second lab runs the same test (08:36) Fake identities and a human who said no (10:28) What saved the day both times (11:24) The one leg you can actually attack (12:26) Building the CAGE: Contain, Access, Guard, Exhaustive (14:18) Three questions to ask before trusting an agent (15:19) The scary part was never the malice Resources: Nicky Pike's LinkedIn OpenAI and Hugging Face partner to address security incident during model evaluation The Hugging Face incident and the road ahead | OpenAI The OpenAI-Hugging Face ExploitGym Incident: A Complete Technical Timeline OpenAI Hugging Face Hack, What the ExploitGym Incident Actually Proves The Benchmark That Broke Containment: An OpenAI Evaluation Model Escaped Its Sandbox and Breached Hugging Face Incident Report: unsanctioned agent behaviour during cyber testing | AISI Work

• Transcript
• Chapters

95% of the World Is Clueless About Platform Engineering

Everyone said AI would reduce the need for developers. Instead, it made one kind of engineer more important than ever. Luca Galante runs the largest platform engineering community on the planet. Besides hosting PlatformCon, he has also spent years watching real enterprises turn flashy AI demos into systems that hold up in production. Currently, he serves as managing director at Weave Intelligence, the analyst firm tracking how the platform model is reshaping enterprise technology. In this conversation with Nicky Pike, Luca explains why most companies now run an internal developer platform without agreeing on what it's for. He also expounds on why a platform built to serve a thousand engineers suddenly has to support an entire company once agents show up, and why he still thinks 95% of the world is clueless about the discipline that's about to decide whether AI gets deployed safely or not at all. They also get into Luca's new book, Thinking in Platforms, and his thoughts on why demos get applause they don't deserve. He also mentions the one prediction he's willing to put a number on: how many platform teams will actually survive this year? If your platform team just got handed a pile of agents and told to make it safe, this is the conversation that tells you what happens next. In this episode, you'll learn: Why automating yourself out of a task usually means getting handed a bigger one How a good platform works like a paved road, not a rulebook Why product managers are becoming the missing link between platform teams and everyone else Things to listen for: (00:00) Meet Luca Galante (02:10) Why platform engineering never had a name (04:15) The relief of finally having a name (07:35) Why AI debates are really about platforms (09:15) Inside the new book Thinking in Platforms (11:10) Why the media team dogfoods platform engineering (18:35) Why AgenticCon needed its own event (20:15) Behind the 90% platform stat (28:50) Rebuilding platforms for machine scale (31:25) Luca's 3-layer agentic development stack (37:40) Why product managers bridge platform teams (43:40) Moving from writing code to setting constraints (49:05) Rapid fire on demos and paved roads (54:45) Predictions: How many platforms will survive Day 100 (57:00) Defining a Coder: Being able to help Resources: Luca Galante's LinkedIn: https://www.linkedin.com/in/luca-galante/ Weave Intelligence website: https://weaveintelligence.io/

• Transcript
• Chapters

Are You Really Learning to Code If AI Does It for You?

John Crickett spent 30 years teaching himself to build software the hard way, and he thinks that's exactly why he's still employable. Long before anyone typed a sentence and watched an app appear, John Crickett was writing Quake bots downloaded by millions, chasing a bed and breakfast search engine years before Airbnb existed, and getting laughed out of a VC pitch for an idea he called takeaways online. Today he runs Coding Challenges, where thousands of engineers go to relearn a skill AI is quietly letting them skip. In this episode, John sits down with Nicky Pike to make an argument a lot of the industry won't like. Cranking out code has never been easier. Building the right software, for the right people, for the right reasons, is exactly as hard as it's always been. They get into what's actually driving the record number of AI projects getting scrapped before launch, why John still thinks coding and software engineering are two different jobs, and why he's calling the entire AI industry a bubble, on record, with names attached. If you've ever handed AI a one-line prompt, gotten back exactly what you expected, and wondered why that felt hollow, this conversation is for you. In this episode, you'll learn: The CEO of You, Inc. mindset he uses to justify learning outside of work Why test-driven development is about thinking, not testing The one prompt trick that turns any AI into a real coding mentor Things to listen for: (00:00) Meet John Crickett (01:20) Studying AI decades before it was cool (06:00) From Quake bots to startup rejections (12:25) Why AI projects are getting scrapped before shipping (17:15) Can AI write the blueprint too (20:25) What teams skip when AI makes coding easy (25:50) Why fewer engineers are learning to code deeply (31:05) Why you can't learn coding from YouTube alone (37:50) How to prompt AI to actually mentor you (41:30) Why you're the CEO of your own career (48:05) Getting the customer back into the process (50:40) One skill every engineer should learn by hand (53:45) Predictions: Who survives the AI bubble and who doesn't (56:30) Defining a Coder: To actually code (57:15) Final thoughts: Challenge John’s ideas Resources: John Crickett's LinkedIn: https://www.linkedin.com/in/johncrickett/ Coding Challenges website: https://codingchallenges.fyi

• Transcript

Open Source Security: The Eyeballs Were Never Enough

6,000 vulnerabilities but only 97 fixed. Nicky Pike can't stop thinking about a stat that a machine found in the open-source code your company almost certainly runs. It all started with 90 seconds of a much longer conversation. A few weeks back, Nicky sat down with Gene Kim for a full episode on citizen developers and the outer loop. Near the end, Gene described a moment from an Erik Meijer talk that stuck with them both: the suggestion that running open source at all might be crazy, that it's coupled to code nobody's actually accountable for. In this minisode, Nicky goes back through 25 years of the open source eyeballs promise and tests it against what happened this year. An AI model was pointed at open-source code and returned thousands of vulnerabilities. Maintainers, already buried, received more bug reports and barely any hands to fix them. Nicky lays out why the gap between finding a problem and fixing it, not the finding itself, has been the real issue the whole time. If your team runs open source and you've never asked who actually fixes it when something breaks, this one will change how you look at that dependency list. In this episode, you'll learn: 1. Why cURL went from weekly bug reports to one every 18 hours 2. How a stolen npm credential targeted the exact AI coding tools you use 3. Why a signed, verified package still shipped malicious code untouched Things to listen for: (00:00) The stats that proved the risks of running open source (00:53) The 90 seconds with Gene Kim that changed everything (01:37) What this episode is not saying (02:23) Linus's law and Gene’s law (03:16) How the XZ Utils backdoor got in (04:14) An npm attack aimed at AI configs (05:09) An AI model gets pointed at open source (06:12) The wolfSSL bug nobody explained (07:06) A 27-year-old claim no one can verify (07:58) Why the fix counter stopped moving (08:50) The maintainer drowning in bug reports (09:41) Why more eyeballs never meant safer code (10:30) What to actually check this Monday (11:22) Why rewriting your own code has a cost (12:17) Closing thought and a question for you Resources: Nicky Pike's LinkedIn: https://www.linkedin.com/in/nicky-pike/ Coder website: https://coder.com/ Gene Kim's Episode: Coding Isn't the Bottleneck Anymore. Gene Kim Explains What's Next Linus's Law One engineer’s curiosity may have saved us from a devastating cyber-attack | John Naughton | The Guardian Jscrambler npm Package Compromised: Why It Matters – Reflectiz Project Glasswing: Securing critical software for the AI era \ Anthropic Cybersecurity Insights with Contrast CISO David Lindner | 04/18/25 Preinstall to persistence: Inside the Red Hat npm Miasma credential-stealing campaign | Microsoft Security Blog

• Transcript
• Chapters

The Thing You Tested Isn't The Thing That's Running feat. Rick Clark

For 15 years, enterprises have signed off on a promise: the thing we tested is the thing that's running. Rick Clark, Global Head of Cloud Advisory at UST, says that promise dies the moment an agent starts making its own decisions in production. Rick helped build the cloud era himself, from Ubuntu Server to OpenStack to the Four Opens framework that still governs the OpenInfra community today. Now he's telling enterprise leaders that agentic AI is the biggest wave he's seen, bigger than cloud, bigger than open source, and it's compressing a decade of hard lessons into eighteen months. In this episode, Rick and Nicky Pike dig into why most enterprise leaders running agents in production can't fully trace what those agents are doing, why audit is the first promise to break, and why testing something yesterday tells you nothing about what it does today. If your company is racing agents into production before anyone's decided who signs off when it goes wrong, this conversation will change how you think about what "tested" and "deployed" actually mean. In this episode, you'll learn: Why the behavioral envelope replaces the pass or fail test for good How one company's 57 secret managers became a warning story Why the AI developer scares Rick more than any 2am coder ever did Things to listen for: (00:00) Meet Rick Clark (01:45) The cloud moment that changed everything for Rick (07:20) Is enterprise AI skipping the usual hype cycle (08:30) The stat that says agents can't be traced (13:45) Three promises about production that just broke (18:00) Why production is a promise, not a place (24:45) What a behavioral envelope actually replaces (29:00) How to test something you can't fully trust (32:45) The first thing a CTO should measure now (38:00) The 57 secret manager mess AI will amplify (48:00) Charred bodies and the cost of moving fast (51:00) Rapid fire on banks, AI, and observability (55:15) Predictions: when the tested artifact stops being a promise (58:50) Defining a Coder: promises a machine can keep (01:00:12) Final thoughts: getting this right instead of fast Resources: Rick Clark's LinkedIn: https://www.linkedin.com/in/dendrobates/ UST website: https://www.ust.com

• Transcript
• Chapters

If You Wake Up Hoping the Model Got Dumber, Get Out of That Business

Wave one was everyone grabbing a shovel and vibe-coding as fast as possible. Wave two is the bill showing up. Rob Whiteley has watched this movie before as he ran NGINX through the last major platform shift, and now as CEO of Coder, he's watching companies rack up token bills and security holes from software nobody thought to govern. In this episode, Rob sits down with Nicky Pike (full disclosure, Coder sponsors this show, and Rob signs Nicky's paychecks) to talk about what actually comes after the AI gold rush. They get into why the model layer is the one thing you should never lock yourself into, how to think about tiered model strategy using a tenured employee analogy, and why governance and rules are not the same thing. Rob also breaks down the real difference between a sandbox, a workspace, and a harness, and makes the case for why an engineer driving an agent will always beat a product manager doing the same. If your team is already sitting on a token bill nobody budgeted for, this conversation is your map for wave two. In this episode, you’ll learn: Why letting a product manager drive an agent alone puts your company at risk Why there will be just as many developers, only far fewer software engineers Why Rob expects two or three more Anthropic-style upsets before the year is out Things to listen for: (00:00) Meet Rob Whiteley (01:20) Why this wave feels different from cloud (06:59) Betting on infrastructure, not the tools (11:34) The Excel analogy for your job (15:39) One customer went from 800 apps to 10,000 (17:04) Your token bill is AWS all over again (21:40) Rating AI models like tenured employees (24:12) Why nobody saw the token bill coming (31:05) Governance and rules are not the same (36:20) Why an engineer beats a PM (40:47) Sandbox, workspace, or harness, know the difference (46:52) Why Coder refuses to bet on one model (56:48) Should you go vertical or horizontal (1:04:47) Predictions: who gets usurped and who wins (1:07:56) Defining a Coder: what it means to build Resources: Rob Whiteley's LinkedIn: https://www.linkedin.com/in/rwhiteley/ Coder website: https://coder.com/

• Transcript
• Chapters

AI Is Writing More Code Than Humans Can Review

What happens when the AI coder moves faster than the review process can handle? Nnenna Ndukwe has spent 8+ years as a software engineer and now works at the intersection of AI, developer relations, and enterprise engineering strategy. As AI developer relations lead at Qodo, she spends her time helping teams separate useful AI adoption from expensive chaos. In this episode of [Dev]olution, Nnenna joins Nicky Pike to talk about the part of AI coding most teams skip: review, verification, governance, and the outer loop where AI-generated code either gets controlled or breaks production. They dig into why AI does not fix broken engineering systems, how rework rate exposes the truth behind AI productivity, and why better code review needs more than another stream of AI comments. What it needs, instead, are deterministic gates, developer trust, and a clear view of where AI belongs in the software delivery process. If your team is shipping faster but fixing more, this episode will make you rethink what “AI productivity” actually means. In this episode, you’ll learn: Why rework rate may expose AI productivity better than velocity How deterministic gates keep AI review from becoming noise Where engineering leaders should introduce AI first Things to listen for: (00:00) Meet Nnenna Ndukwe (01:52) From writing code to advising leaders (04:09) Why AI made the work more interesting (07:02) Paying it forward in women in tech (09:23) AI speed is breaking production (10:30) Where the delivery jam really happens (12:32) Why rework rate tells the truth (15:42) Can AI review AI code (17:21) AI amplifies your current process (20:34) The risk of AI review slop (23:19) Why acceptance rate matters (26:27) Human-agent work needs better rules (29:23) More tokens is not discipline (36:44) Where leaders should start (41:25) Predictions: More managing systems (45:49) Defining a Coder: A problem-solver (47:08) Final thoughts: Cut the noise of AI hype Resources: Nnenna Ndukwe’s LinkedIn: https://www.linkedin.com/in/nnenna-ndukwe/ Qodo website: https://www.qodo.ai/

• Transcript
• Chapters

Coding Isn't the Bottleneck Anymore. Gene Kim Explains What's Next

Coding used to be the bottleneck. Gene Kim says that era is ending, and most companies are not ready for what comes next. In this episode of [Dev]olution, Gene Kim, author, DevOps researcher, and founder of IT Revolution, joins Nicky Pike to talk about what happens when software is no longer built only by developers. Gene has spent decades studying high-performing technology organizations. He’s since helped shape the DevOps movement and co-authored the books many engineers grew up reading. Now, he’s deep in vibe coding, working with leaders, doctors, military teams, and people who have never written code before. The big question: if everyone can suddenly build, can the rest of the company keep up? Nicky and Gene get into citizen developers, broken review gates, and why the next DevOps-sized shift may be 100x bigger. If your company is still treating AI coding like a developer productivity tool, this conversation is the reset. In this episode, you’ll learn: Why the outer loop becomes the real bottleneck when coding gets faster How citizen developers change the job of professional developers What teams should rethink before AI-generated work floods the pipeline Things to listen for: (00:00) Meet Gene Kim (02:30) The project that changed everything (08:55) Pair programming with non-developers (15:45) Why AI feels like the spreadsheet revolution (20:07) Coding isn't the bottleneck anymore (28:11) Nobody knows what comes next (35:01) Why AI should review AI code (44:51) What engineering teams should change Monday morning (50:05) AI becomes the next DevOps specialist (53:50) Could AI replace open source dependencies? (01:00:40) The economics of AI coding (01:04:20) Predictions: 50x more software from non-developers (01:11:10) Defining a Coder: Dreams becoming reality (01:14:20) Final thoughts: Learn from the frontier Resources: Gene Kim’s LinkedIn: https://www.linkedin.com/in/realgenekim/ Gene Kim’s website: http://www.realgenekim.me/ IT Revolution website: https://itrevolution.com/

• Transcript
• Chapters

96% of Companies Run AI Agents. Only 21% Can Control Them

96% of companies are running AI agents in production. Only 21% can actually control them. Gari Singh has watched this movie before. Three times. XML middleware, enterprise blockchain, and now AI infrastructure at Google Cloud, and every wave has the same opening act: teams rush to deploy before the platform team is even in the room. In this episode of [Dev]olution, Nicky Pike, and Gari break down what the outer loop actually costs you when agents go ungoverned, why "Ninja IT" is the new shadow IT, and what platform engineers need to do this Monday to stop building on a foundation that's already cracking. If you're still treating agent governance as a roadmap item, this episode is the reason to move it to the top of the list. In this episode, you’ll learn: Why automating bad processes with AI just makes bad things happen faster The three things every platform engineer should do this week, according to Gari Why MCP servers are the new SOAP and will disappear in five years Things to listen for: (00:00) Meet Gari Singh (02:00) What DataPower taught him about governing traffic (04:30) AI adoption versus the blockchain free-for-all (06:30) The stat that should scare every platform team (09:00) Why Kubernetes took a decade but AI took 18 months (14:30) Prompt injection and limiting the blast radius (18:00) Ninja IT is the new shadow IT (20:30) Automating bad processes just makes bad things worse (25:00) Self-managed MCP versus the enterprise version (28:30) Why YOLO mode survives elicitation (35:00) How platform teams hold the line without becoming the villain (39:30) The outer loop is still the bottleneck (44:00) Three things every platform engineer should do this week (51:00) Rapid fire with Gari (53:30) 2028 predictions and the governance reckoning Resources: Gari Singh’s LinkedIn: https://www.linkedin.com/in/garisingh/ Google’s website: https://www.google.com

• Chapters

Open Weight AI Isn't the Risk You Think It Is

Everyone's asking the wrong question about open AI models and has turned the debate into a geography problem. Is it Chinese? Is it American? Can we trust it? But the biggest AI security incident in recent memory had nothing to do with where a model came from. In this minisode, Nicky Pike breaks down the three layers of risk hidden behind open-weight AI models and why most security conversations focus on the easiest layer to defend. From poisoned training data and sleeper-agent research to malicious Hugging Face repositories that fooled hundreds of thousands of developers, this episode separates real threats from political headlines. If you're evaluating DeepSeek, Qwen, Llama, or any open model, this episode will change how you think about trust, ownership, and security. In this episode, you’ll learn: Why self-hosting only protects you if you control outbound access How malicious repositories create bigger risks than model origins What every engineering leader should inspect before deploying open models Episode highlights: (00:00) The repo that fooled 244,000 developers (00:35) Why everyone wants open models (01:20) The wrong question CIOs keep asking (02:10) The three layers of AI risk (04:00) Anthropic's sleeper agent experiment (06:25) How 250 documents can poison a model (08:00) The Hugging Face malware problem (09:20) Why banning models misses the real threat (10:15) Self-hosting isn't a force field (11:20) What ownership actually gives you (13:20) 4 practical defenses that work (16:20) Why open models are getting too good to ignore Resources: Sleeper Agents: Training Deceptive LLMs That Persist Through Safety Training A Small Number of Samples Can Poison LLMs of Any Size Examining Backdoor Data Poisoning at Scale JFrog Security Research on Malicious Models in Hugging Face

• Transcript
• Chapters

Why Developers Are Ditching AI and Talking to Humans Again

What if your developer community could teach you more than any AI ever could? In this episode of [Dev]olution, Nicky Pike sits down with Pauline Narvas, former Head of Community Platforms at Vercel and incoming leader at OpenAI Codex, to unpack why human connection is thriving in the age of AI. Pauline reveals how communities are becoming the hidden engines driving learning, collaboration, and real product impact. From guiding developers through AI-powered tools to building trust and loyalty in forums and Discord channels, she explains why skills like curiosity, communication, and caring are more critical than ever. Pauline also shares how her team uses AI to handle the tedious tasks so humans can focus on the creative, high-value work that AI can’t replace. Discover why being part of a community isn’t optional anymore, it’s the key to thriving in modern tech. In this episode, you’ll learn: How human-led communities are becoming the secret engine behind AI-driven developer workflows Why skills like communication, curiosity, and caring matter more than coding in the age of AI How to use AI to handle repetitive tasks while your team focuses on meaningful, high-impact work Things to listen for: (00:00) Meet Pauline Narvas (01:06) Breaking news about her new role at OpenAI Codex (04:00) How her journey led from coding to community (06:40) Teaching women to code and mission-driven growth (09:20) Overcoming early obstacles and imposter syndrome (12:00) Developers building fast with AI and its limits (14:50) Foundations still matter when AI automates coding (17:30) Human interaction versus AI for learning and support (20:00) Using community to solve problems AI can’t (24:00) Feedback loops that improve product and user experience (26:30) Skills that matter most in the AI era (31:00) Why human authenticity beats AI in community roles (34:00) AI as a support tool, not a replacement (38:00) Handling negative community interactions with empathy (42:00) Why heart and curiosity are non-negotiable hiring traits (45:50) Lessons on using AI and communities to amplify impact (49:45) Engaging with the OpenAI Codex community (55:30) What AI can’t replace and the definition of a coder (59:00) Closing thoughts and future outlook for human connection Resources: Pauline Narvas’s LinkedIn: https://www.linkedin.com/in/pnarvas/?originalSubdomain=uk Vercel’s website: https://vercel.com/

• Transcript
• Chapters

Why AI is Your Best Co-Worker in Software Development

What if your AI could patch your vulnerabilities while you sleep? In this episode of [Dev]olution, Nicky Pike talks with DaShaun Carter, Spring Advocate at Broadcom, about the growing impact of agentic AI in software development. With more companies turning to AI to accelerate development and patch vulnerabilities, DaShaun explains how AI isn't just about coding faster, it’s about automating the tasks developers hate. From patching CVEs overnight to ensuring systems remain secure while developers sleep, AI agents are reshaping how security is handled in development. DaShaun also talks about the shift from traditional coding workflows to AI-powered environments, where agents autonomously complete repetitive tasks, allowing developers to focus on more strategic work. Tune in to understand why AI isn’t a “nice-to-have” anymore, it’s essential to your development process. In this episode, you’ll learn: How agentic AI can handle critical security tasks like patching CVEs while you sleep Why shifting to AI-driven development environments can streamline your workflows and improve productivity How to implement automation in your dev processes without losing control or security Things to listen for: (00:00) Meet DaShaun Carter (02:13) The hidden value of patching CVEs (05:15) Should AI be writing or patching code? (08:34) Why security automation is essential (12:00) The rise of AI in development security (14:48) Continuous patching: A game changer (18:22) Shifting from traditional dev environments (22:00) Maintaining control with AI automation (25:06) Avoiding over-automation in development (28:15) How agents take over repetitive tasks (32:10) DaShaun’s Raspberry Pi-driven AI tasks (37:30) Will AI replace traditional coding environments? (41:45) AI agents making dev teams effective (46:00) AI and the future of dev security (50:30) Predictions for AI-driven development workflows Resources: DaShaun Carter’s LinkedIn: https://www.linkedin.com/in/dashaun/ Broadcom’s website: https://www.broadcom.com/

• Transcript

The Echo Leak Exploit: Why AI Leaks Data Without a Click

You think your AI is working for you…until it’s leaking your data. Welcome to Echo Leak, the zero-click exploit that can send your company’s most sensitive info to attackers, and you won’t even realize it’s happening. Here’s how it works: an email lands in your inbox, and without anyone clicking anything, your AI system picks it up. It accesses your sensitive data from Outlook, SharePoint, Teams, and quietly ships it out through a crafted URL, all while doing exactly what you paid it to do. This isn’t a glitch. It’s a massive vulnerability. In this minisode, we dive into the lethal trifecta, three factors that make your AI system an easy target for this type of attack. From private data access to untrusted content, to how your AI can communicate externally, it’s all laid out for you. Learn how to protect your systems, lock down permissions, and secure your AI agents before they become the next big breach. In this episode, you’ll learn: What Echo Leak is and how zero-click exploits can leak your data silently The "lethal trifecta": Three key vulnerabilities in AI systems that make them exploitable Actionable steps to restrict AI agents' permissions and prevent Echo Leak Episode highlights: (00:00) Echo Leak: How it works without any user clicks (03:00) The "lethal trifecta" and why it's a security risk for AI (05:40) Real-world Echo Leak examples from Black Hat and RSA (08:00) Vendor responses and why they’re missing the point (09:40) Understanding AI agent governance failures (12:00) Steps to secure your AI systems against Echo Leak (14:20) Restricting external communication and limiting data access (16:00) Designing AI systems with security in mind (18:00) Preparing for AI exploits like Echo Leak Resources: EchoLeak: Zero-Click Microsoft 365 Copilot Vulnerability The lethal trifecta for AI agents: private data, untrusted content, and external communication The lethal trifecta for AI agents YouTubeBlack Hat USA 2025 | AI Enterprise Compromise - 0click Exploit Methods Penetration Testing Safeguarding VS Code against prompt injections

• Transcript

Your Security Was Built for Humans, Not AI

AI agents are already embedded within your infrastructure, yet the critical issue remains: no one is truly in control. In this episode, we sit down with two experts from Red Hat, Michael Epley and Sam Richman, who are actively engaged at the intersection of AI, security, and defense. Their work isn't theoretical; it's about managing systems where the stakes couldn't be higher. Michael Epley, as Chief Architect and Security Strategist, has dedicated years to building identity and governance frameworks in environments where errors are unacceptable. Meanwhile, Sam Richman, Principal Architect for Defense, is responsible for deploying software from development environments to operational drones. This discussion reveals some uncomfortable realities surrounding modern security and AI: the presence of AI agents operating without proper identification, the ineffectiveness of security models designed for human users when governing machine behavior, and the challenge of managing systems that cannot be thoroughly tested, predicted, or trusted. Despite these challenges, these systems are being rolled out. If you're involved in developing AI systems or ensuring their security, this episode poses a critical question: Do you truly understand what your AI agents are doing? In this episode, you’ll learn: Why AI agents break traditional identity and access models How overprovisioned agents create invisible security risks What real governance looks like when systems can’t be fully tested Things to listen for: (00:00) Meet Michael Epley and Sam Richman (02:47) Are enterprises ready for AI agents (05:00) Why AI adoption outpaces value (07:00) AI finding vulnerabilities humans missed (10:58) Why AI systems are unpredictable by design (13:00) The identity problem for AI agents (17:00) Digital sovereignty becomes mission-critical (21:30) AI strategy in defense and enterprise (26:30) Why modular AI infrastructure matters (27:30) What Kagenti actually solves (31:00) Fixing overprovisioned AI agents (34:30) Observability and agent behavior tracking (38:00) AI at the edge and deployment risks (47:30) Running AI without losing control of data (59:00) Predictions for AI governance and agents Resources: Michael Epley’s LinkedIn: https://www.linkedin.com/in/epleymichael Sam Richman’s LinkedIn: https://www.linkedin.com/in/sam-richman Red Hat website: https://www.redhat.com

• Transcript
• Chapters

Is AI Actually Helping or Hurting Devs?

Adron Hall thinks you already missed the boat if you are still banging away at lines of code. He watches organizations struggle with locked-down environments while the rest of the industry moves at a pace they can't keep up with. The junior pipeline is collapsing, and we are building systems on code that nobody actually understands. Vibe coding sounds like a dream until the production system crashes at two in the morning. Adron Hall, Principal Software Engineer at Composite Thrashing Code, joins Nicky Pike to discuss why productivity gains are getting eaten by debugging and what happens when the AI agents start treating your main repo like a sandbox project. If you are wondering if you are building faster or just debugging more, this conversation provides the reset you need. In this episode, you’ll learn: Why writing code manually means you are already too far behind How to manage the six specific types of AI code changes The reason Diff Discipline is the only way to survive vibe coding Things to listen for: (00:00) Meet Adron Hall (03:14) Why the junior developer pipeline is imploding (05:13) How to reign in agent scope for better results (08:31) The slow creeping dread of vibe coding (12:50) Moving past communication cycles with prototypes (16:50) Why shipping to production needs a human gatekeeper (20:20) How roles shift when agents handle the workflow (24:05) Why slinging individual lines of code is over (29:47) Bringing a generalist approach back to computer science (34:57) Breaking down the six types of code changes (41:40) Why AI optimizes for plausible output instead of correctness (52:37) Enforcing diff limits to keep human reviewers sane (57:29) Setting up no-fly zones for sensitive code (01:02:41) The coming hundred x shock to the tech industry (01:11:27) What it means to be a coder in 2026 Resources: Adron Hall’s LinkedIn: https://www.linkedin.com/in/adron/ Composite Thrashing Code blog: https://compositecode.blog/

• Transcript
• Chapters

AI Is Skipping the Fundamentals and That Should Worry You feat. Dan Vega

Dan Vega has spent years teaching developers how to build things the right way. Now he’s watching AI change how an entire generation learns to code. Dan is a Spring Developer Advocate at Broadcom, and in this episode of [Dev]olution, we get into what happens when AI removes friction faster than it builds understanding. Writing code has never been easier, but the fundamentals are quietly getting skipped. We talk about why AI is creating masters with no apprentices, how junior developers are getting fast-tracked past the learning phase, and why understanding systems still matters more than shipping quickly. If you’re building with AI or trying to learn without losing the basics, this conversation with Dan Vega is one heck of a learning session. In this episode, you’ll learn: Why developers still need to learn how systems fail, not just how code runs How AI changes the role of mentors and what juniors are missing without feedback loops Why shipping faster doesn’t automatically mean building better software Things to listen for: (00:00) Meet Dan Vega (01:40) How AI changed the way people learn to code (05:05) Shipping code without understanding systems (08:55) Dan’s path from learning fundamentals to teaching them (12:35) How AI reinforces bad developer habits (16:00) The “masters with no apprentices” problem (19:45) Why juniors are skipping the struggle phase (23:55) Copying answers versus building intuition (28:15) Why debugging is where learning happens (32:10) Teaching reasoning instead of syntax (36:30) The danger of prompt-driven development (40:20) What senior developers should do differently (44:35) Using AI without losing judgment (48:50) Advice for developers starting today (53:30) Final thoughts on learning in an AI-first world Resources: Dan Vega’s LinkedIn: https://www.linkedin.com/in/danvega/ Broadcom website: https://www.broadcom.com

• Transcript
• Chapters