t0kt0

writing about web craft, CSS, design engineering 🌈 by & for diversity in tech

3 August 2026

careervueai

Checkly: four monitor types, and how AI changed the way we ship them

From learning the hard way with URL monitors, to a playbook for DNS, to ICMP built mostly with AI, and gRPC built almost entirely by agents.

The uptime monitors in Checkly today. Image: Checkly.

At Checkly since September 2024. Monitor types: November 2024 to July 2026.

I joined Checkly in September 2024 as a frontend engineer. Checkly runs checks against your apps and APIs and tells you when something breaks. Since then I've helped ship four new monitor types: TCP, URL, DNS and ICMP. Each one went faster than the one before, and the reason changed along the way. First it was experience, then a playbook, and then AI.

End to end means end to end

A new monitor type at Checkly is not a new form. It's the UI, but also the API, the docs, the CLI, the Terraform and Pulumi providers, the Go SDK and the data pipeline. A lot of those places aren't frontend.

I don't want to become a backend engineer, but being able to follow a problem through the whole stack makes my frontend work better. When an error message is confusing, I want to know where it comes from, not just how to style it.

TCP and URL: learning a bunch of stuff

TCP was my first one, from beta in November 2024 to general availability in February 2025. I built the create and edit flows, and debugged a lot of edge cases with the backend team. Mostly I was learning how a check travels through Checkly, from the form to the runner and back to the results page.

URL monitors came next, in the summer of 2025. We renamed our HTTP checks to URL monitors, rebuilt the overview, results and reports pages, removed the feature flag, and launched in July.

The launch was messy, and I learned more from that than from anything that went smoothly. We changed too many things at once: billing, a new monitor and a new offering. Feedback kept arriving until the last minute, and nobody was clearly responsible for saying "let's roll". But we got early feedback from real users fast, and that shaped what we did next.

DNS: a playbook

By the time we started DNS monitors in September 2025, we knew which pieces a new monitor type needs and in which order. DNS shipped in November, faster than URL, with less drama.

The useful part was writing it down. DNS became our "new monitor type" playbook, and I wrote a doc listing every docs area a new check type touches. I first wrote it in Notion. Then I moved it into the repo docs, next to the code, so it would be easy to find. At the time I thought I was writing for the next engineer. It turned out I was also writing for agents.

ICMP: mostly AI

An early ICMP check result, from my PR in January 2026.

ICMP monitors started in December 2025, and that's when the way I work flipped. In November most of my work was manual. By January about 80% of it was AI-assisted.

ICMP was the perfect project for it. We had already shipped three monitor types, so every ticket, PR and doc from TCP, URL and DNS was a template. I set up a Claude Project with the long-running context for the feature: the playbook, the earlier PRs, the decisions we'd made. Then I let the agent build most of ICMP across the UI, the docs, the CLI and the SDKs, while I steered, reviewed and tested. In April 2026 I gave a brown bag talk to the team about this, using ICMP as the example.

ICMP was generally available in early 2026. It also taught me something uncomfortable. We had tracking in place, but we never decided up front what success looked like, and I didn't draw the loop back to whether it worked. Now I decide the success metric before I start, and I go back and read it after launch. I also use agents to check work, not just to write it. Agents should bring evidence, not just changes.

gRPC: almost entirely agents

All this work ended up in Daniel Paulus' gRPC monitors. Each of the earlier monitor types took a team of four or five people. gRPC was mostly one person and a fleet of his agents. The playbook, the docs map, and every PR from the four monitor types before it gave the agents enough context to do most of the work. gRPC monitors went generally available in July 2026, together with SSL and Traceroute monitors.

What I take from it

Looking back, the work that made us faster was never the code. It was writing down what we learned: the retro after a messy launch, the playbook after DNS, the docs map, the context for ICMP. That writing was meant for people. Now it is also what lets an agent build a monitor type end to end.

So I still write things down. I just know there are two kinds of readers now.