Developer tool roundups usually list ten AI coding assistants and stop. That misses most of the picture, because the AI in a modern stack shows up in at least five separate places — your editor, your design step, your backend, the model calls your app makes, and the infrastructure running it — and each layer has completely different economics.

This guide is organised by layer. And because the pricing units are deliberately incomparable, there is a section that normalises them, which is the part most likely to save you money.

The real problem: nothing is priced in the same unit

Look at what you are actually asked to compare:

• Credits — an editor charges you per agent action
• Per developer per month — a backend charges by headcount
• Per second of GPU — infrastructure charges by compute
• Per million tokens — a gateway charges by data volume
• Per seat — a design tool charges by user again, differently

These are not five prices. They are five different questions, and no spreadsheet compares them directly. The consequence is that teams pick tools by demo quality and discover the cost structure three months later, usually when a single busy week produces an alarming invoice.

The trick is to convert everything to cost per unit of work you actually do — per feature shipped, per thousand requests served, per model call. Do that once, before you commit, and most of these decisions become obvious.

Layer 1 — In the editor

This is where most developers meet AI, and where the market is loudest.

Sweep takes the unfashionable position of building for JetBrains rather than VS Code. It offers next-edit autocomplete that predicts your intent, inline editing, and an agent that searches the codebase, edits files, then runs tests and checks for linter errors. The interesting technical choice is that it uses JetBrains' own static analysis rather than inferring structure — which is what its team credits for the accuracy. It carries 4.9 stars across 40,000+ installs, with users at Ramp, Amplitude and Atlassian. Pricing is not published publicly, which is the main mark against it.

Kiro is AWS's spec-driven AI IDE, and it is a genuinely different philosophy. Instead of chatting your way to code, it turns a prompt into structured requirements, a design document and a task list, then has agents execute those tasks in parallel in local sandboxes. Steering files let you define coding standards the agents must follow, and event-driven automation updates docs and tests on file save. It is Open VSX compatible and reads your VS Code settings.

The free plan gives 50 credits with Claude Sonnet 4.5 access. Pro is $20 a month for 1,000 credits, scaling to Power at $200 for 10,000, with extra credits at $0.04 each.

The honest comparison: Kiro's structure is a real advantage on work with a defined scope — migrations, refactors, well-specified features. It is overhead on exploratory work where you do not yet know what you are building. Match the tool to the task, not to the benchmark.

Layer 2 — The design step nobody automates

AI agents build working pages that look generated. The problem is not the code, it is that the model has no reference for what good looks like in your niche.

Fudge is an MCP server that gives coding agents actual design evidence. It searches roughly 10,000 real websites by industry, page type, layout, color, font or visual similarity; inspects a live site's design system down to typography, spacing, radii, shadows and rendered styles; extracts palettes with contrast checks; identifies fonts and finds licensed alternatives; and exports a DESIGN.md your agent can build from. A Chrome extension saves references into per-project collections.

Explorer is $9 a month and Chat is $19, but the hosted MCP integration most people want starts at $29 (Pro), with Studio at $99. There is no free tier.

It comes from the Font Of Web team, which is a meaningful credential for the font-detection half of the product.

Layer 3 — The backend you are building on

Two very different answers depending on whether your product is an application or a content surface.

Convex is a reactive TypeScript backend bundling database, serverless functions, real-time sync, search and file storage with end-to-end type safety. It has a reactive database with ACID transactions preventing corruption from concurrent writes, real-time sync pushing changes to clients instantly, scheduled crons and webhooks, and both text and vector search in the same platform. Convex Components are open-source building blocks.

The free and Starter tier is $0 with pay-as-you-go overage, covering 1 to 6 developers with 1M function calls, 0.5GB database storage, 1GB file storage, 0.5GB search storage and 20 GB-hours of action compute. Professional is $25 per developer per month.

The vector search matters more than it sounds. If you are building anything retrieval-augmented, having vectors in the same system as your relational data removes an entire synchronisation problem that teams routinely underestimate.

Cosmic is an AI-native headless CMS delivering content over a REST API, with built-in AI agents for content generation, code, communication and browser automation, workflow automation for repeated publishing tasks, cookieless analytics with per-object attribution, and SDKs for Next.js, React and Vue.

Its free plan is $0 with no card, covering 1 bucket, 2 team members, 1,000 objects, 1 agent and 300k AI tokens a month. Builder is $49 and Team is $299.

Layer 4 — The model calls your app makes

The moment your product calls an LLM, you have a new class of problem: three provider accounts, three billing dashboards, three sets of keys, and no single view of spend.

Two tools solve this differently, and the difference matters.

The transparent gateway

Tokens Forge gives you one OpenAI-compatible sk- key that reaches GPT, Claude and Gemini models, with a single dashboard for keys, balance and usage. It drops into existing tools — Cursor-style clients, Open WebUI, Dify, LiteLLM, or plain Python and Node.

