We tracked 200K AI requests. Here's where the money actually goes

Joao Romao — Sat, 16 May 2026 19:32:47 +0000

Six months ago I posted here about CostLens — a tool to reduce OpenAI costs. Since then, we've completely rebuilt it based on one question a VP asked our team:

"How much faster are we delivering with AI? What's the number?"

Nobody could answer. We had cost dashboards, but no way to connect spend to output. So we built that.

What CostLens does now

It's not just cost tracking anymore. It's three things:

Cost attribution — not "you spent $4,200 on OpenAI" but "code review costs $340/mo, customer support costs $89/mo, and classification costs $12/mo." Per-feature, per-developer.
Smart routing — simple prompts automatically go to cheaper models. No code changes. We're seeing 30-40% savings on teams that were sending everything to GPT-5.4.
Productivity tracking via MCP — works inside Claude Code, Kiro, and Cursor. Tracks sessions, commits, PRs, and time-to-ship. Generates weekly reports your VP can forward to justify the AI budget.

The setup is still one line

import { CostLens } from 'costlens';
const costlens = new CostLens({ apiKey: 'cl_...' });
const openai = costlens.wrapOpenAI(new OpenAI());
// Done. Every request is tracked and optimized.

For coding agents (Claude Code, Kiro, Cursor):

{
  "mcpServers": {
    "costlens": {
      "command": "npx",
      "args": ["-y", "@costlens/mcp-server"],
      "env": { "COSTLENS_MCP_KEY": "your_key" }
    }
  }
}

What we learned from tracking 200K requests

52% of requests were simple tasks running on expensive models (classification, extraction, yes/no questions)
Smart routing cut our own bill from $4,100 to $2,337/month
The "code review" feature was 3x more expensive than we thought
Sessions with no output (abandoned/looping) accounted for 15% of spend

Kill switch

One thing we added after a background agent burned $50 in a weekend: a Slack kill switch. When spend velocity spikes, you get a message with a "Pause" button. One click stops that specific agent session. Auto-
resumes after 30 min.

Free for individuals

The SDK and MCP server are free. Team features (reports, routing, budgets) start at $99/month.

Website: https://costlens.dev
SDK: npm install costlens
MCP: https://www.npmjs.com/package/@costlens/mcp-server

Would love feedback — especially from teams spending $1K+/month on AI. What would make you try this?

Is Your OpenAI Bill Giving You Nightmares? I Built a Tool to Help

Joao Romao — Wed, 22 Oct 2025 10:19:39 +0000

Let's be honest: playing with large language models is amazing, but seeing that OpenAI API bill at the end of the month can be... painful. 😅

I've been working with the GPT-4 and GPT-3.5 APIs a lot, and I noticed how quickly the costs can spiral out of control. A simple task routed to GPT-4 by mistake, an inefficient prompt, or running the same query over and over—it all adds up.

I kept thinking there had to be a smarter, more automated way to manage this without rewriting all my code.

That's why I built CostLens, a simple SDK I'm hoping can help other developers who are facing the same problem.

What is CostLens?

At its core, CostLens is a drop-in SDK that automatically helps you cut your AI costs. The goal is to make it a "set it and forget it" tool that starts saving you money in minutes.

It works by wrapping your existing OpenAI client. Once it's installed, it automatically does three key things:

Smart Model Routing: This is the big one. It analyzes your requests and automatically routes simple tasks to cheaper models (like GPT-3.5) while saving the expensive, powerful models (like GPT-4) for the complex tasks that actually need them.
Prompt Optimization: The tool's AI rewrites your prompts before they hit the OpenAI API to be 40-60% shorter. You get the same (or better) quality results for a fraction of the token cost.
Response Caching: If your application sends the same request multiple times, CostLens will catch it and return the cached result instantly, for free.

How It Works (It's Quick)

I really wanted to make this as easy as possible, with no need to refactor your existing logic.

You just import the client, wrap your existing OpenAI instance, and... that's it. You can keep using the OpenAI client just like you always have, and the optimizations happen in the background.

It looks something like this:

import CostLens from 'costlens';
import OpenAI from 'openai';

// 1. Initialize CostLens
const costlens = new CostLens({
  apiKey: process.env.COSTLENS_KEY
});

// 2. Wrap your existing OpenAI client one time
const openai = costlens.wrapOpenAI(new OpenAI());

// 3. Use it exactly as you did before!
// Savings happen automatically
const result = await openai.chat.completions.create({
  model: 'gpt-4',
  messages: [...]
});

// ✅ This request is automatically optimized,
// ✅ routed to the best-priced model,
// ✅ and cached for future use.

I'm Looking for Testers and Feedback!

This started as a personal project, but I think it could be genuinely useful for other indie devs, startups, or anyone who wants to keep their AI experiments affordable.

I just launched a Free plan that lets you optimize up to $100/month of AI spend, so you can try it out without any risk.

If you're a developer using the OpenAI API, I would be incredibly grateful if you'd give it a try and let me know what you think.

Does it actually save you money?
Is the setup as easy as I think it is?
What features are missing?

You can check it out and get started here: https://costlens.dev/

My goal is just to build something that helps the community, so any and all feedback (good or bad) is super welcome.

Let me know what you think in the comments!

DEV Community: Joao Romao