How the groundcover team works now: Slack for people, Linear for agents
Building groundcover Investigations changed more than our product and how you can use groundcover to perform root cause analysis and roll out fixes. It also changed how the team building groundcover Investigations works day to day. Agents now handle much of the lookup work, the ticket updates and the first pass of code review. The engineers spend more of their time making decisions.

Building groundcover Investigations changed more than our product and how you can use groundcover to perform root cause analysis and roll out fixes. It also changed how the team building groundcover Investigations works day to day. Agents now handle much of the lookup work, the ticket updates and the first pass of code review. The engineers spend more of their time making decisions.
In this post, we'll cover four changes. First, where conversations and tickets live now. Second, how code review has changed. Third, how we use AI while holding on to good engineering practices. And fourth, how we think about the tradeoff between moving fast and taking on risk.
Slack for people, Linear for agents
The first change is where the work gets discussed. Our engineers still use Linear, but they rarely read it. Once a spec is fleshed out, agents create most of the Linear tickets, update them and link them to pull requests, usually because an engineer asked an agent to. The engineers talk to each other in Slack.
Our Product Managers don’t create or maintain the Linear tickets for Engineers anymore, they work in making sure everyone is aligned and in communicating any decision or opinion, small or big, to everyone, either via Slack, face to face in our office halls, or in meetings. In high velocity efforts, we strive for our engineers to be as knowledgeable as possible in order to make the right calls themselves, and remove the PM as a bottleneck. Linear tickets turn into Agent prompts, so creating and maintaining the tickets is done by them. This helps empower everyone and make everyone accountable for the product’s success, as they are owning a meaningful part of the product. If someone doesn’t know or understand something, they don’t wait a week for the next sync, they are expected to actively raise it.
By the way this is one of the main reasons we are mainly a work-from-office company.
Here's a typical example. During a design review for groundcover Investigations, our product manager posted a list of open questions into the team's Slack channel. One question was how the UI would show which groundcover agent is working on which part of an investigation. A backend engineer didn't answer from memory. He tagged Linear's agent in the Slack thread and asked it to compare the questions against the investigation service spec. Linear's agent answered each question from the spec, flagged two places where the proposed UI didn't match the spec, and listed what the spec didn't cover yet. Then the engineers made the remaining decisions in the same Slack thread.
Another moment from the same project shows how far this goes. Our PM asked that backend engineer a question, and he politely told them to RTFM. He’d been using agents to keep a single design doc current through dozens of revisions, so the answer was already written down. The PM gave their own agent access to the doc and never asked him a “simple” question again. From then on, the only things they brought him were the gaps that they and their agent couldn’t close on their own.
In both cases, agents did the lookup and the cross-checking, and people made the judgment calls and design decisions. The second one also shows what changes for the people: the questions that reach an engineer now are the ones that actually need him. Most of our work now follows that split.
How code review changed
The second change is in code review. Code used to be expensive to write, so we settled the design first and reviewed the code later. Someone wrote a proposal, the team argued about it, and only once it was approved did anyone start building. Now an agent can produce a working version of a change in less time than that design meeting would take, so for most changes we skip the separate design step. The pull request is where the design gets reviewed.
That changes what a review looks like. A reviewer isn’t only asking whether the code is correct. They’re asking whether this is the right approach, and since the code already exists, they can answer by looking at real behavior instead of a diagram. If the answer is no, rewriting it is cheap. Early in the Investigations project, our backend team reviewed the agent code and decided the investigation APIs belonged in a separate service. In the old process, that decision would have come out of a design review weeks before anyone wrote code. This time it came out of a PR review, and moving the code took a fraction of the time it would have taken before.
Bigger efforts still get a design doc, like the one our backend engineer kept current for Investigations. But most changes go straight to a PR.
An AI code review tool handles the first pass on most pull requests, so the engineers can spend their review on the design questions. In high-risk areas, like anything that touches scale, data correctness or customer-facing APIs, reviewers still go through the code line by line.
Folding design into the PR only works if the code underneath, and the CI pipeline, follow good engineering practices. That brings us to the third change.
Using AI while keeping good engineering practices
Agents produce code quickly, and fast code generation makes good engineering practices more important, not less. A practice that keeps one engineer's code safe also keeps ten agents' code safe, as long as the team actually enforces it. Here are the practices we lean on most, and how they apply when agents write much of the code:
- Set explicit limits. Every loop, retry and queue should have a bound. Agents tend to retry until something works, so we put the bounds in code. In groundcover Investigations, for example, the moderator re-judges a set of proposals at most three times before the proposals wait for a person to decide.
- Check invariants while the program runs. Don't trust that output is correct because it looks correct. The investigation service checks every request from every agent against its rules before saving anything, the same way a well-written program asserts its own assumptions.
- Keep interfaces small and simple. Agents perform better with a tight, well-defined structure than with a flexible one. In post 2, we described how splitting investigation nodes into questions and hypotheses improved the groundcover investigator more than any prompt change.
- Design slowly so you can build quickly. An agent can write a feature in minutes, which makes it tempting to skip design. Spending the time on design first means the agent builds the right thing. Changing a ship’s destination is easier when you change the route’s angle at the start, rather than later. Design documents used to go stale almost instantly, but today it is easy to keep them updated throughout a project’s lifetime to maintain a source-of-truth for a full team.
- Avoid technical debt from the start. Agents make it cheap to write code, but every line still has to be maintained. Reviewers reject code that works but would need to be rewritten later. We have added roadmap trajectory impact as part of our review process, which is instrumental to keeping our long-term velocity high.
Agents also help us follow these practices. They write more tests than our engineers ever did. Agents even have a tendency to write some redundant tests, but the extra coverage catches problems nobody planned for.
Agents still have a clear limit, though: they aren't creative yet. Given 1 + x = 2, an agent solves for x. An agent doesn't yet decide on its own which new attributes are worth measuring for a feature, or how the results should be presented. Engineers still make those decisions.
Speed and risk
The fourth change is how much risk we're willing to take on. With agents writing code and investigating problems, our team moves faster. Aside from prioritizing writing good code, we’re also moving toward continuous remediation. Continuous remediation is only effective if you can know something broke before a customer notices it, then investigate the problem and write the fix faster than we could before.
Faster fixes can also mean accepting more risk, and that tradeoff isn’t right for every company or vertical. A bank, for example, would reasonably choose to move more slowly and use more manual audits. That’s why we’re not jumping straight to automated remediation. The next step for groundcover Investigations is automated suggestions: the investigator proposes a fix, and a human reviews it and decides whether to apply it. Teams get to see how often the suggestions are right before they hand anything over. Some teams will move on to automated fixes once they trust the suggestions. Others, like that bank, may decide suggestions are as far as they want to go, and that’s a valid choice.
We’ve already taken this approach with Autonomous Infrastructure, which keeps Kubernetes CPU and memory requests sized correctly. Teams can review its recommendations before turning anything on. Once they do, they opt in one cluster and one Deployment at a time, every change is logged, and switching it off restores the original values. Confidence comes from watching the system make good calls first.
For groundcover, we believe this tradeoff will be worth it, as long as the engineering practices above keep the risk bounded. groundcover Investigations is built for teams that want to move the same way: fast, with the guardrails to back it up.
What's next
If you’ve been following groundcover and the acquisition of wand, it probably doesn’t come as a surprise what is coming next. We want to connect observability agents to the CI/CD pipelines our customers already run. Before a deploy, an agent would record errors, latency and other signals across regions as a baseline. After the deploy, the agent would compare the new data against that baseline and flag anything that changed, so the team learns about a regression before customers do. If you want to compare notes on how your team works with agents, I encourage you to join our community Slack and ask any questions you may have. I also encourage you to give groundcover a try with our playground.



