Zach Bruggeman

Zach Bruggeman helped build Inspect, Ramp’s internal background coding agent, with Jason Quense and Rahul Sengottuvelu. Their two-week prototype developed into a shared environment where engineers, designers, and product managers can request changes, run the application, and collaborate on code. The team’s decision to build internally gave Inspect a specific advantage: access to Ramp’s development services, diagnostic tools, and product history, so it could investigate and test changes within the company’s own workflow.

Lowering the cost of trying an idea

Zach’s open-source run-js removes setup from browser-based programming experiments. Developers can run scripts without first creating HTML files, configuring compilation, or manually installing dependencies. It supports JavaScript, JSX, CoffeeScript, and TypeScript, installs missing packages, and reloads the browser when files change. Zach presented it as a playground, including for newcomers, rather than a production environment.

His messenger-bot project handles another kind of setup: connecting application code to Facebook’s Messenger Platform. The Node.js client exposes messages and other events, with helpers for replies, user profiles, and webhook handling.

At Plus, Zach also worked on how an engineering team coordinated exploratory work. In his July 2022 essay on engineering cycles, he described a process in which engineers wrote and estimated their own issues, while two-week cycles coordinated work without making releases depend on arbitrary deadlines. Full-team cycle meetings took two hours across the fortnight. Larger streams of work supplied the goals; smaller groups handled implementation discussions. The team revised rituals when they stopped helping, leaving room for scope to change as engineers learned.

Building Inspect around Ramp’s workflow

Inspect began as a side project by Zach, Jason, and Rahul. In their Linear interview, Zach explains why they built an agent around Ramp’s systems: the team knew which credentials it needed, how internal logs were structured, and how it should connect to the development lifecycle. A central team defined what agents could access and do, allowing other teams to build automations within those permissions.

The Modal interview, published in February 2026, describes how the team made that integration usable. Zach said he got an initial version running in a few days; the account of the three-person team’s first version puts its development at two weeks. The resulting system combines three capabilities:

• A full environment for checking changes. Each session runs OpenCode inside a Modal sandbox with the services a Ramp engineer would use locally, including Postgres, Redis, Temporal, and RabbitMQ. An editor, terminal, and Chromium browser let the agent run the application, execute tests, and visually inspect frontend changes. Connections to tools such as Sentry and Datadog give it diagnostic information beyond the source code. Keeping the agent, files, and services together avoids remote filesystem synchronization and network hops between the agent and its test environment.
• Prepared environments for fast startup. Every 30 minutes, the system prepares repositories, installs dependencies, runs initial builds, and saves filesystem snapshots. A new session starts from a recent snapshot and syncs subsequent repository changes, allowing it to begin working within seconds. Separate sandboxes support concurrent experiments without occupying a colleague’s laptop or competing for the same development environment.
• Product history and collaborative sessions. Inspect’s Linear integration connects code with specifications, customer requests, and roadmaps. A bug investigation can follow a customer request through the intended product behavior to the implementation. Colleagues can also share a working session: a designer might begin a dashboard change from a Figma file, then hand it to an engineer. Web, Slack, and Chrome-extension clients make the environment accessible without local installation.

Zach’s own experience building the Linear connection illustrates how he uses agents to extend the system. He supplied an agent with Linear’s documentation and a few pointers, and reported that it completed roughly 90 percent of the integration in about 30 minutes. That is his estimate of progress on that integration, rather than a measure of its final correctness.

When review becomes the constraint

The adoption figures describe Inspect’s reach across Ramp, rather than Zach’s individual output. The February 2026 Modal account reported that roughly half of merged frontend and backend pull requests started with Inspect; the supplied Linear account reports three in four. Those accounts use different descriptions of agent involvement, but both place Inspect well beyond an isolated engineering experiment.

Zach identifies code review as the growing bottleneck as agents produce more changes. In the Linear interview, he describes watching how review tools are evolving to meet that workload. Inspect gives colleagues a running implementation, product context, and a shared session to examine; people still have to assess the resulting changes. His work with Jason and Rahul makes that shift concrete: preparing an implementation increasingly includes preparing the environment and evidence someone else needs to review and finish it.