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.

The correlation overhead is often underestimated. When you're debugging a race condition like the payment example here, the manual work of correlating timestamps across RUM, APM, and logs can easily add 30-45 minutes per issue. And that assumes you know what you're looking for.

It took a little bit to gain traction after it’s release but the MCP saw a boom in adoption last year. But it’s not all roses, in fact, most MCP servers are collecting dust. Here's what we learned building Multiplayer's MCP server after watching this play out: 🧵

If you tried Multiplayer but didn’t finish setup, I’d love to learn why. I’m building the only tool that gives teams full-stack session replays out of the box. All correlated, all AI-ready. But if getting there feels harder than it should, that’s on me.

[1/] This year our engineering team leaned into one conviction: AI will only be as good as the context it’s given. If my background in neural nets has taught me anything it’s that data is everything. That’s why our 2025 focus was about capturing the right data in the right structure:

Where are AI tools ✦augmenting✦ our work, and where are they ✦undermining✦ the craft that makes engineering effective? As CTO of a startup building with AI, I keep coming back to this question. I shared my thoughts in this LeadDev article 👇 leaddev.com/ai/are-smart...

Most teams already test their code, UI, and infra. But ask when they last tested their APIs (thoroughly) and you’ll get a hesitant pause. Bad news: that pause is expensive. Good news: this is preventable. Better news: what makes your APIs testable also make your systems more observable.

Logs aren't dead - they just need some love. Some excellent advice in this article:

Jules Verne might as well have been talking about debugging when he said: “Science, my lad, is made up of mistakes, but they are mistakes which it is useful to make, because they lead little by little to the truth.”

I’m joining a LeadDev panel tomorrow on a topic many teams are struggling with right now: how to bring AI into your systems without creating chaos, security holes, or unexpected costs.

Monitoring will always have its place. But modern distributed systems require more: you need immediate, surgical and complete visibility *across your stack* to fully understand system behavior.

A tiny bug. A big bank. Hours lost. Internal tools don’t get the same love as customer-facing products, but the pain of debugging them is just as real.

APIs are the front doors to our systems, and users expect them to just work. Automated API testing is how we guarantee that at scale. Here are a few proven best practices: 🧵

“Ambiguous screenshots”. It says it all, doesn’t it? @farisaziz12.bsky.social is describing the nightmare that of debugging vague support tickets, with blurry photos, no reproduction steps, and endless back and forth.

Does debugging support tickets look like this for you? If yes, share the latest rabbit hole you fell into.

I’ve spent the better part of the past year working with the OpenTelemetry Collector to ensure our full-stack session recordings include automatically correlated backend traces. Here are the lessons I’ve learned (sometimes the hard way) about configuring the Collector 👇

👇 @farisaziz12.bsky.social describes the pain of customer support perfectly. It’s always exciting to see Multiplayer show up in real-world stories like this, as part of how engineers actually solve problems. Seeing it used to cut through the “screenshot chaos” is exactly why we built it.

"Effective debugging isn’t about speed. It’s about visibility and understanding. When AI has access to complete context, it becomes a real collaborator in that process." 👆 This is exactly why we built Multiplayer. 🤩

Optimizations don’t have to be flashy or complex and a 5-minute fix to our CI/CD pipeline saved us 5hr a day. This is a reminder that even the most obvious optimizations can hide in plain sight when you’re heads down building the next big thing.

A sneak peak of my presentation for tomorrow’s MCP demo night 👀 If you’re in New York - come say hi!

Claude Code error or human error? From the latest Anthropic blog post: variable names don’t match (red)…misspelling of urgent (blue) … unnecessary second check (second yellow line)

🧵 What is an “AI Engineer,” really? It’s one of the hottest job titles of 2025 but also one of the most misunderstood. Let’s unpack what the role actually means (and why it matters).

When your AI confidently ‘fixes’ production. Don’t worry, I’m sure it learned from this. 😅

Sometimes the frontend data isn’t enough. Sometimes (okay, always) you also want to know what happened in the backend.

This is a good time to remind everyone of the AI Darwin Awards. 😆

Devs: I’ll just make a small change. QA tickets: 🐶🐶🐶🐶🐶🐶🐶🐶

MCP servers are everywhere right now. But most are collecting dust. The key lesson we’ve learned at Multiplayer: scope matters. 🧵

I repeat. DON’T UPVOTE. I don’t care about that. I just want to hear your feedback: 👉 Would you use this mainly for debugging, testing, or feature development? 👉 Have you tried session replays before? What worked, what didn’t?

I repeat. DON’T UPVOTE. I don’t care about that. I just want to hear your feedback: 👉 Would you use this mainly for debugging, testing, or feature development? 👉 Have you tried session replays before? What worked, what didn’t?

Is it ever really possible to get a dev to switch tools once it "works well enough"?

If you haven't yet, I highly recommend checking this collection of reference implementations for the Model Context Protocol (MCP). 👇

Most “session replay” tools show you what happened in the browser. Multiplayer shows you what happened across your entire stack.

I had the chance to speak at API World 2025 last week on a topic I’ve seen frustrate teams for years: API documentation. Because let’s face it: most developers don’t want to read static docs. Outdated Postman collections and PDF references slow everyone down.

Dashboards are great at showing symptoms: CPU is spiking, latency is up, error rates crossed a threshold. But when you need to understand why dashboards alone don’t cut it. 🧵

What’s more expensive: developing a new API or fixing a bug?

I wrote a feature that auto-generates a test script from a bug. Basically: run the bug once, never write that test from scratch again.

Most monitoring tools give you summary data about a crash. Very few help you see it in detail as if you had a dash cam.

Reproduced a bug that’s haunted us for weeks. Watching it unfold in a single timeline, with traces + request/response payloads + screens in one place… Is this what closure feels like?

I’m giving away $195. No catch. No crypto wallet required. Yes, it sounds like a scam. No, it’s actually a free pass to API World in Santa Clara, Sept 3–5. Want it?

Heisenbugs don’t disappear. They wait for demos.

Great API monitoring is knowing that when something breaks, you’ll know where, why, and how to fix it.

99% of debugging time is just trying to get the system to confess.

Is there a better compliment for an engineering manager?

If you only sample at the beginning of a request (head-based sampling), you might miss the error that happened at the end. Tail-based sampling is heavier, but smarter and increasingly worth the cost on critical paths.

The worst part of a flaky test isn’t that it fails. It’s that no one trusts it when it passes.

Hooked up a full-stack session replay to Cursor. Watching it suggest a fix with actual request/response data was… kind of magic.

The moment a bug enters production, every missing trace becomes a tax on your time.

Spent yesterday afternoon breaking the demo app in different ways and recording how we fix it with full-stack replays and AI-assisted suggestions. It was fun! 😆

In every system I've worked on, API integrations start out deceptively simple: a few endpoints here, a webhook there. But scale, uptime requirements, and changing business needs reveal the cracks fast. Here’s the summary of key API integration best practices I recommend every engineering team adopt