After the AI mandate: inside Honeycomb’s engineering org
Is there still room for engineering? Or are we going to become a dark software factory that just needs to pump out code?
That’s Josh Parsons, Staff Software Engineer on Honeycomb’s Core Services team, describing the question on his mind when Honeycomb first went all in on AI.
Honeycomb is an observability platform for engineering teams, built for the AI era. They have years of code, customers whose work would be deeply disrupted if an agent went rogue, and established engineering practices that take both time and effort to change. The company was founded in 2016, and Josh’s team owns the ingest path that every event a customer sends has to pass through. “Move fast and break things” isn’t really on the menu like it might be for younger and smaller AI-native engineering organizations. Yet, in August 2025, Honeycomb’s founders asked every employee to try to double their productivity with AI.
A little over a year after the internal AI mandate was released, I talked to three people about how it’s played out: Josh, who you’ve already met; Rebecca Murphey, the former Field CTO at Swarmia and current Principal Engineer for AI Operations at Honeycomb; and Quail Lincoln, a Senior Software Engineer on the Engineering Enablement team.
What all three agreed on is that this isn’t a finished playbook. Honeycomb is in the middle of the change, and Josh, Quail, and Rebecca were all very open about what they haven’t figured out yet. But if you run an engineering organization that existed before agents did, I’m hoping this piece does two things: give you at least one concrete idea to try with your teams and reassure you that nobody else has their AI transformation fully worked out yet either.
It all started with a company-wide AI mandate
A recently published blog post on Honeycomb’s AI norms and values spells out what the mandate means for the engineering org. The long-term goal is to rank in the top 10% of engineering teams at comparable companies for both AI adoption and productivity. The nearer one is that by the end of 2026, at least a quarter of pull requests get reviewed by AI and merged with no human review, while the change failure rate stays under 3% even as the rate of change increases.
The note also explains why: Honeycomb has built its reputation on being out ahead on how software gets built, and its customers are now building with AI. A company that wants to guide them can’t afford to learn about it secondhand. Josh agrees. “Our customers are looking to us for guidance and expertise,” he says, “and we can’t be uninformed about that if we want their business.”
When the mandate went out, the support around it wasn’t in place yet. That’s how most big changes go: you set the direction first, and then you find out what it takes to get there. Since then, Honeycomb has standardized its tooling, given the Engineering Enablement team AI platform work, grown that team, and brought in Rebecca. Part of what she came to Honeycomb to do, in her words, was to turn the mandate into “something real, measurable, and actionable.”
She found engineers all over the map. Some skeptics had become converts. Others were still skeptical, but couldn’t quite say why. “They don’t have a concrete worry,” Rebecca says. “What’s underlying that is mourning. Mourning the job that they used to have.” On top of that came difficult questions about what the new job is, whether they’re good at it, and whether they even want it.
Honeycomb’s leadership acknowledges this too. The FAQ in the norms and values note says “it’s not strange to feel a sense of loss or grief” about setting down the parts of the job that used to feel satisfying. Instead of asking people to push through it, the note asks them to deal with it openly and share what is and isn’t working with their teammates.
Quail is the kind of convert Rebecca means. People at Honeycomb keep stream channels, personal Slack channels that Quail compares to having their own Twitter feeds. Quail’s goes back to 2024, when the company first got access to ChatGPT and their big question was, “What do I put into the box?”

By the Sonnet 3.7 days, they were posting tests the model had written and calling them total crap, even when they’d shared an existing test to use as a template. Then Opus 4.5 came out in November 2025, right before the holidays. “Everybody had their winter break, and they thought about it, and they considered it, and everybody came back, and they were like, oh my gosh,” Quail says. They barely touched it over the break. “I think I just thought about it a bit and read about it. And I was like, this is completely changing.”

Today, Rebecca describes Quail as an enthusiastic champion who’s politely, but actively, pushing everyone else to adopt these tools.
Josh came at it from a different angle. He cares a lot about quality and about how teams learn together, and he gets nervous about “anything that abdicates responsibility.” In his stream in July 2026, he listed a collection of thoughts and ideas he’d been having recently.

