Yes. Session-based, unsampled runtime data collection is very cool 😎

Today we're open sourcing Multiplayer: run our debugging agent locally, next to your coding agent, and fix production bugs automatically. 👉  github.com/multiplayer-...

1 in 3 engineering managers is thinking about going back to IC. 37% say their hands-on technical work has increased in the last 12 months. AI made building fast enough to compete with managing again. @leaddev.com latest report puts numbers on what a lot of us have been feeling.

The latest Jellyfish's AI Engineering Trends research shows token consumption climbing sharply, but PR revert rates remain roughly flat across all AI adoption tiers, hovering in the same 0.45%–0.65% band they were in a year ago. More tokens per developer hasn't bought fewer reverted PRs.👇

This meme is a lie and we all know it 👇 Human PR review was always a bottleneck. We merged things we hadn't fully read and shipped things we shouldn't have. The difference now is that coding agents made it worse with PR slop.

First time at #KCDNewYork. Great event, easy to meet people, fantastic food. Met @salaboy.com, newly elected CNCF TOC member and author of Platform Engineering on Kubernetes. Already at the top of my reading pile. See you at the next one. 🙌

Who wants to review this PR? 👇😅 PR reviews were already a known weak point in software development before AI coding agents arrived. They just made it impossible to ignore.

Every major model release makes the same point: the frontier keeps moving. Claude Fable 5 today. Something better in six months. The most underrated decision any engineering team makes right now: building AI workflows that are MODEL-AGNOSTIC.

I'm speaking at the #DeveloperWeek conference tomorrow in 📍New York. If anyone is interesting in discussing agentic coding, debugging, or just have a coffee, find me and @bkstephj1.bsky.social ☕️

Back in NY from #LDX3 London. 3 sessions in 2 days: AMA panel, a talk on why most MCP servers are collecting dust, and moderating a peer group. The questions after my talk made every hour of prep worth it. @leaddev.com sets the bar high for developer conferences!

It’s hard not to make the connection between between AI output quality and data input. The sooner the distinction between dashboard data and agent data becomes a first-class engineering concern the sooner coding agents will actually deliver on what everyone expects them to do.

“some companies are shipping as many as 50% more defects than before.” This is 👆 from a recent DX report on AI-assisted engineering which confirms what many engineering teams have been quietly noticing: adoption is up, but quality continues to be inconsistent.

I'm speaking at the LDX3 conference next week in 📍London, UK. If anyone is interesting in discussing agentic coding, debugging, or just have a coffee, find me and @vladistevanovic.bsky.social ☕️

“Shift left” has become one of those empty buzzwords that started as genuinely useful and has become misunderstood or misused to the point where it just creates more confusion. See 🧵for the most concrete damage “shift left” does IMO

Replace PR slop with a handful of high-quality PRs. Coding agents prompted by incomplete observability data produce noisy, low-quality PRs that create more review work than they save. Multiplayer provides coding agents unsampled, full-stack session data. Try it for free today: www.multiplayer.app

Minneapolis last week. New York on June 9-10. I'll be presenting at DeveloperWeek a talk I've been wanting to give for a while: From Alert to Action: Redesigning Your Observability Stack for Agentic AI.

First time at the @cncf.io Observability Summit. First time speaking there too. Honestly, what a rush. I gave a talk on building MCP servers and shared some of the lessons we've learned building the @multiplayer.app debugging agent on top of #OpenTelemetry.

I'm attending the Cloud Native Computing Foundation (CNCF) Observability Summit today in 📍Minneapolis, Minnesota. If anyone is interesting in discussing agentic coding, debugging, or just have a coffee, find me and @bkstephj1.bsky.social ☕️

Your manager doesn't care how many PRs you opened this week. They care about this: (1) Change Failure Rate (CFR): the % of deployments that break something in production. Industry benchmark is 4%. Some teams using AI coding tools are now running at 6%, shipping 50% more defects than before.

According to the most recent Pragmatic Engineer survey, Staff+ engineers use agents regularly at a rate of 63.5%, outpacing regular engineers (49.7%), engineering managers (46.1%), and directors and VPs (51.9%).

There's a story economists love to tell about ATMs and bank tellers. If you're a developer, you've probably heard it cited in relation to AI tools: the technology won't replace you, it will assist you.

Most engineering teams are using AI to write code faster than ever. But they are also shipping bugs with equal speed. Ultimately, the root cause is a data problem.

Coding agents take bad metadata at face value. They won’t reconcile five different naming conventions for the same entity. This is a fundamental and under appreciated asymmetry: humans accumulate skepticism as a kind of professional immune system. AI agents don’t.

AI has no intuition for “that’s sus”. AI agents have none of that scar tissue that experienced developers accumulate over time.

The Law of False Alerts: “As the rate of erroneous alerts increases, operator reliance, or belief, in subsequent warnings decreases.” Too many alerts and people stop reading them. Too many false positives and people stop trusting them.

