devopsy.kinsta.cloud

Category: Video Interviews

  • Giving AI Agents the Keys to Real Infrastructure

    Giving AI Agents the Keys to Real Infrastructure

    AI coding assistants can generate pull requests faster than most teams can review them, and that mismatch is creating a new kind of bottleneck across engineering organizations. The volume of AI-generated code is growing rapidly, but without a reliable way to validate that code against real production environments, teams are left choosing between slowing down to manually review everything or accepting the risk of pushing untested changes forward.

    Alan Shimel speaks with Sumeet Vaidya, CEO and co-founder of Crafting.dev, about the emerging concept of closed-loop autonomous development. The idea is straightforward: rather than treating AI agents as tools that hand off code for humans to verify, give those agents the ability to test their own output against live dependencies and real infrastructure before a human ever needs to get involved.

    The conversation explores what it takes to make that work in practice. Traditional sandboxing approaches struggle to replicate the complexity of production environments, where services interact with databases, APIs and other systems in ways that simplified test setups cannot capture. Vaidya argues that the next step for AI-assisted development is not better code generation but better code validation, ensuring that what gets produced actually behaves correctly in context.

    For DevOps and platform engineering teams, the implications are significant. If AI agents can reliably validate their own work, the role of human engineers shifts from gatekeeping individual pull requests to overseeing outcomes and setting guardrails. That changes how teams think about automation, testing pipelines and the division of labor between humans and machines in modern software delivery.

  • AI Is Forcing DevOps Teams to Rethink Observability Data Management

    AI Is Forcing DevOps Teams to Rethink Observability Data Management

    As AI coding tools accelerate software delivery, they are also intensifying a problem DevOps and SRE teams have been dealing with for years: the unchecked growth of observability data. In this conversation, the founders of Sawmills argue that telemetry volume is no longer just a cost issue. It is becoming a data quality problem that affects how effectively teams can monitor systems, troubleshoot incidents and make sense of production behavior.

    Ronit Belson and Erez Rusovsky describe how the rise of AI-generated code is making observability harder to manage. Instrumentation is often treated as an afterthought, which means more logs, metrics and traces are being generated without much discipline around relevance, quality or downstream impact. The result is familiar to many DevOps teams: rising observability bills, more noise in monitoring systems and growing difficulty separating useful telemetry from unnecessary data.

    Rather than waiting until data lands in production systems and then trying to reduce cost or improve signal quality after the fact, Belson and Rusovsky describe a model in which telemetry is reviewed and optimized closer to the point where code is written and deployed. That includes looking at instrumentation itself, not just the systems consuming it.

    They also touch on a broader operational shift now underway. As organizations become more comfortable with agentic AI, there is growing interest in using agents not only to write code, but also to continuously manage repetitive operational work. In the observability context, that means identifying noisy telemetry, highlighting gaps, feeding lessons from production back into development and helping teams keep data both useful and affordable.

    The bigger takeaway is that observability can no longer be treated as a downstream concern. If AI is going to keep increasing the speed of software creation, DevOps teams will need stronger control over the telemetry that software generates.

  • Why AI-Generated Code Is Raising the Stakes for Secrets Management

    Why AI-Generated Code Is Raising the Stakes for Secrets Management

    Following a $50 million funding round, GitGuardian CEO Eric Fourrier discusses why secrets security is becoming a much bigger problem in the age of AI-generated code and autonomous agents. As more organizations rush to deploy coding assistants and AI agents, Fourrier argues that the number of exposed credentials, API keys and tokens is rising just as quickly, creating new risks for DevSecOps teams already struggling to manage software supply chain security.

    Fourrier explains that AI agents need access to data and systems to be useful, but many organizations are still handling that access the old way by handing over secrets. That, he says, is accelerating an already serious problem. Secrets are ending up in code, collaboration tools, tickets, developer laptops and other places where they can be exposed, reused or stolen. While early concerns focused on whether large language models themselves might reveal secrets from training data, Fourrier says the bigger issue now is how humans are using these tools, especially as non-developers begin building applications with little understanding of secure credential management.

    The discussion also highlights how traditional approaches are falling short. According to Fourrier, scanning for secrets at scale still requires deterministic methods because the volume of data across code repositories, binary artifacts, collaboration platforms and cloud environments is simply too large and too costly to hand off entirely to LLMs. Instead, he sees a hybrid model emerging, one that combines fast detection with AI-assisted prioritization and remediation.

    Just as important, Fourrier says secrets security can no longer sit with one team alone. Developers, application security teams, identity teams and DevOps leaders all need to work together to prevent leaks, improve remediation and reduce reliance on long-lived credentials. As AI speeds up software creation and expands who can build software, organizations will need new safeguards, better visibility and much tighter collaboration to keep sensitive credentials from becoming the weakest link in the modern development pipeline.

  • OpenTelemetry Is Paving the Way for the Rise of the Observability Warehouse

    OpenTelemetry Is Paving the Way for the Rise of the Observability Warehouse

    Eric Tschetter, chief architect at Imply and creator of Apache Druid, explains how the rapid adoption of open source OpenTelemetry for instrumenting applications is reshaping modern observability architectures. As telemetry data volumes surge, organizations are moving toward an “observability warehouse” model that unifies logs, metrics and traces into a scalable analytics foundation capable of delivering real-time operational intelligence.

    Tschetter notes that the current observability landscape is dominated by verticalized, siloed stacks—such as Kibana tightly coupled with Elasticsearch, or Grafana with Loki. However, just as the Business Intelligence (BI) sector evolved to decouple the visualization layer from the underlying data warehouse, modern observability architecture is undergoing the exact same transformation.

    An observability warehouse centralizes telemetry into a highly scalable, cost-effective tier (like cloud object storage) without sacrificing query performance. By utilizing domain-specific compression and advanced indexing optimized specifically for logs and event data, teams can retain their complete dataset at a fraction of the traditional cost. Crucially, this decoupled model eliminates data silos. Telemetry is stored once, allowing different engineering and security teams to query the same single source of truth using their preferred visualization tools.

    Looking ahead, Tschetter also breaks down the intersection of AI and observability. Rather than magically fixing schema-less developer logs, AI will function like manufacturing automation. AI agents will dramatically increase the rate of data consumption, driving even greater demand for highly scalable data platforms capable of feeding these models real-time operational intelligence. For DevOps practitioners, the takeaway is clear: the future of observability requires robust, centralized data foundations, not just fragmented dashboards.

  • How AI Helps Teams Track Dependencies and Reduce Delivery Risk

    How AI Helps Teams Track Dependencies and Reduce Delivery Risk

    AI is showing up everywhere in software delivery, but project management is where a lot of the real friction lives. Newly appointed Planview CEO Matt Zilli talks through why planning and delivery still break down inside modern organizations, even when teams have more data and more tools than ever.

    Zilli’s point is simple: the problem is not visibility in the abstract. It is that work is scattered across different teams that make decisions in different ways, using different systems, with different operating models. That fragmentation makes it hard to see what is actually happening, where dependencies are forming, and what needs attention before a small delay turns into a wider miss.

    He argues that AI can help by turning that messy, cross tool picture into something teams can act on. Instead of people spending time chasing updates, filling out status fields, or maintaining sprawling dependency maps, AI can pull signals from the systems teams already use and surface where work is drifting off track, where risk is accumulating, and what tradeoffs matter for the next decision.

    Zilli also lays out a practical view of agentic AI. The technology is moving fast, but most organizations are not going to hand over full autonomy overnight. For 2026, he expects more proofs of concept and guided deployments where teams build confidence in specific use cases. In lower risk scenarios, that can extend beyond spotting issues to taking action, like adjusting resource allocations or sequencing work differently.

    For project managers, agile coaches, and delivery leaders, the goal is less low value coordination work and more time spent on the decisions that actually move outcomes. Zilli thinks that shift can reduce surprises, lower stress, and improve forecasting, not because planning becomes perfect, but because teams get earlier, clearer signals about what is really happening in the work.

  • How AI Is Expanding Who Gets to Build Infrastructure

    How AI Is Expanding Who Gets to Build Infrastructure

    Pavlo Baron, co-founder and CEO of Platform Engineering Labs, unpacks what’s changing in platform engineering as AI reshapes who gets to build, and how infrastructure actually gets managed.

    Baron traces the origin story back to his time building high-scale systems at Instana (which exited to IBM in 2020), where the reality of “always-on” platforms made one thing obvious: the tooling we rely on is often too low-level, too rigid, and too disconnected from real-world use cases. That gap has only widened as environments have exploded in complexity—more cloud providers, more managed services, more hybrid setups, more internal APIs, and “gillions” of tools stitched together into brittle workflows.

    One of the most interesting themes is the idea that, in the age of AI, we’re all builders now. The same wave that’s enabling “vibe coding” for non-traditional developers is also changing expectations for infrastructure work. Baron argues that classic IaC models, especially the provider ecosystem around tools like Terraform, were effectively designed for top-tier software engineers, even though many people operating in the broader DevOps and infrastructure world learned by scripting and iterating until the job gets done.

    Platform Engineering Labs’ answer is to make infrastructure extensibility feel more like a natural part of the workflow. Instead of waiting on someone else to write a complex provider, or being stuck if you disagree with how it’s implemented, teams can use AI-assisted development to create the integrations they need (GitLab, Jira, internal systems) quickly, then verify them against a robust test suite for safety and repeatability.

    Baron also emphasizes community and openness: the project is open source, active on GitHub, with a growing set of plugins plus ways to connect via Discord, blogs, and LinkedIn. The goal is simple: remove the stones in the road so more engineers can build what they need—without unnecessary cycles, ceremony, or delay.

  • AI Is Forcing a Rethink of Software Testing and QA

    AI Is Forcing a Rethink of Software Testing and QA

    SmartBear vice president of AI and architecture Fitz Nowlan explains why maintaining software integrity in the age of artificial intelligence requires organizations to double down on testing and quality assurance. He discusses how AI-driven development increases risk and why stronger QA practices are essential for reliable software delivery.

    Nowlan argues that AI-driven development increases risk in a few ways. More code gets produced, more quickly, which means more surface area for defects and more opportunity for issues to slip into production. He also notes that relying on traditional, manually authored testing approaches can’t keep up with the churn created by AI-generated code. As a result, organizations need to “double down” on testing and quality assurance, and they need to modernize how QA is done.

    A central theme of the conversation is the rise of AI-powered QA. Nowlan explains why the same wave of automation transforming software creation must also transform test management, test execution, and even test authoring. He points to functional specifications—requirements and definitions of correctness—as the source of truth that can guide both what gets built and what gets tested, especially as roles blend across development, QA, DevOps, and product management.

    The discussion also tackles a common concern: can you use AI to test AI-written code without “letting the fox guard the henhouse”? Nowlan says the key isn’t necessarily a different model, but a different structure—separating the frameworks and prompts used for QA from those used for building features, and expanding validation beyond just code to include operational signals like latency and system behavior.

    Finally, Nowlan looks ahead to “vibe coding” and citizen development, where prompts and specs matter as much as source code. His message: speed is great, but reliability still wins—and in an AI-driven world, stronger QA practices are the only way to maintain software integrity.

  • Postman Bets on Better API Documentation with Fern Acquisition

    Postman Bets on Better API Documentation with Fern Acquisition

    Postman CEO Abhinav Asthana explains how the acquisition of Fern will significantly improve the quality and consistency of documentation generated for application programming interfaces (APIs) and software development kits (SDKs), as well as the impact on developer experience and modern API-driven development.

    Fern, Asthana explains, has built momentum by helping companies generate higher-quality SDKs and developer portals—tools that make APIs easier to discover, learn and consume. By bringing Fern into Postman’s broader API platform (spanning design, collaboration, testing and monitoring), the goal is to improve the “last mile” of API programs: turning well-built APIs into well-adopted APIs.

    Asthana also argues that good documentation is becoming even more critical as developers begin relying on AI agents and automation to interact with services. Agents still depend on accurate metadata and clear descriptions to choose the right endpoints and use them correctly, and that context often comes from documentation. While AI can help generate drafts and drive consistency across large portfolios of APIs, Asthana stresses that humans remain essential in the loop—reviewing, validating and preventing hallucinations.

    API management varies by industry: fast-moving tech teams may prioritize speed, while regulated sectors demand stronger governance and lifecycle discipline. Regardless, he says discoverability and consistency are foundational. Better documentation doesn’t just help developers; it can prevent duplication, speed internal reuse, and make API-first strategies actually work in practice.

  • The Next DevOps Frontier: Governing Models, Agents and Code

    The Next DevOps Frontier: Governing Models, Agents and Code

    Anaconda CEO David DeSanto explores what it takes to make AI-native development practical, secure and scalable for modern engineering teams. DeSanto reflects on his journey from leading product at GitLab to stepping into the CEO role at Anaconda, and why the next wave of software delivery will be shaped by the intersection of open source, DevOps practices and AI governance.

    Software is increasingly assembled rather than written. With dependencies pulled from countless repositories, the software supply chain has become one of the largest sources of risk—especially as attackers target packages and organizations push more workloads into production faster. DeSanto explains how trust, curation and reproducibility matter when teams are depending on thousands of third-party components to build and ship applications.

    From there, they turn to the evolving needs of AI development workflows. Beyond packages, teams now have to account for models, agents and new “AI supply chain” artifacts that also require security controls, policy enforcement and governance. DeSanto outlines how organizations are trying to move from experimentation to production with guardrails in place—tracking lineage, performance characteristics and vulnerabilities, and creating an “AI bill of materials” that extends the same discipline DevOps teams expect in traditional pipelines.

    A standout theme is developer enablement. As AI raises the cost and complexity of building and running models, the ability to test and iterate locally—then carry those changes forward into production—becomes a practical advantage. DeSanto emphasizes a hands-on approach: staying close to builders, listening to customers, and making it easier for teams to adopt new capabilities without sacrificing control.

    As AI becomes part of everyday software delivery, the winning platforms will be the ones that reduce friction for developers while strengthening security and governance across the full lifecycle.

  • 60% of Code Is AI-Generated—Are We in Trouble?

    60% of Code Is AI-Generated—Are We in Trouble?

    Jonathan Rende, chief product officer at Checkmarx, tackle’s one of the most urgent questions in AppSec right now: what happens when AI starts writing the majority of your software?

    With estimates that as much as 60% of code is being generated by AI in some environments—and that AI-authored code is already finding its way into production—the conversation quickly moves past novelty and into operational reality. The central theme is trust: should AI-generated code be treated differently than human-written code, and are organizations holding it to a higher standard simply because they’re less confident in how it was produced?

    Rende unpacks how developer behavior is changing as copilots and agents make it possible to generate thousands of lines of code quickly, often faster than teams can realistically review it. That shift increases pressure on DevSecOps “outer loop” controls—static analysis, dynamic testing, supply chain security, and governance—to catch defects and vulnerabilities before they become incidents. The issue isn’t only volume; it’s also context. Even as models improve, secure outcomes still depend on how developers prompt, validate, and integrate AI output into real systems.

    They also explore the evolving benchmark landscape for measuring model security performance and what those trends suggest: AI-generated code may be getting less vulnerable over time, but “less vulnerable” isn’t the same as “secure.” Rende argues that while common vulnerability patterns may decline, higher-order logic flaws and transitive issues will remain difficult—and may even become more prominent as applications and AI-driven supply chains grow more complex.

    Whether code is written by humans or machines, production software still demands rigorous, continuous security testing—because in the AI era, the attack surface is expanding as fast as delivery velocity.