What brought him around was how the norms got written. Charity Majors, Honeycomb’s co-founder and CTO, held voluntary Q&A sessions on AI norms and values and drafted them in the open, in Google Docs anyone could comment on and challenge. The drafts went through a lot of edits, and Honeycomb has since started publishing them.
“I think I wanted to understand, most of all, what good looks like for us,” Josh says. Plenty of industry yardsticks for elite teams lean on volume, like lines of code or how often you ship. Honeycomb landed somewhere else. “We were able to define a version of what good and great looks like for us that isn’t so tied to volume,” he says. “It was more tied to how are we growing? How are we doing this collaboratively? How are we learning together in this new world?”
“Will you rubber stamp this, please?”
Josh’s favorite of the norms is about respecting each other’s time. With so much more being written, people ask for each other’s attention more often, for code review and for internal docs that were obviously AI-generated. “If you have generated a 10-page document and it took you a couple of minutes, you just did a single prompt, and then you’re asking someone to read this document that’s obviously going to take more than a few minutes,” he says, “that’s disrespectful.”
Charity’s phrase for the fix, Josh says, is to address the envelope. Tell people how much effort went in and how much you need back: “Hey, I only spent a few minutes on this. I just need a spot check. Can you spend no more than five minutes on this?”
The same thing was happening with code. Honeycomb had invested heavily in authoring, everyone had Claude Code, and writing code got easy. All that extra code had to go somewhere, and it went straight into the review queue. Rebecca watched review start to overwhelm people, along with a familiar request: “Will you rubber stamp this, please?” Some changes clearly didn’t need a second pair of eyes, but they waited for one anyway, because that had always been the way.
Some contributors also discovered they could now drop very large pull requests on teams who’d never heard about them. The norm that came out of that is simple: talk to the team first. Rebecca points to Liz Fong-Jones as the model for doing it well. Liz is a very senior engineer who works with customers in the field, and Rebecca says she’s often writing tickets and dispatching agents from her phone during customer meetings. She worked with the teams she contributes to most to build skills that capture what their reviewers care about, so her changes arrive the way those teams like them.
When Rebecca joined, the Engineering Enablement team had been building tooling for writing code. But writing code was no longer the hard part, so she pointed the team at the review queue instead. She gave them a mantra, “better, faster, easier, happier,” and a mission that fits on a sticky note. “Identify and eliminate bottlenecks is your mission,” she says. “Period.” She walked them through the theory of constraints, and within a few months the team had a framework for deciding what to work on and measurements they report on every week.
The first reviewer is still a human
Quail’s team owns the code review agent. Open a pull request at Honeycomb, and the bot reviews it. The goal is to get it to a point where it can approve pull requests by itself, which doesn’t mean taking people out of the loop. “The first human is the PR author,” Quail says, “so we still expect PR authors to review and stand by their code.” What goes away is the requirement for a second human on every single change.
So how do you decide which changes still need one? Rebecca points to an experiment Josh’s team ran. When they opened a pull request, the author graded it from 1 to 5 for how much review they thought it needed, and the reviewer acted accordingly. Rebecca expects the automated version to start out just as simple, with the author flagging whether a change is a candidate for automated review. If it’s flagged and under 500 lines, it’s a candidate for auto-merging. Something smarter can come later.
The bot isn’t perfect. Recently, it missed something on a pull request that the team really wanted it to catch, and people talked it through in Ops Hours, one of their regular meetings. It turned into a conversation about how they want to work together now. Do you need an RFC that lays out every change in detail before someone builds something, or can you say “I trust you, go get it done”? “I don’t know where the line is,” Quail admits.
What they have figured out is how to close the loop. When someone posts in the team’s Slack channel that a review wasn’t very good, Quail asks Amp, the coding agent Honeycomb is moving to, to start a thread and make whatever changes are needed so the reviewer catches it next time. When the work is done, the agent posts back in Slack.
“For me, it’s actually not that much work,” Quail says, “but they know that I’m going to take seriously that this is a thing that needs to be addressed.” The more feedback gets acted on, the more feedback people send.
Why Honeycomb isn’t building a software factory (yet)
If a bot reviews your agent-created pull requests and merges them, you’re starting to sound like a software factory. Honeycomb isn’t heading there on purpose. They’re curious about the approach and want to experiment with it, but consider the playbook unwritten.
Rebecca doesn’t think you should aim for one either. “I think something like the software factory will emerge,” she says. “I don’t think that you should set out to build one.”
Quail goes further. “I am not a fan of a software factory,” they say. Their issue is with the purest version, StrongDM’s, which Quail describes as laser-focused on the idea that nobody ever reads the code. “I think you go too far when you do that.”
Their reasoning involves The Simpsons. In one episode, a car company asks Homer, the average American consumer, to design his dream car. He asks for this, that, and everything else, and they build all of it. What rolls off the line looks like a clown car. “The agents are very good at writing code, and they can give you what you ask for,” Quail says. “But the problem is, sometimes you ask for a Homer car.”
Agents will happily build you the Homer car, and noticing is the human’s job. Quail doesn’t read every line of a diff, but they do look at it, and sometimes something feels off. Then they go in, with an agent’s help, to work out which combination of requirements made the complexity spike and what can be cut. “If you’re barring yourself from looking at the code,” they say, “I think you rob yourself of doing that.”
Quail doesn’t rule out getting there one day. They just think anyone building a software factory right now is a bit early, because you still need some signal that the code has gotten too complex, and someone to decide what complexity can go. The agents do more and more of the work, and the judgment calls stay with people.
Paving the road with the right tooling
Honeycomb’s approach to tooling is to pave one road and let people wander off it if they really want to. After a period of experimenting with lots of tools, the company consolidated on Claude Code. People who loved Cursor could keep it, and Honeycomb would still pay for it, but nobody would test it or make sure it kept working. “You are kind of paving your own road here,” Quail says, “and if it’s valuable enough for you to do that, then please keep using it. Otherwise, please use the road that we’re paving.”
Now the paved road is moving to Amp, and the deal is the same. Claude Code isn’t going away, and the company will keep paying for it, but the enablement team won’t be worrying about breaking it.
Rebecca tells Amp’s origin story like a rom-com. Dean, on the Engineering Enablement team, started playing with it and fell in love. The rest of the team was skeptical. Dean kept using it and talking about it, and slowly, the team came around.
What won them over was the threads and the “orbs” that they could spawn. In Amp, threads are multiplayer, shareable, and connected to a virtual machine (orb), so you can have Honeycomb running right next to the conversation. Everyone can see everyone’s threads by default, unless you make yours private. That fixed something people had been missing. As agents wrote more of the code, engineers felt they had even less visibility into how a change came to be. “Never before have we been able to see how an engineer was thinking as they wrote the code,” Rebecca says. “Now we can.”
There’s a practical win too. You can only run so many instances of Honeycomb on one laptop, which put a cap on how many things one person could work on at once. Amp gives every thread a machine of its own.
Quail has been using it for something that used to be a recipe for merge conflicts. Before AI, if a coworker was working in the same corner of the codebase, you’d stay away. Now Quail tells their thread that another thread is working nearby, and the agents message each other as the interfaces change. “It works way better than I think I would have expected,” they say.
Quail skips GitHub’s stacked pull requests, which they call “totally awful.” Instead, they wait for their coworker’s pull request to merge before opening their own. When I pointed out that this sounds a little waterfall, Quail took the point. “It feels like the most interesting combination of waterfall and agile that there’s been,” they say. A little design up front, and a very tight feedback loop.
Getting Amp approved took some doing. Anthropic was already an approved subprocessor, which meant Claude Code could be hooked up to tools like Notion and Linear. Amp wasn’t, so the team had to get it through that process first. “I’m not gonna call it a saga,” Quail says, “but it was a thing.” In the meantime, people were excited enough to use Amp to build little apps that answered one question: is it Amp subprocessor day yet? When the day came, Quail says, you could see it on the charts.
Letting people know what’s coming next
By the time Amp was approved, there was a line of people waiting for it. Part of that is because the tool is good. The rest is because Honeycomb has had to get deliberate about how they communicate about change.
Almost everything Engineering Enablement ships affects every team. So for each change, Quail’s team asks a few questions. Does this go in the big announcement channel all of R&D reads, or can it live in a smaller one? How risky is it? Do we need to get a couple of teams on a Zoom before it ships?
Big changes used to announce themselves. “Previously, certain changes would be like, okay, this is big, it’s gonna take weeks,” Quail says, “and so just by virtue of the fact that you’re working on it for a bit, and you’re talking about it, people hear about it.” Now the gap between an idea and a shipped change can be one night. “You set the agent to work on it when you log off for the day, and then you log on the next morning, and it’s ready.”
So nobody hears about anything by accident anymore. A lot of the news travels through what Quail calls the manager sphere. Managers hear what’s coming and prepare their teams, and then someone on the team checks it out and comes back with concerns. “You have to be really loud about what you’re changing, when it’s changing,” Quail says. That means the official announcements, but also “getting it in people’s minds that something like this is coming,” long before it does.
Rebecca adds that Honeycomb runs on Slack and almost nothing happens over email. There are dedicated announcement channels, and if you’re an engineer, you’re expected to read the engineering one. New ways of working roll out in rings: first the team that built them, then friends and family, then everyone else, with a channel where people can bring their questions.
Learning out loud
Announcements tell people what’s changing. They don’t teach anyone how to work differently. Rebecca’s read was that Honeycomb had plenty of individuals exploring, but nothing that made what they learned spread to their teams. “We were really missing that community exploration,” she says.
When I asked where it was working, she pointed me to Josh’s team. Core Services, she says, is “the gold star team.” They’ve made time for experimentation on purpose, they talk about it every week, and they try things without knowing whether they’ll work.
The team has five engineers, plus a manager and a part-time product manager. Every Thursday, they have an hour on the calendar called AI innovation time. Despite the name, the meeting is not for building anything. It’s a Zoom call where people talk about what they tried that week, what worked, and what didn’t, or bring something they’ve seen others do and can’t figure out. Nobody sets an agenda. Instead, Josh explains, everyone brings their learnings, questions, and things to commiserate about.
“I think it’s just as important to talk about those things that aren’t working and what’s been tough,” he says. “That really makes this a very rich shared experience.”
Fridays bring a weekly review, where the team checks whether they hit the short-term goals they set. The last 30 minutes are show-and-tell, for half-finished work and lessons from the week, separate from the 45-minute Friday demo. All in, that’s one to two hours a week of the team learning from each other. On top of that, there are cross-team spaces, like the long-running Ops Hour where people from different domains swap stories.
Josh’s lens on all of this comes from Dr. Cat Hicks, a psychologist whose work on software teams and learning cultures has shaped how he thinks about it. The goal, as he puts it, is “creating the team conditions so that we can learn together as we’re using these tools.” The alternative is everyone working heads down, “siloed in a Claude Code terminal UI session.”
Quail puts the emotional side plainly. “You just need to talk to each other and be willing to be vulnerable with each other,” they say. “You messed up here, and it’s okay that you messed up, but I’m going to hold you accountable to do better next time, and I expect you to do the same for me when I mess up, because I will mess up. Because we’re all figuring this out together.”
Rebecca wants more exploration happening where others can see it. Her example is Hazel Edmands on the Storage team, who spun up a fully isolated instance of Honeycomb Private Cloud, the new product that runs Honeycomb inside a customer’s AWS account, and asked Claude to go find bugs for 24 hours. Claude found plenty. It root-caused bugs the team hadn’t been able to pin down, and fixed some they already knew about. “I want more people doing that,” Rebecca says.
To help the learnings spread, she’s working with Engineering Enablement on curated presentations. And now that the enablement team has more people, it can send someone to embed with another team regularly.
It appears there’s still room for engineering
Quail thinks the latest models can handle almost the entire development cycle. They’ve had changes where a single agent session covered all of it: making the change, watching it roll out, checking the telemetry, and updating the docs and the changelog. “Deciding which changes are the right ones to be doing and when, which has always been the problem,” Quail says, “but it’s now becoming even more of a key thing.” On their own team, the struggle is deciding where to spend human attention. “That, to me, feels like the game.”
Josh is excited about the ways AI can help everyone understand code they didn’t write. Someone at Honeycomb recently demoed a causal loop graph that shows, for any code path, which other systems are linked to it and would feel a change. It gave Josh a vision of comprehension maps: a visual, easy-to-update resource where a developer can point at part of the codebase and see which concepts, patterns, and skills they need to understand it. Nothing’s built yet, and the conversations are just starting, but “that excites me the most,” he says.
Rebecca is already looking past engineering. Getting the enablement work on track was the straightforward part, and she suspects the next bottleneck won’t be in engineering at all. In true observability-company fashion, her question is how she’ll see it coming. “It’s very observable when code is backing up,” she says. “What is observable about other organizational bottlenecks?” One place she’s watching is customer feature adoption. When a team can ship far more than it used to, the open question is how much of it customers can actually take in.
Similarly, Quail’s North Star is the internal admin tool. Every company has one, they say, and the engineers who build it often think it’s for them. It’s really for customer success, account executives, and other engineering-adjacent people with a wide range of technical skill, and it tends to go a little unloved. Quail wants those people to be able to contribute to it confidently. An admin tool is a forgiving place to start: “If somebody ships something bad in there, we can rip it out, it’s fine.” Amp helps here too, because when an engineer steps in, they can see the whole conversation that led to the change, including what the person actually wanted. “How could we enable people to make their own lives better with these things?” Quail says. “That’s my North Star.”
As for Josh, he got his answer. There’s still room for engineering at Honeycomb, and still room to learn. He’s still wary of the unhealthy ways people use these tools, and he says so. But he’s on board.
“The way we’re encouraging people to use these tools makes a lot of sense to me,” he says, “and I feel aligned to what we’ve come up with together.”
Notice the last word. A mandate can set the direction, but actually getting there takes the whole organization.
Subscribe to our newsletter
Get the latest product updates and #goodreads delivered to your inbox once a month.