Everyone in the room nods when you say “garbage in, garbage out.” It’s the first thing developers say when you ask them about AI and data quality. It’s also, apparently, the last thing they think about when they connect their observability stack to a debugging agent.

Hot take for a room full of observability practitioners: Logs, traces, and metrics were designed for a world where humans wrote and reviewed every line of code. That world is gone. I'm speaking at @cncf.io's Observability Summit North America in Minneapolis on May 21–22.

Turns out “is that a problem?” has a pretty clear answer.

I'm joining this panel 👇 today and I'll be bringing a slightly uncomfortable perspective. 👀 Looking forward to an honest conversation with Jon Haddad, Michele Mancioppi, and Amy Tobey about what it takes to make agentic observability actually work.

📅 Today, Wed, 18 MAR 2026 🕘 10:00 AM PDT | 1:00 PM EDT | 6:00 PM CET A panel on agentic observability with @tomjohnson3.bsky.social, @rustyrazorblade.com orblade.com, @michele.dash0.com, and @renice.bsky.social Hosted by @dash0.com and @leaddev.com Save your spot: leaddev.com/event/a-blue...

System-first o11y has its function, but more and more devs are realizing that effective debugging requires a session-first approach with a single timeline that correlates: • User interactions • Console errors • Network req/res • Backend traces and spans

This chart should scare you👇. 96% of developers don't fully trust AI-generated code, yet only 48% always review it before it ships. Sit with that for a second.

First time speaking at a @cncf.io event. If you're going to be in Minneapolis, let's connect. ☕️👇 My talk will be all about the hard lessons from moving an MCP server into production and how to design for AI agents and effective debugging. Full schedule: observabilitysummitna26.sched.com

If your team isn’t discussing Spec-Driven Development or how your design decisions are documented, versioned, and shared, you’re undermining your AI tooling strategy.

AI agents (especially when running in parallel) don’t operate well on vague intent. They need precise, well-reasoned specifications to make consistent decisions.

Most engineers tune out when they hear “system design.” It feels like overhead. Until AI forces you to care about it.

If your data is scattered across tools, aggressively sampled, and missing payloads … AI can't magically correlate it for you. You're automating a broken workflow.

Reading and understanding someone else’s code is significantly harder than writing code yourself. AI-generated code is, in every meaningful sense, someone else’s code.

Adding AI to legacy observability practices won't make debugging faster. It'll just amplify the problem.

Built an MCP server recently? Did developers actually use it, or is it collecting dust? 😵 I'll be speaking at @leaddev.com (June 1-2) about why "connecting AI to everything" doesn't work and what actually does when building tools that move from assistants to autonomous agents. See you there? 🇬🇧

▶ Reading unfamiliar code is exhausting. Now imagine that code is coming from an LLM that writes faster than you can think and doesn't take lunch breaks ◀ The AI productivity paradox: code is written faster than ever, but humans can’t keep up with manually reviewing it (or debugging it)!

Debugging AI-generated code is annoying (and time consuming). Debugging AI-as-a-runtime-component is a completely different problem.

Teams that fix the data correlation problem ship faster and debug smarter. But what exactly is it? It’s when debugging (understanding what went wrong) takes longer than fixing because the information is in a bunch of different places: Sentry, Stripe, LogRocket and several APM tools.

Traditional software: `Input A → Output B` (always, reliably, debuggably) AI-generated software: `Input A → Output B... or B', or B'', or sometimes C` That’s why 👆 debugging AI-generated code is tricky.

Five screenshots. Three 'can you also send...' messages. Twenty minutes later, you finally have enough context to start debugging. Have you ever had (or witnessed) a similar conversation in Slack? 👇

Agreed. AI excels at pattern recognition (code review, static analysis) and iterative debugging when it has the *right context*. That's the key: what you feed them. AI debugging works when you give it complete context: user session replays, full traces, request/response data, runtime behavior.

AI debugging is great... until you hit the context bottleneck. In particular, you need runtime data: what the user did, what the backend processed, what came back, etc. Without that, you're indeed getting vibes, not diagnosis or solutions.

Marc Donner: “Of all my programming bugs, 80% are syntax errors. Of the remaining 20%, 80% are trivial logical errors. Of the remaining 4%, 80% are pointer errors. And the remaining 0.8% are hard.” This sentiment is surprising relevant for AI tools.

I’m joining a panel tomorrow on agentic observability and AI-powered troubleshooting. I’ll be speaking with: • Michele Mancioppi (Dash0) • Amy Tobey (Netflix)

We've been experimenting with AI coding tools at Multiplayer for the past year: Copilot, Cursor, Claude Code, Codex. All impressive. All with the same fundamental limitation. They excel at the "write code" part. They struggle with the "understand what's actually happening in production" part.