Frugal recently shipped awesome new capabilities that are helping Frugal users catch cost regressions before they ship, and I wanted to say a bit about it here.

What is the point of Code Review?

For many years now, the engineering teams I've been a part of have relied on code review as an essential part of our software development process. Requiring a peer to review code changes before they are merged is important to our security and compliance policies, it finds some quality issues, it trains engineers and establishes engineering culture through the team. Sometimes it catches a cloud cost problem early, but that relies on one of the reviewers knowing about how a change would impact our cloud costs, and there isn't always a reviewer with that knowledge. In many organizations, detailed info about the cloud bill doesn't make it back to the engineers doing the review.

How has code review changed in the age of AI-native software development?

Its now a race between how fast the AI agents can generate the code and how fast engineers, armed with code reviewing AI agents, can vet the proposed changes.

In our team, we now have a small army of AI Agents reviewing every change. We have made a few specialist AI reviewers mandatory: every change always gets reviewed by CodeRabbit for quality, Snyk for security, and Frugal for cost. In addition, Claude Code, Codex and Copilot are frequently also chiming in with their review comments, depending on the change, the repo and the preferences of the engineers supervising the review.

What does Frugal bring to a Code Review?

Data — Frugal has assembled, normalized, distilled, and correlated your cloud cost and usage data down to the code that drives it. That data is the difference between a justified optimization and a guess: which service is actually cost effective, whether an API calling pattern is expensive at your volume, what service tier makes financial sense for this particular component.

Knowledge — Frugal knows the efficiency patterns for each managed service, the cost traps that show up over and over, and which alternative offering or service tier tends to be the cheaper way to do the same job. It also knows the cost-relevant services and design patterns already in use elsewhere in your organization, so a review isn't re-deriving decisions another team settled months ago.

Coverage — A lot of what teams spend today isn't decided when something gets provisioned, it's decided by what the application code does every time it runs: tokens sent to a model API, log lines emitted, queries scanned, objects listed, bytes moved between regions. Frugal reviews across the broad set of cloud and SaaS services that make up the bill teams are actually looking at, which means it catches the usage-driven costs that never appear in a resource definition anywhere.

Attribution — Frugal also reviews the instrumentation itself, checking that new code carries the tags, labels, and metrics needed for its cost to land against the right component with a clear owner. Cost you can't see is cost nobody owns, and review is the cheapest moment there is to fix that.

Let's see it

Here's a pull request in one of our demo repos. An agent wrote the change — real-time AI recommendations generated per API call — and Frugal reviewed it before any human got there.

Frugalbot leads with the number and the context for it. This change adds about $1,100 a month across three cost traps, all of them in the new recommendation path. The baseline table underneath is what makes that number mean something: Recommendations is already a $23,172 a month component against the Anthropic API, so this is roughly a 5% bump on a line item somebody already cares about. Each trap is linked to the file and line that causes it.

Further down, each trap gets the full write-up: an unfiltered availableProducts list going into the prompt ($800), max_tokens set to 200 for a response that needs about 25 ($200), and a system prompt that could be half its length ($100). Detected, and what to do about it.

None of these are bugs. The code works, it does what the ticket asked, and it would sail through a normal review. The bill would turn up five weeks later as a line item nobody can explain.

Worth noting what this PR doesn't contain: nothing was provisioned. No new resource, no infrastructure to diff, nothing that declares a price ahead of time. It's a prompt and a token limit, and it spends money every time the endpoint gets called. That's what most of the growth in cloud and AI bills looks like now.

The review also runs as a check, so the cost shows up in the same place as everything else that gates a merge — one red mark among thirty green ones, with the estimated monthly impact right there in the summary line. Teams that want a threshold enforced can have one, and teams that just want the information get the information.

GitHub pull request review is available today. GitLab merge request support is coming soon.

Where this goes

Teams are rebuilding their development process around agents, and code review is where most of that pressure lands. The general-purpose reviewers are good and getting better, but the interesting move is the rise of specialists: a reviewer for quality, a reviewer for security, and now a reviewer for cost. Frugal can play that role because of the data behind it. Nothing about a diff tells you that a component spends $23,172 a month, and no amount of reasoning about the code gets you there.

Do this on every change for a year and the compounding is the point: cost that's attributed and owned instead of argued about, applications that get more efficient in the ordinary course of shipping, and cloud and AI spend that's managed as it's created. Fewer anomalies discovered in the bill, and fewer of the firedrills that inevitably follow.

Here I am talking about it, if you'd rather watch: https://www.youtube.com/shorts/bI7NaD-RRZY

Looking for help with cost optimizations like these? Book a Demo or Explore the Sandbox to see Frugal in action.