devopsy.kinsta.cloud

Category: Video Interviews

  • Bringing Order to Chaotic Software Engineering Workflows

    Bringing Order to Chaotic Software Engineering Workflows

    Software development has never been tidy, but the current landscape feels more chaotic than ever. Shannon Mason, chief strategy officer for Tempo, dives into why software engineering workflows remain chaotic and what teams should be doing to try and restore application development order.

    Developers today face a relentless push to innovate while keeping complex codebases running securely and efficiently. AI has been billed as the great productivity booster, but early research paints a more nuanced picture. Cornell studies and MIT reports show that while AI tools can accelerate work for junior engineers or greenfield projects, they often slow down experienced developers working with mature, complex systems. The result? More debugging, more oversight, and sometimes more frustration than gains.

    Shannon draws a useful analogy: think of AI as “the world’s smartest intern.” It’s promising, but it still needs guardrails, guidance, and plenty of supervision. Left unchecked, AI-generated code can be verbose, insecure, or just plain wrong—adding to the workload rather than reducing it. Layer in the explosion of low-code and no-code tools, plus the rise of citizen developers, and the volume of software entering pipelines is set to grow dramatically. That democratization is exciting, but it also raises hard questions about scale, security, and quality.

    At the human level, the pace of change and the constant context-switching are pushing teams to their limits. Shannon highlights practical remedies: make work visible, avoid overloading teams, plan realistically (80% capacity, not 120%), and carve out focus time. Even simple steps like instituting a weekly no-meeting day can improve flow and reduce burnout.

    The takeaway is clear: AI won’t magically fix software development chaos, but with smart practices, cultural shifts, and realistic planning, teams can navigate the turbulence—and maybe even rediscover some joy in building great software.

  • Why APIs Alone Won’t Cut It in the AI Era

    Why APIs Alone Won’t Cut It in the AI Era

    Kumar Chivukula, co-founder and CEO of Codeglide.ai (a subsidiary of Upsera), explains why the rise of the Model Context Protocol (MCP) is reshaping how enterprises connect APIs to large language models. For years, APIs have served as the backbone of data access, but they were never designed with AI in mind. They lack memory, context, and intent awareness—forcing developers to bolt on brittle glue code every time models change.

    Anthropic’s introduction of MCP earlier this year marked a turning point, offering a standardized way to make APIs context-aware and AI-ready. But as Chivukula points out, adopting MCP isn’t just about creating a one-off server. Enterprises run tens of thousands of APIs—many undocumented, outdated, or internally facing—and keeping pace with rapid model changes demands a lifecycle approach. That’s where CodeGlide positions itself: a continuous MCP server platform that automates creation, updates and security scanning at scale.

    The comparison to cloud migration is apt. Just as lift-and-shift approaches left organizations with bloated costs, treating MCP as a quick wrapper on existing APIs won’t cut it. Instead, enterprises need a sustainable framework that refactors APIs for AI interaction, enforces security, and manages change continuously. Chivukula highlights integration with GitHub’s vast ecosystem—home to tens of millions of API repositories—as a critical lever to reach both developers and enterprises.

    With more than a billion APIs in existence and an emerging AI economy valued in the tens of billions, MCP adoption isn’t optional—it’s inevitable. The question is how organizations will navigate the transition without drowning in complexity. Platforms like CodeGlide hint at one possible path forward.

  • MCP Emerges as a Catalyst for Modern DevOps Processes

    MCP Emerges as a Catalyst for Modern DevOps Processes

    Loreli Cadapan, VP of product at CloudBees, discusses how the Model Context Protocol (MCP) developed by Anthropic will provide the foundation for reinventing DevOps workflows.

    Cadapan explains that MCP acts as a bridge between large language models and enterprise DevOps environments, functioning as a kind of control plane. It can connect with different CI/CD tools and testing frameworks, pull in real-time data on pipelines and vulnerabilities, and even orchestrate tasks across the software delivery lifecycle. By reducing context switching and integrating with existing developer tools, MCP is designed to improve both productivity and governance.

    She compared MCP servers to factory floor managers—directing specialized AI agents that handle specific tasks such as diagnosing build failures or recommending tests. The challenge, she noted, is ensuring those agents are trained on the right data. As with any AI, the quality of output depends heavily on the quality of the inputs and feedback they receive.

    Cadapan acknowledged that AI adoption varies across organizations. Some want co-pilot style assistance with humans in the loop, while others are experimenting with allowing agents to fully automate parts of their workflows. Either way, she stressed that guardrails and policies must be in place so that outcomes are reliable, secure, and aligned with enterprise requirements.

    Looking ahead, Cadapan sees AI changing not just coding and pipelines but also product management practices, from drafting requirements to validating solutions. As AI-generated code and commits increase, bottlenecks are shifting downstream—from developers to reviewers and pipelines. Her advice for teams is to stay informed, experiment carefully, and validate outputs rather than trusting AI blindly.

    The broader message: MCP and AI agents are early steps toward rethinking the entire software delivery lifecycle. As software delivery accelerates and AI-generated code becomes commonplace, the real challenge will be ensuring pipelines, governance, and teams evolve at the same pace. For DevOps practitioners, that means preparing now for a future where AI is embedded in every stage of the lifecycle.

  • How AI-Created Code Will Strain DevOps Workflows

    How AI-Created Code Will Strain DevOps Workflows

    Nick Durkin, Field CTO at Harness, explains why as artificial intelligence (AI) tools are relied on more to create code, it’s now only a matter of time before bottlenecks in existing DevOps workflows become exacerbated to the point where they need to be re-engineered.

    Durkin noted that while AI is generating more code, organizations are not necessarily moving faster. In fact, industry reports show a slight slowdown, along with an uptick in bugs. The challenge, he said, lies in making it easier for engineers to do the right thing while putting guardrails in place to prevent errors, regardless of whether the code was written by a developer or an AI.

    One issue is the proliferation of pipelines. In the past, teams often created a separate pipeline for every application, leading to thousands of variations that were difficult to manage. Durkin argued for a template-driven approach, where reusable pipelines with built-in policies make failures visible early and allow fixes to be made quickly — more like a video game that encourages iteration than a static approval process.

    The rise of AI, he added, puts pressure on organizations to modernize their CI/CD platforms. Instead of stitching together dozens of tools, companies need scalable pipelines that can be automated and reused, with AI assisting in tasks such as test generation, troubleshooting and infrastructure management. The goal is to remove repetitive work so engineers can focus on higher-value problems.

    Durkin also addressed the paradox that while AI can speed up some tasks, it may still extend delivery timelines. He sees this as part of a broader shift toward platform engineering, where context and governance matter more than raw speed. Increasingly, these conversations are moving beyond engineering leadership to CEOs, COOs and boards, as software delivery becomes central to business competitiveness.

    Ultimately, Durkin emphasized that AI won’t replace the fundamentals of software delivery but will change how organizations approach them. Success will depend less on how much code is produced and more on how effectively pipelines, policies and platforms channel that output into secure, reliable applications. In his view, the companies that thrive will be those that treat AI as an accelerator for disciplined practices rather than a shortcut around them.

  • AI-Driven Observability: Fast, Context-Rich MCP Servers

    AI-Driven Observability: Fast, Context-Rich MCP Servers

    Christine Yen—developer-turned-CEO—explains why Honeycomb built an MCP server and why every observability vendor may follow. MCP, short for Model Context Protocol, acts like a concierge for AI agents: It makes a product’s API, telemetry schema and helper tools easily discoverable so large-language models can ask precise questions instead of guessing. Yen sees it as table stakes for letting bots troubleshoot production just as humans do.

    Speed is the first requirement. Engineers won’t wait minutes for an LLM to fetch a log slice or distribution graph. Honeycomb’s mantra—fast is a feature—now pays off when an agent fires off dozens of sub-queries during root-cause analysis. Yen jokes that no one wants to brew coffee while a model thinks, so the platform’s near-instant queries translate directly into snappier conversational answers.

    Depth of data is the second pillar. Because customers pipe richly labeled events (“checkout_latency_ms”, “user_tier”) instead of fixed dashboards, even off-the-shelf models can map plain-English prompts to meaningful fields. Yen argues this beats the “narrow metric lists” many teams still rely on; a model that understands business context can pinpoint anomalies without endless prompt engineering.

    Yen admits she no longer remembers every field in Honeycomb’s own dog-food cluster—but the MCP server does. She expects newcomers to treat agents as default copilots, while power users toggle between raw queries and natural language. The challenge for vendors, she says, is balancing both paths without forcing engineers into one camp.

    Yen’s closing advice: start experimenting now, map where your context lives and demand that every tool expose it through open protocols. The future observability stack won’t just collect data; it will serve it—fast and in the right context—to whatever human or agent asks first.

  • Context on Tap: How MCP Servers Bridge AI Agents and DevOps Pipelines

    Context on Tap: How MCP Servers Bridge AI Agents and DevOps Pipelines

    Large language models can draft code or move artifacts, but without situational awareness they still trip over the basics. Cloudsmith CEO Glenn Weinstein tells Mike Vizard why a new piece of plumbing—the Model Context Protocol (MCP) server—is quickly becoming table stakes. Think of MCP as a receptionist for AI agents: it answers questions like “Which Docker images are in my repo?” and supplies environment-specific details the model would otherwise guess—or miss entirely.

    Context alone isn’t enough. Developers increasingly chain agents together to run multi-step jobs—pull a package, scan it, publish it—without a human in the loop. That hand-off requires agent-to-agent (A2A) protocols so one bot can call another securely and without endless re-authentication. Google’s recent move to donate A2A to the Linux Foundation hints at how fast the ecosystem is converging on open standards.

    More context and more agents lead to more builds—sometimes hundreds per day. Weinstein warns that existing CI/CD pipelines will bottleneck if artifact storage can’t keep up. Teams already accustomed to nightly releases will feel pain when AI turns “once a day” into “once an hour” unless repositories serve packages globally and caches stay warm.

    There’s also a supply-chain angle. Hallucinating agents may suggest outdated or even nonexistent packages. An artifact manager that doubles as a control plane—tracking provenance, scanning for vulnerabilities and rejecting spoofed names—becomes a final checkpoint before code reaches production.

    Weinstein’s takeaway is blunt: experiment with AI copilots today, but raise expectations for every tool in your stack. If a platform can’t expose its data through an MCP endpoint and play nicely with agents, it will feel ancient in a year. Start mapping where context lives, audit your APIs and assume that the next generation of developers will treat AI companions as a given. Your pipelines should be ready before they arrive.

  • Is Generative AI Replacing Junior Developers?

    Is Generative AI Replacing Junior Developers?

    Generative AI tools aren’t just autocomplete for code—they’re reshaping the very first rung on the engineering career ladder. Host Mike Vizard asks Juan Salinas, VP of business development at Jalasoft, and software engineer Rolando Lora whether entry‑level developer jobs are about to disappear.

    Salinas is blunt: the routine, low‑risk tickets that once taught newcomers the ropes are now exactly what teams hand to AI agents. University graduates were “20–30 percent job‑ready” before; today the same agents that help them finish coursework will compete for their first paychecks.

    Lora counters that the picture isn’t all doom. Lightweight “vibe‑coding” chats let designers and product owners spin up prototypes in hours, while senior engineers use agentic AI to explore multiple implementation paths and ship higher‑quality features. The catch, he says, is that newcomers must learn to review—not just generate—code, and master “context engineering,” the craft of feeding agents the right background so they solve problems in one pass.

    Both envision a mixed future: specialized agents will handle boilerplate and reviews, while humans focus on architecture, judgment and systems thinking. For that to work, academia must stop graduating “juniors” and instead turn out mid‑level developers who already know how to collaborate with AI responsibly. Hiring managers, Salinas adds, should map each task to a spectrum—augmentation, automation or full agency—and invest in upskilling rather than backfilling rote work.

    The take‑away: early‑career coding isn’t dead, but its fundamentals are changing fast. Anyone entering the field will need to treat AI as a teammate they trust—yet constantly verify. That means pairing curiosity with critical thinking and realizing that debugging a machine’s work may become the new entry ticket to the profession.

  • Scaling DevOps: Tackling Infrastructure Automation

    Scaling DevOps: Tackling Infrastructure Automation

    Spacelift CEO Pawel Hytry dives into the infrastructure automation challenges DevOps teams are facing following the picking up of an additional $51 million in financing.

    Infrastructure-as‑code was supposed to make provisioning easy—copy some Terraform, hit “apply,” and move on. In practice, teams soon discover that version‑controlled snippets are only half the story. Once dozens of developers start spinning up resources, you still need collaboration, security reviews, cost oversight and a reliable audit trail. Hytry explains why his biggest customers hit a wall: what used to take a day to deploy now drags on for a week because manual approvals, rollbacks and duplicated code clog the pipeline. The tipping point usually arrives when an infrastructure lead realizes the team is hiring people just to babysit scripts.

    Hytry argues that the answer isn’t to lock everything down; it’s to add “guard‑railed self‑service.” A central platform team defines reusable modules and policies, then lets application squads launch infrastructure inside those boundaries. That keeps velocity high while preventing surprise cloud bills or rogue ports. He frames the approach as a natural fit for the rise of platform engineering, where one group maintains the paved road so everyone else can drive fast without veering off a cliff.

    AI enters as a helper, not a takeover artist. Hytry envisions agents that trace resource drift or predict cost spikes, with a human still approving changes—at least for now. The broader lesson, he says, is to replace brittle, ticket‑based processes with automated pipelines that scale as headcount and complexity grow. Teams that ignore the sprawl will keep paying in slow deploys, mounting cloud spend and tired engineers.

  • Fast Code, Real Risks: Guardrails for AI-Generated Software

    Fast Code, Real Risks: Guardrails for AI-Generated Software

    Yonatan Arbel, developer advocate in the Office of the CTO at JFrog, dives into the potential risks and rewards of relying on artificial intelligence (AI) agents to build and deploy software.

    Yes, more code is shipping faster than ever, Arbel admits, but volume alone isn’t a win—each hastily synthesized line must still survive build servers, security scanners and production reality. “Not everything in life comes for free,” he reminds, framing AI acceleration as an IOU that must eventually be paid down with careful review.

    To drive the point home, Arbel shares a personal misadventure. While traveling, he used a “vibe-coding” platform to whip together a receipt-tracking app. The tool auto-generated an impressive login flow and slick UI, so he proudly shared the URL with friends—only to discover their receipts mixed with his the next morning. A quick code dive revealed an AI-written SQL query that fetched every user’s data instead of scoping to the current account, proving how easily privacy can be breached when humans skip the boring inspection step.

    From there, the conversation turns to guardrails. Developers are becoming “pilots with copilots,” Arbel notes, spending more time instructing chat windows than writing functions. That shift demands automated policy checks, dependency vetting and runtime governance so velocity doesn’t eclipse trustworthiness. DevOps teams must embed quality gates early and often, treating AI-generated packages and prompts just like any other third-party code subject to organizational rules.

    Arbel’s advice is pragmatic: Start small, review everything, and remember that speed without oversight is just a fast track to technical—and financial—pain. Used thoughtfully, AI can compress months of work into days, but only if teams stay vigilant, enforce context-aware policies and let security evolve in lockstep with the bots.

  • How DevOps Strategy Is Evolving with Jim Cassens

    How DevOps Strategy Is Evolving with Jim Cassens

    Perforce Software CEO Jim Cassens dives into how the company’s overall approach to DevOps is evolving in the wake of a series of acquisitions.

    Cassens talks through the company’s recent spate of acquisitions and how thoughtful integration—not just portfolio expansion—is driving value for customers. He also highlights the growing role of synthetic data, AI-enhanced testing and how automation is shifting the responsibilities of development teams.

    A recurring theme is how generative AI is disrupting—not replacing—traditional developer roles. Cassens sees AI as a force multiplier, taking on repetitive, low-level tasks while freeing developers to focus on higher-order problems. But with that shift comes a challenge: How do early-career engineers gain the hands-on experience they need when entry-level work is being automated? That’s a question Cassens believes employers, not just universities, will need to answer.

    They also delve into the pressure DevOps teams face as pipelines become more brittle and overloaded. Cassens warns that the current approach to automation and scripting isn’t sustainable in a world where AI can flood pipelines with code at unprecedented volume. Organizations will need to rethink how they structure CI/CD, data management, and even pipeline observability.

    Finally, Cassens touches on the human element behind every digital transformation. As leaders weigh new tools and AI-powered workflows, he advises them to consider the fear and uncertainty many team members may be feeling—and to support them through education and open communication. The DevOps landscape may be changing fast, but people, not just platforms, will determine how successful the transition is.