The feature worth singling out is that settlement prices are published per model before you spend, input and output per million tokens. Billing is usage-based with no subscription, and new accounts get a starter credit to test before adding balance.

The everything aggregator

APIXO goes wider: one API across 29 image models, 7 audio models, LLMs and a full video lineup, switched by changing one parameter. Its Chat API is drop-in compatible with Claude, OpenAI Responses and Gemini — you change only the base URL and key. Generation APIs run async with polling or webhooks, there are SDKs for JavaScript, Python and Go, and an MCP server works inside Cursor, Claude Code and Codex. Best-value routing picks a provider from real-time health, latency and cost signals, with automatic failover.

Pricing is pay-as-you-go with no subscription and credits that never expire. Published rates include Veo 3.1 Lite at $0.15 per 720p video and Sora 2 at $0.10 per second.

Should you use a gateway at all?

Worth thinking about properly rather than defaulting either way.

Arguments for: one integration instead of three, one bill, model switching without a code change, and failover when a provider degrades — which they do.

Arguments against: you have added a dependency between your app and every model it uses. If the gateway goes down, everything goes down at once, where separate integrations would have failed independently. There is also a margin in there somewhere, because the gateway is a business.

The reasonable position: gateways are excellent while you are still deciding which models you need, and during any period where you are evaluating alternatives. Once one model is clearly your production choice and volume is high, a direct integration for that path — with the gateway kept as fallback — is usually the better architecture.

Layer 5 — Infrastructure that runs your own models

If you are running inference or training rather than calling someone else's API, this is where the money goes.

Modal is Python-native serverless compute that scales from a laptop to 1000+ GPUs with sub-second cold starts. Code and hardware requirements live in the same codebase, it offers H100, A100, B200 and other GPUs across global regions, built-in logging and observability, sandboxed ephemeral environments for running untrusted code, and SOC2 and HIPAA compliance with data residency controls.

The Starter plan is free with $30 a month in compute credits, 3 seats and 10 GPU concurrency. Usage is billed per second: roughly $0.0011 for an H100, $0.0007 for an A100 80GB, $0.00016 for a T4. Team starts at $250 a month including $100 of credits.

That per-second billing deserves a moment. A T4 at $0.00016 a second is about $0.58 an hour; an H100 is around $3.96. The reason cold start time matters so much is that with per-second billing, a slow cold start is not an annoyance — it is a line item you pay on every single invocation.

Baseten occupies the same space, focused on deploying and serving ML models in production with fast inference infrastructure at scale. Pricing is not published.

Layer 6 — When you should not build it at all

The most underrated engineering decision is recognising which internal tools do not deserve a codebase.

Whacka takes a plain-language description and generates the interface, database, authentication, permissions and notifications, then hosts it — with push and email notifications built in, and shipping to Google Play and the App Store with over-the-air updates. The free tier deploys a live app rather than a preview, and you keep ownership of your data, users and app with no vendor lock-in. Paid plans add build credits, a custom subdomain and data and code export, but prices are not published.

The right use is not your product. It is the internal request tracker, the client status page, the small tool that would take a week and then need maintaining forever.

Normalising the costs: what this stack actually runs at

Here is the same stack priced in comparable terms.

Solo developer, side project — $0

Convex free tier with 1M function calls. Modal Starter with $30 a month of compute credits. Cosmic free bucket. Kiro's 50 free credits for editor assistance. Tokens Forge starter credit for model calls.

The free tiers in this category are unusually strong — better than in marketing or design tooling — because developer tools convert on production usage, not on trial expiry.

Small team shipping a product — roughly $150 to $250 a month

Convex Professional at $25 per developer for three developers is $75. Kiro Pro at $20 each is $60. Fudge Pro at $29 if design consistency matters. Model calls on usage — for most early products, under $50 a month.

Running your own inference — variable, and this is the one to model

GPU compute dominates everything else. One H100 running continuously is roughly $10,000 a month; the same H100 at 5 percent utilisation with sub-second cold starts is around $500. Your architecture, not your vendor, decides which of those you pay.

A worked example: costing a feature before you build it

The advice to "normalise the units" is easy to say. Here it is applied to one concrete feature.

The feature: a document summariser inside an existing SaaS product. Users upload a PDF, get a structured summary back. Expected volume, honestly estimated: 2,000 documents a month, averaging 8 pages.

Step one — the model call. Eight pages is roughly 4,000 tokens in, and a structured summary is maybe 600 out. At published gateway rates, a mid-tier model at $1.25 per million input and $7.50 per million output works out at about $0.005 input plus $0.0045 output — call it a cent per document. Two thousand documents is around $20 a month. That is the number that actually matters, and you could not have reached it without published per-model rates.

Step two — the backend. Each document is an upload, a function call, a database write and a status poll. Call it six function calls per document, so 12,000 a month — comfortably inside a free tier offering 1M. Storage for the PDFs is the real constraint, not compute.

Step three — do you need GPUs at all? No. This is an API call to somebody else's model. The temptation to reach for inference infrastructure here would have added hundreds a month for nothing.

