30 秒でわかる
Ramp’s Inspect coding agent writes and ships about 75% of the company’s code, says engineer Zach Bruggeman. He attributes its adoption in part to a shared setup that brings improvements to everyone and sessions visible across the company, where colleagues can learn from each other. Reviewers can inspect the agent’s conversation and verification evidence. When an agent found a telemetry bug, working through it in public turned a skeptical user into an active collaborator; engineers later used the same platform to build a separate code-review agent.
- 1Inspect writes and ships about 75% of Ramp’s codeBruggeman says the collaborative agent has access to company tools and takes work from a prompt through coding, review and verification.
- 2A shared setup spreads improvements across the companyBruggeman argues that repeated individual setup and maintenance wastes time and leaves knowledge unevenly distributed. Inspect provides a company-wide baseline without a usage mandate.
- 3Public sessions teach both coworkers and the tool’s buildersEmployees can inspect how colleagues prompt and break down problems. The Inspect team also learns from unexpected uses and missing tools.
- 4Reviewers can see how a change was verifiedA pull request can link the agent conversation, tool calls, screenshots and browser verification recording, giving reviewers evidence beyond the code diff.
- 5A public debugging thread converted skepticism into collaborationInspect traced an error to telemetry code that failed to read or cancel a response body. As colleagues tested and patched the issue together, the user who reported it joined the discussion.
- 6Engineers extended Inspect into code reviewDaniel and Pranjal used existing automation triggers to build Review Buddy, prompting the core team to think beyond an agent that only writes code.
ポイント
- Give teams a shared agent setup so useful improvements reach everyone without repeated individual configuration.
- Make agent sessions visible within the team so colleagues can learn from real work and the tool’s builders can spot missing capabilities.
- Show reviewers the conversation, tools and verification evidence behind a change, not just the code diff.
- An openly investigated bug can bring a skeptical user into the work and lead to new ideas.
- Let teammates build on shared agent infrastructure: two Ramp engineers used it to create Review Buddy.
チャプターごとに整えた全文を読む
Inspect became Ramp’s shared coding agent
Bruggeman describes a remote, collaborative agent connected to company tools. He says it now writes and ships about 75% of Ramp’s code.
I am Zach Bruggeman, an engineer at Ramp. Over the past year, our engineering culture has changed around Inspect, a collaborative coding agent. We chose to build our own agent with sessions that run remotely and can be shared by multiple people.
Inspect works alongside a team in its own interface, Slack, Linear and other integrations. It now goes beyond writing code: design tools, review agents and verification flows help a builder take a prompt through to shipping. Connections to company data and tools, including databases and telemetry, are available across the organization.

We now see about 75% of Ramp’s code being written and shipped by Inspect. When we first shared it, people focused on the technical plumbing, such as starting isolated environments quickly, giving agents internal context and letting people work with them together. I want to focus instead on the culture that grew around the tool.
A common setup reduces information silos
Individual setup and maintenance costs multiply across a large organization. Ramp spreads improvements through one shared baseline.
At a large organization, even 15 minutes of setup per person adds up to days of repetitive work. Agent practices and configurations also change quickly, so setup becomes an ongoing maintenance cost. Improvements do not necessarily spread evenly, leaving people with different knowledge and outcomes.
Our first lesson is to build tools that break down information silos. When we find a useful pattern or tool, we can distribute it across Ramp immediately. People may still tune their own setup, but Inspect provides a strong baseline, and we have not needed to mandate its use.
No individual knows the best way to use agents for every task, even if following the field is their full-time job. A single shared Inspect gives everyone the benefit when someone discovers a better approach. Most improvements are invisible to other users: they continue working normally while the shared tool gets better.
Open sessions make learning part of work
Colleagues can study one another’s sessions, while the Inspect team observes real uses. This feedback informs tool improvements.

We have not needed formal sessions to teach people how to use Inspect effectively. Sessions are public inside the company by default, so it is easier to work openly than privately. People can watch how colleagues use the agent or ask it to examine recent sessions for their prompting and problem-solving habits.
That openness helps the Inspect team too. We see uses we did not anticipate and learn where people need better built-in capabilities, tools or data. What people achieve with Inspect feeds back into what we build next.
Verification evidence helps build trust
Bruggeman argues that people build trust by seeing how a change was made and tested. The agent’s session accompanies the code review.
Our second lesson is about trust. Learning to rely on agent-written code has been a major adjustment, even as models have improved. We usually build trust partly by learning from people we respect, but knowledge should not be limited to those who enjoy speaking publicly; systems can share what the wider team knows.
An Inspect session is a shareable record of how a change came about. A reviewer does not have to look at a large code diff alone: they can inspect the conversation, the tools used, before-and-after screenshots and even a recording of a verification agent clicking through the application in a browser. That makes it easier to show why the change can be trusted and involve colleagues from other teams.
A telemetry bug became a shared investigation
A skeptical user and the Inspect team debugged an error in public. The investigation found a response-handling problem and encouraged further collaboration.
In February, an engineer named Andrew reported an Inspect bug. I asked Inspect to investigate. Although the agent had been able to access Datadog for some time, we had only just added instrumentation to Inspect itself, so this was an early test of that new visibility.
Inspect initially said the instrumentation itself was causing the error. Dylan and I were unconvinced, while Andrew said he would use Claude Code instead. Nobody trusted the others’ answer yet, but because the conversation was public, we kept investigating together.

Dylan asked Inspect to inspect the telemetry library’s code and see whether the problem had existed before without being visible. The agent found that the library called fetch without reading or cancelling the response body. Bruggeman describes this as a Cloudflare platform limitation encountered in a library made for Cloudflare Workers.
We asked Inspect to patch the exporter so it explicitly cancelled the response body. After the change deployed, the errors stopped appearing. Fixing the bug mattered, but so did the way the investigation happened.
Previously, a report might have become a ticket, with the debugging done privately and the reporter told only when it was fixed. Here Andrew could see the work and naturally contribute his own experience. The same thread produced ideas for other ways Inspect could help, without anyone having to push people into collaborating.
In about an hour, a skeptical user with a broken experience became an engaged colleague who wanted to build together, while Inspect became more stable. For me, the next lesson after shared tools and trust is to think bigger together.
Thinking bigger together led to Review Buddy
Bruggeman argues against treating AI as only an individual productivity tool. Engineers built a review agent on Inspect’s existing triggers, broadening the team’s view of the platform.
AI lets individuals do more, but I do not think the lone operator should be the end goal. If we do not collaborate and share what we learn, we risk building only for ourselves and missing other people’s perspectives. Tools can instead strengthen those connections.
The story with Andrew has repeated in different forms at Ramp. Inspect has become part of our culture: colleagues recognize its character, decorate it for holidays and add Easter eggs. Not every iteration has been perfect, but we have evolved it together.
Earlier in the year, Inspect had fewer capabilities. We had been rotating among off-the-shelf code-review products when two engineers, Daniel and Pranjal, realized they could build their own. Inspect already had automation triggers, including one for an opened pull request, so they used it to create Review Buddy.
Like Inspect itself, Review Buddy began as a side project. The engineers did not need permission to try; they used Inspect to move faster and built a review agent for Ramp. Seeing that pushed the core team to think beyond Inspect as only a coding agent, sooner than we might have otherwise.
Ask the people you work with what they have been waiting to do, then try building it together. Inspect began with Jason and me wanting to make work more enjoyable for a team we cared about. Bruggeman closes by saying Inspect is now available outside Ramp through a waitlist.
同じチャンネルの記事
56:08EN
18:30EN
19:08EN
22:25EN
17:50EN
14:07EN