Step four — the editor cost. Building this is maybe two days of agent-assisted work. On a credit-based IDE at $20 for 1,000 credits, that is a rounding error.

Total: roughly $20 a month in variable cost, on infrastructure you were already paying for. Now compare that to the twenty seconds it would have taken to assume "AI features are expensive" and not build it.

The reverse case is just as instructive. Change the feature to "summarise every document our users have ever uploaded" — 400,000 documents — and the same arithmetic returns $4,000. Same code, same architecture, completely different business decision. Volume is the variable that decides, and it is knowable in advance.

The five cost traps

Credits that look cheap per unit. $0.04 per extra credit sounds trivial until an agent runs a hundred actions solving one problem. Check what a credit buys before assuming the headline allowance is generous.

Per-developer pricing on a growing team. $25 per developer is fine at three and $500 at twenty. Model your cost at the team size you expect in a year, not today's.

Idle GPU time. The most expensive line in any AI product is compute you provisioned and did not use. This is precisely why cold start performance is an economic feature rather than a convenience one.

Free tiers sized to your test, not your traffic. 1M function calls is enormous in development and modest under real load. Do the arithmetic against projected traffic before choosing.

The gateway margin. Convenient, and it is not free. At low volume it is irrelevant; at high volume on a single model it becomes the argument for a direct integration.

What to actually watch for on lock-in

Every tool here creates some dependency. They are not equally reversible.

Lowest risk: gateways with OpenAI-compatible APIs. Because Tokens Forge and APIXO both speak a standard interface, moving away is a base URL change. That compatibility is a portability feature, not just a convenience.

Medium: serverless compute. Modal's Python-native model means hardware requirements live in your code — clean to work with, and something to rewrite if you leave.

Highest: reactive backends. Convex's real-time sync and type safety are genuinely excellent and deeply woven into how you write the application. That is the trade: the tighter the integration, the more you gain and the more a migration costs. Worth entering deliberately rather than by accident.

The practical check for any of them: can you export your data in a usable format today, without asking support? If the answer is no, that is the lock-in, whatever the marketing says.

What AI still does badly in a codebase

An honest list, because knowing the failure modes is what separates useful assistance from expensive rework.

Anything requiring the whole system in its head. Agents work well inside a file and reasonably across a few. Changes whose correctness depends on an invariant held in six places will produce something that compiles, passes the obvious tests, and breaks a case nobody wrote a test for.

Your undocumented conventions. Every codebase has rules that exist only in the team's heads — this service never calls that one directly, these IDs are always strings. Steering files and instruction documents help, which is exactly why spec-driven tools bother with them, but the coverage is never complete.

Knowing when to stop. An agent asked to fix a failing test will fix the test. Sometimes the test was right and the code was wrong. Without an explicit stop condition, you get a green suite and a live bug.

Dependency and version reality. Models confidently use APIs that were deprecated two versions ago, because that is what most of the training data shows. Anything touching a recently-changed library needs checking against current docs, not against the model's memory.

Security-relevant judgement. Auth flows, permission checks, anything handling secrets or untrusted input. Generated code here is often superficially correct and subtly permissive. Modal offering sandboxed ephemeral environments for running untrusted code exists precisely because this class of problem is real.

The pattern across all five: AI is strong where the correct answer is checkable and weak where correctness depends on context that was never written down. Point it at the first kind of work and it earns its cost easily.

Common questions

Is an AI IDE actually faster, or does it just feel faster?

It depends heavily on the task. On well-specified work — migrations, boilerplate, refactors with clear rules — the gains are real and large. On novel architectural work the bottleneck was never typing speed, and an agent confidently producing a plausible wrong approach costs more time than it saves.

Should I use a gateway or go direct to providers?

Gateway while you are still choosing models or running fewer than a few million tokens a month. Direct once one model is clearly your production path and volume is meaningful. Keeping the gateway as a fallback route is a reasonable middle position.

Do I need vector search in my database?

If you are building retrieval-augmented anything, having vectors alongside your relational data removes a synchronisation problem that gets worse over time. Convex bundling both is a genuine simplification rather than a checkbox.

How do I estimate GPU costs before I have traffic?

Take your expected requests per day, multiply by average inference seconds, and multiply by the per-second rate. Then double it, because cold starts, retries and failures are real. Published per-second rates like Modal's make this arithmetic possible in advance, which is exactly why unpublished pricing is a problem.

Which single tool should I start with?

If you are building an app, Convex's free tier — it removes the most decisions at once. If you are integrating models into something existing, Tokens Forge, because published per-model rates let you cost the feature before writing it.

The bottom line

The AI in a developer stack is not one product, it is five layers with five pricing models, and the mistake is treating the editor assistant as the whole conversation.

Start free — this category has genuinely usable free tiers, and Convex, Modal, Cosmic and Kiro all give you enough to build something real. Convert every price to cost per unit of work before you commit. And when you evaluate a tool, look at the export path as carefully as the feature list, because that is the number you will care about in year two.