DEV Community: Hirak

OpenAI API Pricing in 2026 — What You Actually Pay Per Token

Hirak — Wed, 19 Aug 2026 14:30:02 +0000

GPT-5.6 Sol costs $5.00 per million input tokens and $30.00 per million output. Terra is $2.00 in and $12.00 out. Luna, the cheap one, is $0.20 and $1.20. Those are standard-tier prices for prompts up to 272K input tokens — go past that and input doubles while output rises 1.5x, which most pricing write-ups never mention. Two of the three moved on July 30, 2026.

Last verified: 11 August 2026.

I re-check this page monthly against OpenAI's own pricing page and changelog, not against other people's summaries. Per-token pricing is the fastest-rotting number in this industry and a stale table here costs you real money.

The GPT-5.6 pricing ladder

Everything below is the Standard service tier, in dollars per 1M tokens, from developers.openai.com/api/docs/pricing.

One thing you need to know before reading any GPT-5.6 price anywhere: OpenAI's table is split into two context bands. The header tooltips define them precisely — short context is ≤272K input tokens, long context is >272K. Almost every summary you'll find quotes only the short-context half. Here are both.

Short context (≤272K input tokens):

Model	Input	Cached input	Output
gpt-5.6-sol	$5.00	$0.50	$30.00
gpt-5.6-terra	$2.00	$0.20	$12.00
gpt-5.6-luna	$0.20	$0.02	$1.20

Long context (>272K input tokens):

Model	Input	Cached input	Output
gpt-5.6-sol	$10.00	$1.00	$45.00
gpt-5.6-terra	$4.00	$0.40	$18.00
gpt-5.6-luna	$0.40	$0.04	$1.80

The jump is not a rounding detail: input doubles and output goes up 1.5x the moment a request crosses 272K input tokens. If your workload is long documents — codebases, contracts, transcript piles — the long-context column is your real price, and budgeting off the short-context one understates your bill by around 2x on input.

GPT-5.6 Sol, Terra, and Luna API pricing compared

GPT-5.6 Standard-tier, short-context (≤272K input tokens) API pricing for Sol, Terra and Luna — input and output cost in dollars per 1 million tokens, on a log scale. Luna's output price is 25x cheaper than Sol's ($1.20 vs $30.00 per 1M tokens). Verified 10 August 2026 against developers.openai.com/api/docs/pricing.

There's a fourth column on OpenAI's table that most write-ups drop: cache writes, which cost more than a plain input token. Sol writes are $6.25, Terra $2.50, Luna $0.25. That's 1.25x the standard input price, so priming a cache costs you a 25% premium on the first pass in exchange for 90% off every read after it.

The July 30, 2026 changelog entry matters because the two cuts weren't the same size: "Starting July 30, GPT-5.6 Luna costs 80% less, while GPT-5.6 Terra costs 20% less." Luna got the headline. If you sized a budget off a Terra quote from July, you're only 20% off. If you sized one off Luna, your estimate is five times too high, which is the nicer direction to be wrong in.

All three share the same envelope: 1.05M token context window, 128K max output, knowledge cutoff February 16, 2026. So any of them fits your documents — but fitting and costing the same are different things. The 272K band boundary above applies to all three equally, so the choice between models is about cost and quality, while the choice about how much context you send is a separate pricing decision of its own.

Legacy models are still billed at their own rates

This matters more than it sounds. When a vendor retires a model slug, one of two things happens: the request errors, or it silently redirects and bills at the successor's rate. I checked every older row on OpenAI's table against its GPT-5.6 replacement and none of them have been quietly repriced, even the ones already carrying a shutdown date. You pay what the row says.

Model	Input	Cached input	Output
gpt-5	$1.25	$0.125	$10.00
gpt-5-mini	$0.25	$0.025	$2.00
gpt-5-nano	$0.05	$0.005	$0.40
gpt-5-pro	$15.00	—	$120.00
gpt-4.1	$2.00	$0.50	$8.00
gpt-4.1-mini	$0.40	$0.10	$1.60
gpt-4.1-nano	$0.10	$0.025	$0.40
gpt-4o	$2.50	$1.25	$10.00
gpt-4o-mini	$0.15	$0.075	$0.60
gpt-3.5-turbo	$0.50	—	$1.50
o1	$15.00	$7.50	$60.00
o1-pro	$150.00	—	$600.00
o3	$2.00	$0.50	$8.00
o3-pro	$20.00	—	$80.00
o3-mini	$1.10	$0.55	$4.40
o4-mini	$1.10	$0.275	$4.40

o1-pro at $150 input and $600 output per million is still sitting there, roughly thirty times Sol's input price for a model that shuts down in October. Nobody should be sending it traffic. Someone is.

Two other things fall out of this table. gpt-4o's cached input is $1.25, only half its standard input rate rather than the 90% discount the GPT-5.6 rows get, so caching is worth dramatically less on the gpt-4o pair specifically — the gpt-5, gpt-5-mini and gpt-5-nano rows still show the full 90% ratio. And the legacy rows show a dash in the cache-writes column, meaning the write premium is a GPT-5.6-era addition rather than something you were already paying.

Fast mode is Priority Processing with a new name

Do not treat this as a new feature to evaluate. OpenAI's own guide says: "Priority processing was renamed Fast mode on July 30, 2026." Same tier, new label, generally available right now. The old service_tier: "priority" value still works and is an alias for service_tier: "fast", so nothing in your code breaks.

What did change is speed. OpenAI says it "increased the speed at which Fast mode operates for gpt-5.6-sol to make it up to 2.5× faster than Standard processing," with "more consistent latency while keeping pay-as-you-go flexibility."

The price is the interesting part. For the entire GPT-5.6 family, Fast mode is exactly 2x Standard, to the cent — and that holds in both context bands. Short-context Fast prices:

Model	Fast input	Fast cached	Fast output
gpt-5.6-sol	$10.00	$1.00	$60.00
gpt-5.6-terra	$4.00	$0.40	$24.00
gpt-5.6-luna	$0.40	$0.04	$2.40

Above 272K input tokens the same 2x applies to the long-context rates: Sol runs $20.00 in / $90.00 out, Terra $8.00/$36.00, Luna $0.80/$3.60.

Older models get a smaller markup. gpt-4o goes from $2.50 to $4.25 input, which is 1.7x. o3 goes $2.00 to $3.50, or 1.75x. gpt-4o-mini goes $0.15 to $0.25, about 1.67x. If your latency-sensitive path is still on gpt-4o, Fast mode is proportionally cheaper there than it would be on the new family — the sort of asymmetry that quietly changes the shape of a migration plan. (None of the older models publishes a long-context price in any tier — gpt-5.5, gpt-5.5-pro, gpt-5.4 and gpt-5.4-pro are explicitly labelled "(<272K context length)", the rest simply carry no context band at all — so for them the Fast price you see is the whole story.)

Fast mode isn't available on everything. The pricing table's fast tier lists gpt-5.6-sol, terra and luna, then gpt-5.5, gpt-5.4, gpt-5.4-mini, gpt-5.2, gpt-5.1, gpt-5, gpt-5-mini, gpt-4.1, gpt-4.1-mini, gpt-4.1-nano, gpt-4o, gpt-4o-2024-05-13, gpt-4o-mini, o3 and o4-mini. No other slugs appear with populated prices.

Batch and Flex: the same 50%, two different trades

Batch is 50% off with a 24-hour completion window, plus what OpenAI calls "a separate pool of significantly higher rate limits." For Sol that's $2.50 input, $0.25 cached, $3.125 cache write, $15.00 output. Terra lands at $1.00/$0.10/$1.25/$6.00 and Luna at $0.10/$0.01/$0.125/$0.60. The long-context band halves the same way — Sol at $5.00 in / $22.50 out above 272K input tokens. Exact halves in both bands, no rounding surprises.

Flex charges the same halved rates for the three GPT-5.6 models — I checked those rows cell by cell, in both bands — but the two tiers are not mirror images: Batch prices 34 model rows where Flex prices 16, so eighteen slugs have a Batch price and no Flex option at all. (The two easy to miss on the Flex list are gpt-5.5-pro and gpt-5.4-pro, both at $15.00 in / $90.00 out — half their standard $30/$180.) And Flex carries a caveat Batch doesn't: OpenAI's guide says plainly that "Flex processing is in beta with limited model availability." What you're buying is different too. Batch trades turnaround for money; Flex trades per-request latency for money and warns about "occasional resource unavailability." So Flex is for synchronous work where you can tolerate slow and can retry, and Batch is for work you can hand over and collect tomorrow. Same bill, very different failure mode.

Prompt caching, and a change that will bite migrations

Caching turns on by itself for any prompt of 1024 tokens or longer. No flag, no opt-in. On the GPT-5.6 family that's a 90% discount on the cached portion, which is the single biggest lever on this whole page if you run long system prompts.

The gotcha is a behaviour change, not a price. OpenAI's caching guide states that GPT-5.6 and later "cache exact prompt prefixes at cache breakpoints," with an implicit breakpoint at the latest user or tool message, and that unlike earlier models it "does not automatically fall back to the longest matching unmarked prefix before that breakpoint." Translated into a bill: a prompt-assembly pattern that was reliably hitting cache on GPT-5 can quietly stop hitting it on Sol, and you find out from your invoice rather than from an error. Watch your cached-token counts for the first week after you switch.

One more line item that's easy to miss: regional processing endpoints carry a 10% uplift for models released on or after March 5, 2026 that are eligible for data residency. Every price above assumes you're not using them.

Usage tiers

Access is gated by cumulative spend, and promotion is automatic — the docs say "as your spend on our API goes up, we automatically graduate you to the next usage tier."

Tier	Qualification	Monthly usage limit
Free	Allowed geography	$100 / month
Tier 1	$5 paid	$100 / month
Tier 2	$50 paid	$500 / month
Tier 3	$100 paid	$1,000 / month
Tier 4	$250 paid	$5,000 / month
Tier 5	$1,000 paid	$200,000 / month

Spend is the only variable on that page. There's no waiting period listed, no account-age criterion, nothing about payment history.

Two things I went looking for and could not find. First, per-model RPM and TPM numbers: I checked the rate-limits guide, the models page and the pricing page on 10 August, and none of them carry a public per-tier RPM/TPM table. The rate-limits guide points you at the models page for "a high-level summary," but the models page's public HTML has no such figures, and the authoritative per-org numbers live behind login at platform.openai.com/settings/organization/limits, which returns 403 without an account. Second, a new-account free credit: I checked the rate-limits guide, the quickstart and the pricing page, and none of them state a dollar grant for new signups. The widely repeated "$5 free credit" isn't on any of those pages, so I'm not printing it as a number. The only "Free" is that top table row, and it's a ceiling, not a gift.

Dated shutdowns you need in your calendar

These are absolute dates from OpenAI's deprecations page. I'm writing them out in full because a page that says "next month" is worthless six weeks later.

Date	What goes away	Replacement
10 August 2026	gpt-5.2-chat-latest, gpt-5.3-chat-latest	gpt-5.6-sol
26 August 2026	Assistants API	Responses API + Conversations API
24 September 2026	Videos API, sora-2, sora-2-pro and all their snapshots	none listed
28 September 2026	gpt-3.5-turbo-instruct, gpt-3.5-turbo-1106, babbage-002, davinci-002	gpt-5.6-terra
23 October 2026	gpt-3.5-turbo (base and 0125), gpt-4 and gpt-4-turbo families, gpt-4.1-nano, gpt-4o-2024-05-13, gpt-image-1, o1, o1-pro, o3-mini, o4-mini	GPT-5.6 family; gpt-image-1 → gpt-image-2
30 November 2026	v1/prompts reusable prompt objects, the Evals dashboard and API (read-only from 31 October), Agent Builder	app code / Agents SDK
1 December 2026	gpt-image-1.5, gpt-image-1-mini, chatgpt-image-latest	gpt-image-2
11 December 2026	gpt-5-2025-08-07, gpt-5-mini-2025-08-07, gpt-5-nano-2025-08-07, gpt-5-pro-2025-10-06, o3-2025-04-16, o3-pro-2025-06-10	Sol / Terra / Luna
20 January 2027	gpt-realtime, gpt-audio, gpt-4o-audio, gpt-4o-realtime and the mini variants	gpt-realtime-2.1 (mini variants → gpt-realtime-2.1-mini), gpt-audio-1.5; gpt-4o-mini-transcribe → its 2025-12-15 snapshot

Mind the gpt-3.5 split: the -instruct and -1106 variants go on 28 September, a month before the rest of the family. If you're on either — both are still individually priced today — the October date everyone quotes is a month late for you.

The two chat-latest snapshots went dark on 10 August 2026, the same day this article was drafted. Notice also that the December wave maps gpt-5-pro and o3-pro onto gpt-5.6-sol with reasoning.mode: pro rather than onto a separate pro model.

Fine-tuning is winding down too. The pricing page says the platform "is no longer accessible to new users," and the deprecations page puts a hard date on the rest: active existing customers can no longer create new fine-tuning jobs after 6 January 2027. Fine-tuned models stay available for inference until their base models are deprecated. If you're already on it, o4-mini fine-tuning is $100.00/hour to train with inference at $4.00/$1.00/$16.00 per 1M, halved to $2.00/$0.50/$8.00 if you opt into data sharing. That data-sharing discount is the only one of its kind on the page, and it applies to fine-tuned inference only, not to regular chat calls.

Everything else on the bill

Embeddings are cheap enough to ignore in most budgets: text-embedding-3-small is $0.02 per 1M, 3-large is $0.13, and ada-002 is $0.10 — which means the old ada model now costs five times the current small one. Moderation via omni-moderation-latest is free, listed literally as "Free" in the input column.

Image generation bills tokens in two streams — and both current models have a shutdown date. gpt-image-1.5 charges $8.00 input, $2.00 cached and $32.00 output per 1M image tokens, plus $5.00/$1.25/$10.00 on the text side. gpt-image-1-mini is $2.50/$0.25/$8.00 for image tokens and $2.00/$0.20 for text input and cached input. Both are removed from the API on 1 December 2026 along with chatgpt-image-latest, replaced by gpt-image-2 — which is already priced on the page at $8.00/$2.00/$30.00 per 1M image tokens ($5.00/$1.25 text). If you're building on image generation in the autumn, build on gpt-image-2 from the start.

Last housekeeping note, and it trips up scripts more than people: platform.openai.com/docs/* now 301-redirects to developers.openai.com/api/docs/*. Old bookmarks resolve fine, so nothing looks broken, but if you've got a scraper or an agent pinned to the old host it's following a redirect it may not be logging. Same class of quiet migration as the retired Grok slugs that keep billing without erroring.

If you're comparing this against what other vendors charge, the free AI API rate limits page covers the zero-dollar end of the market, and whether the Claude API is free does the same for Anthropic.

8 Retired Grok Slugs Still Work — And Bill at grok-4.3 Rates

Hirak — Mon, 17 Aug 2026 14:30:08 +0000

If your code still sends requests to grok-4-1-fast-non-reasoning, grok-3, or six other Grok model IDs, those requests still work. They worked before 15 May 2026 and they have kept working since. Nothing errored, nothing warned, nothing in your logs changed. What changed that day was the bill.

They are being served by grok-4.3 and billed at grok-4.3 prices: $1.25 per 1M input tokens and $2.50 per 1M output.

Last verified: 7 August 2026 against the migration notice and current model docs. Re-checked monthly.

(The company is now SpaceXAI — xAI was absorbed into SpaceX. The docs still say xAI. More on that below.)

The eight slugs

From xAI's model retirement notice, effective 15 May 2026 at 12:00 PM PT:

Retired slug	Now served by
`grok-4-1-fast-reasoning`	`grok-4.3`, `low` reasoning effort
`grok-4-1-fast-non-reasoning`	`grok-4.3`, `none` reasoning effort
`grok-4-fast-reasoning`	`grok-4.3`, `low` reasoning effort
`grok-4-fast-non-reasoning`	`grok-4.3`, `none` reasoning effort
`grok-4-0709`	`grok-4.3`, `low` reasoning effort
`grok-code-fast-1`	`grok-build-0.1`
`grok-3`	`grok-4.3`, `none` reasoning effort
`grok-imagine-image-pro`	`grok-imagine-image-quality`

A note on the name

The company that retired these models was xAI. It isn't called that any more.

SpaceX acquired xAI in a merger that closed 2 February 2026, Musk said in May that xAI would be
dissolved as a separate company, and on 6 July 2026 the rebrand to SpaceXAI was made official
with a new logo and a renamed X account.

The developer surfaces have not caught up. As of 7 August 2026 the API docs still live at
docs.x.ai, still say "the xAI API", and still point support at support@x.ai — no mention of
SpaceX or SpaceXAI anywhere on the retirement notice. The models are still Grok.

So: the retirement was announced by xAI, the entity is now SpaceXAI, and the thing you actually
type into your config didn't change at all. This page says "xAI" where it's quoting xAI's own docs,
because that's what they say.

Why this one is easy to miss

Most deprecations announce themselves. You get a 404, a deprecation header, something in a changelog you eventually read. This one is the opposite, and xAI says so plainly:

After May 15, 2026 at 12:00 PM PT, requests to the retired model slugs above will automatically redirect to grok-4.3. The slugs themselves continue to resolve, so you do not need to change your code to avoid breakage.

That's genuinely considerate engineering — nobody's production traffic fell over. But the same doc adds:

If you continue sending requests to a deprecated slug after May 15, please be aware that you will be billed at grok-4.3 pricing

So the failure mode isn't an outage. It's a bill that changed while every string in your codebase stayed the same. If you set grok-4-1-fast-non-reasoning in an env var eight months ago and haven't looked since, you are on grok-4.3 pricing and your config still says otherwise.

What you actually pay now

Current xAI model pricing, checked 7 August 2026:

Model	Input / 1M	Output / 1M
`grok-4.5` (<200k ctx)	$2.00	$6.00
`grok-4.5` (≥200k ctx)	$4.00	$12.00
`grok-4.3` (<200k ctx)	$1.25	$2.50
`grok-4.3` (≥200k ctx)	$2.50	$5.00
`grok-4.20` reasoning / non-reasoning	$1.25	$2.50
`grok-4.20-multi-agent`	$1.25	$2.50
`grok-build-0.1` (<200k ctx)	$1.00	$2.00

Published Grok API prices under 200k context, and where retired slugs bill

xAI's published under-200k prices per 1M tokens. All eight retired slugs are served by grok-4.3 and bill at its $1.25 / $2.50 — regardless of the model name your config still shows. Verified 7 August 2026 against xAI's own docs.

A note on the old prices. You'll see figures circulating for what the retired fast models used to cost — grok-4-1-fast at $0.20 / $0.50 is the one most often repeated. We're not stating it as fact: xAI no longer publishes pricing for retired models and we couldn't reach an archived copy to confirm it. For your own delta, the only record of what you were actually charged is your xAI billing history either side of 15 May.

You don't need that number to see the problem, though. Everything above is published, and it already shows you're on the mid tier: grok-4.3 at $1.25/$2.50 when grok-build-0.1 sits right there at $1.00/$2.00. You didn't choose that — a redirect did.

What isn't in doubt is the direction. The retired slugs were the cheap, fast tier. grok-4.3 is not the cheap, fast tier.

Check in thirty seconds

grep -rEn 'grok-4-1-fast|grok-4-fast|grok-4-0709|grok-code-fast-1|grok-3\b|grok-imagine-image-pro' \
  --include='*.js'   --include='*.ts'   --include='*.py'  --include='*.go'  \
  --include='*.rb'   --include='*.rs'   --include='*.java' --include='*.json' \
  --include='*.yaml' --include='*.yml'  --include='*.env' --include='*.toml' .

(One --include per extension on purpose. The tidier-looking --include='*.{js,ts,py}' matches nothing at all: the braces are inside quotes so the shell never expands them, and --include doesn't do brace alternation — so it fails silently and looks like a clean bill of health.)

Also check the places code search misses: environment variables in your hosting dashboard, CI secrets, serverless config, and any model name stored in a database or feature flag.

If you get hits, you have a decision rather than an emergency. Requests still succeed. But you should pick the model deliberately instead of inheriting one, and grok-build-0.1 at $1.00/$2.00 is cheaper than grok-4.3 if the work suits it.

The wider lesson

This is the same class of problem as free tiers that quietly shrink — the number you built against stops being the number you're on. Silent redirect is becoming the normal way model providers retire things, because breaking production is worse press than a quiet price change. It's the right call for uptime. It does mean the old assumption — if it still runs, nothing changed — no longer holds for AI APIs.

The practical habit: treat model IDs like dependency versions. Pin them somewhere visible, and re-read the provider's model page on a schedule rather than when something breaks. Nothing will break.

Keep reading

Running Codex CLI or Claude Code on Another Model: What It Actually Costs (2026)

Hirak — Fri, 14 Aug 2026 14:30:02 +0000

Last verified: 6 August 2026; OpenAI, Anthropic and repo facts re-verified 11 August 2026.

Claude Sonnet 5 costs $2 per million input tokens and $10 per million output tokens — as standard pricing now, not an introductory rate. It wasn't supposed to stay that way: the launch price was labelled introductory through 31 August, with a 50% rise to $3/$15 scheduled for 1 September. Anthropic cancelled it. Their pricing page now says it outright: "The $2/$10 per million input/output token pricing for Claude Sonnet 5, announced at launch as introductory pricing through August 31, 2026, is now the standard price. The previously scheduled increase to $3/$15 per million input/output tokens on September 1, 2026 will not occur." If you'd budgeted a September jump into a long agentic coding job, take it back out.

That reversal is the reason this page exists this week. The broader question underneath it is one a lot of people are asking now that opencodex can point Codex CLI or Claude Code at a completely different vendor's model: if the harness is portable, what does each engine actually cost per token?

Output cost per million tokens for models opencodex can route Codex CLI or Claude Code to, verified 6 August 2026

Output price per million tokens (MTok) for every model opencodex can point Codex CLI or Claude Code at, cheapest to most expensive. Claude Sonnet 5 stays at $10 per million output tokens — the 50% rise scheduled for 1 September 2026 was cancelled, and $2/$10 is now the standard price. Log scale; verified 6 August 2026 (Anthropic and OpenAI figures re-verified 11 August) against each vendor's own pricing page.

What opencodex is, and what it isn't

It's a local proxy. Free, MIT-licensed, self-hosted, binds to 127.0.0.1 by default. Latest release is v2.12.0, published 10 August 2026. About 9,300 stars on GitHub when I checked on 11 August.

It does not save you money on tokens. Every provider needs your own key or your own OAuth session. The README is direct about it: "Log in once, skip the API key — OAuth for xAI, Anthropic, and Kimi; or forward codex login, paste a key, or use ${ENV_VAR} references." So opencodex doesn't lower your bill. It changes which meter is running. That distinction is the whole point of the table below, because once you can freely swap the engine under Claude Code, the price per million tokens becomes a decision you make rather than one you inherit.

The provider list it ships with covers OpenAI (ChatGPT login or API key), Anthropic, Google Gemini, SpaceXAI (still branded xAI throughout its docs and opencodex's config), Kimi, Azure OpenAI, and Ollama for local and cloud, plus DeepSeek, Groq, OpenRouter, Together, Fireworks, Cerebras, Mistral, Hugging Face, NVIDIA NIM, MiniMax, Qwen Cloud and SiliconFlow.

Per-token prices, verified 6 August 2026

Every price below came from the vendor's own pricing or docs page on the check date. Rates are per million tokens (MTok).

Model	Input / MTok	Output / MTok	Source
Claude Sonnet 5 (standard — Sept rise cancelled)	$2.00	$10.00	platform.claude.com
Claude Opus 5	$5.00	$25.00	platform.claude.com
Claude Haiku 4.5	$1.00	$5.00	platform.claude.com
gpt-5.6-sol (≤272k input tokens)	$5.00	$30.00	developers.openai.com
gpt-5.6-sol (>272k input tokens)	$10.00	$45.00	developers.openai.com
gpt-5.6-terra (≤272k input tokens)	$2.00	$12.00	developers.openai.com
gpt-5.6-terra (>272k input tokens)	$4.00	$18.00	developers.openai.com
gpt-5.6-luna (≤272k input tokens)	$0.20	$1.20	developers.openai.com
gpt-5.6-luna (>272k input tokens)	$0.40	$1.80	developers.openai.com
Gemini 3.1 Pro Preview (≤200k input tokens)	$2.00	$12.00	ai.google.dev
Gemini 3.1 Pro Preview (>200k input tokens)	$4.00	$18.00	ai.google.dev
Gemini 3.6 Flash	$1.50	$7.50	ai.google.dev
Gemini 3.5 Flash-Lite	$0.30	$2.50	ai.google.dev
Grok 4.5 (<200k input tokens)	$2.00	$6.00	docs.x.ai
Grok 4.5 (≥200k input tokens)	$4.00	$12.00	docs.x.ai
deepseek-v4-pro	$0.435 (cache miss) / $0.003625 (cache hit)	$0.87	api-docs.deepseek.com
deepseek-v4-flash	$0.14 (cache miss) / $0.0028 (cache hit)	$0.28	api-docs.deepseek.com
Ollama, local inference	$0	$0	ollama.com

The spread between the top and bottom of that table is enormous. gpt-5.6-sol output is $30/MTok. deepseek-v4-flash output is $0.28/MTok. That's a factor of over a hundred for the same slot in your Codex config.

The context cliff is the number that should scare you

Three of the four big providers in this table price by prompt length. Gemini 3.1 Pro and Grok 4.5 put the threshold at 200k input tokens; OpenAI puts the GPT-5.6 family's at 272k — the pricing table's own header tooltips define short context as ≤272K input tokens and long context as everything above.

Gemini 3.1 Pro at or under 200k is $2 in, $12 out. Cross the line and it's $4 in, $18 out. Input doubles; output goes up half again. Grok 4.5 is cleaner and worse: $2/$6 below 200k, $4/$12 at or above it — both sides double. OpenAI's cliff has the same shape as Gemini's: gpt-5.6-sol goes from $5/$30 to $10/$45 past 272k, input doubling and output up 1.5x, and Terra and Luna scale identically.

This is precisely the wrong failure mode for agentic coding, because agentic coding is a context-accumulation machine. Claude Code and Codex CLI don't send you a tidy 4k-token prompt. They send file contents, tool call results, diffs, test output, and the entire prior conversation, on every turn. On a small repo you never notice. On a large one, the run starts comfortably under the threshold, grows through a dozen tool calls, and at some point a single extra file read pushes the prompt past 200k. From that turn onward you're on the expensive rate, and nothing in your terminal announces it. You find out on the invoice.

Two practical consequences. If you're routing Claude Code at Gemini 3.1 Pro, Grok 4.5 or the GPT-5.6 family through opencodex on a big codebase, budget for the upper tier, not the headline rate, because that's where a real session ends up. And if you're deliberately keeping context small — narrow file globs, fresh sessions per task, clearing history between subtasks — that discipline is now worth actual money rather than just speed. Our notes on keeping Claude Code's context under control apply directly here.

Anthropic is the odd one out: Claude's published per-token table has no context-length threshold at all, so it's the only pricing in this comparison where the number you budget is the number you pay regardless of prompt size. OpenAI's 272k line is more forgiving than Google's and SpaceXAI's 200k — an agentic session gets another 72k tokens of headroom before the meter jumps — but it's the same trap.

Ollama is the only honest $0

Local Ollama inference costs nothing per token. Not a promotional rate, not a trial credit. You already bought the hardware, and the marginal cost of a token is your electricity bill. For a router like opencodex that's genuinely useful: point the cheap, high-volume work at a local model and reserve the metered API for the parts that need it.

The cloud tier is not free, and it would be dishonest to leave that fuzzy. Ollama's own pricing page lists a free tier at $0 for unlimited public models run on your own hardware, then Pro at $20/mo or $200/yr for "50x more cloud usage than Free" and three concurrent cloud models. Max is $100/mo for ten concurrent cloud models and five times Pro's usage, and it's currently paused for new signups, so you can't buy it today even if you want it. Team is $25/seat/mo with a five-seat minimum.

DeepSeek: publish the flat rate, and one warning

DeepSeek's live pricing page shows a single flat rate per model. deepseek-v4-pro is $0.435/MTok for a cache miss on input, $0.003625/MTok on a cache hit, $0.87/MTok output. deepseek-v4-flash is $0.14, $0.0028, and $0.28 respectively. The cache-hit price is the interesting one for agentic work, where the same system prompt and the same file contents get resent turn after turn.

One line from that same page is worth quoting exactly, because it's the only forward-looking pricing statement DeepSeek makes there: "We plan to raise the overall pricing for DeepSeek API services in the near future, with a significant increase expected." No date, no figures. Treat today's rate as provisional.

What the docs don't tell you

Both major pricing pages moved, and stale links are everywhere. Anthropic's per-token table now lives at platform.claude.com, not the old docs.anthropic.com console path. OpenAI's is at developers.openai.com/api/docs/pricing; the platform.openai.com pricing path is superseded. If a blog post is quoting one of those old URLs, you have no idea how old its numbers are.

Rate limits are the gap. Anthropic's pricing page gestures at Start, Build and Scale usage tiers but does not print the actual requests-per-minute or tokens-per-minute figures on that page, and I'm not going to guess at them. Same story for OpenAI, Google and SpaceXAI as reached through a proxy. If you're planning a high-throughput job, pull each vendor's rate-limit doc directly rather than trusting a number in an article, including this one. There's more on which providers are actually generous in our free AI APIs roundup and on Anthropic's own tiering in is the Claude API free.

The README's "40+ built-in providers" claim I could not confirm. The enumerated list in the README names roughly twenty by name; getting to forty would mean reading ocx init's live provider list, which I didn't do. Take the count as marketing until someone checks it.

Star counts drift fast enough to be useless as a quality signal. The repo read roughly 7,760 earlier that week, 7,770 on 6 August and 9,298 on 11 August. Cite it if you must, but date it.

And the thing nobody says out loud: swapping the model under Claude Code changes the model's behaviour, not just the price. A cheaper engine that needs three attempts at a refactor isn't cheaper. If you're weighing the two harnesses themselves rather than the engines, we covered that in Claude Code vs Codex CLI.

FAQ

Is opencodex free?
Yes. It's MIT-licensed, self-hosted, and runs locally on 127.0.0.1 by default. v2.12.0 shipped on 10 August 2026. You pay each provider directly.

Will Claude Sonnet 5 get more expensive?
No — not on the schedule everyone had in their calendar. The planned 1 September 2026 rise to $3/$15 was cancelled in August 2026; Anthropic's pricing page states the $2/$10 launch price "is now the standard price" and that the increase "will not occur."

Which model is cheapest for running Claude Code?
Local Ollama at $0 per token, if your hardware can handle the model. Among hosted APIs, deepseek-v4-flash at $0.14 in / $0.28 out is the lowest here, with gpt-5.6-luna at $0.20/$1.20 close behind (for prompts up to 272k input tokens — $0.40/$1.80 past it).

A warning that applies well beyond this table: xAI retired grok-4-1-fast-reasoning and grok-4-1-fast-non-reasoning on 15 May 2026, and requests to those slugs are now served by grok-4.3 and billed at grok-4.3's $1.25/$2.50 per million. The name still resolves. Nothing in your terminal tells you the substitution happened. If you are routing through a proxy to a model slug you picked months ago, check it against the vendor's live model list before you check your invoice.

What happens above 200k tokens on Gemini or Grok?
Gemini 3.1 Pro goes from $2/$12 to $4/$18. Grok 4.5 goes from $2/$6 to $4/$12. Long agentic sessions on large repos routinely cross that line.

Does opencodex reduce my token bill?
No. It's a routing layer. It lets you choose a cheaper meter; it doesn't discount any of them.

Is ChatGPT Actually Free in 2026? The Real Limits

Hirak — Wed, 12 Aug 2026 14:30:05 +0000

Yes, ChatGPT is still free in 2026. No card, no trial clock — and as of the week of 10 August, freer than it used to be: OpenAI's help pages now state, in present tense, that Free users have unlimited everyday text chats. If your free account behaved strangely in early August, you weren't imagining it; OpenAI swapped the default model underneath the Free tier mid-week, and for five days its own documentation contradicted itself about what you were getting. This page watched that happen, and the record of it is below.

Last verified: 8 August 2026; rollout status, Free/Go limits and storage figures re-verified 11 August 2026. Every figure below was checked against an OpenAI help page or an OpenAI blog post on one of those dates. Where OpenAI publishes no number, this page says "not published" instead of borrowing one from somebody else's blog.

ChatGPT price ladder, Free to Pro $200/month, verified 8 August 2026

ChatGPT's published monthly price ladder, Free through Pro $200, plus the monthly-vs-annual price of a Standard Business seat. OpenAI describes both Pro tiers as sharing the same core capabilities, with usage allowance as the main difference. Verified 8 August 2026 against OpenAI's own help and product pages.

What changed on 6 August

OpenAI posted on 6 August 2026 that "GPT‑5.6 Luna will become the default model for Free and Go users this week." The help docs say the same thing and add that Free and Go users don't get GPT-5.6 Sol at all; Luna is their default, and Luna is also what powers the Think feature.

The bigger part landed on schedule. The post promised: "Starting next week, they'll also have unlimited text chats and access to a new Think button for harder questions (subject to abuse guardrails)" — and in the week beginning Monday 10 August, OpenAI's help pages flipped to present tense. The Free Tier FAQ now reads: "Free users have unlimited everyday text chats, subject to abuse-prevention safeguards." The GPT-5.6 page says the same for Go, and documents Think as live: "Free and Go users can use Think for harder questions in ChatGPT on the web and in the mobile app." One oddity worth noting: the announcement post itself was never updated — it still promises in future tense what the help pages now document as fact.

Unlimited is OpenAI's word, and the very next sentence in OpenAI's own post walks it back to the part that matters: "Limits will still apply for file uploads, images and other tools." So the honest reading is that plain back-and-forth typing stops being metered, while everything that costs real compute — attaching a PDF, generating an image, running data analysis — stays capped.

OpenAI has published some of those caps already, on a page most write-ups miss: the File Uploads FAQ limits Free users to 3 file uploads per day, against an "up to 80 files every 3 hours" ceiling that applies across plans. Those caps survived the change — the File Uploads FAQ was untouched by the rollout, and the announcement said plainly that "Limits will still apply for file uploads, images and other tools."

One piece is still officially mid-flight: the Luna default. The Availability section states it as fact — "Their default model is GPT-5.6 Luna" — while the Overview on the same page still says Luna "is becoming" the default, and a later section adds that Luna "powers the default ChatGPT experience for Free and Go users as it rolls out". Everything else in this section is present tense on OpenAI's own pages as of 11 August 2026.

The verified price and limit ladder

	Free	Go	Plus	Pro	Business (Standard seat)
Price	$0	$8/mo (US)	$20/mo	$100/mo or $200/mo	$25/user/mo monthly, $20/user/mo annual (min. 2 seats; Premium seat announced at $100/$125, not launched)
What the price buys	—	Localized in some markets	—	$100 = 5x Plus usage; $200 = 20x Plus usage	Per seat; varies by country
Annual billing	—	None	None	None	Yes, $20/user/mo (Standard seat)
Default model	GPT-5.6 Luna (live per docs; vendor still says "as it rolls out")	GPT-5.6 Luna	GPT-5.6 Sol rolling out to eligible paid plans	Same, plus higher usage allowance	GPT-5.5 Instant still listed as the base model
Text chat cap	Unlimited everyday text chats (live per docs, 11 Aug)	Same as Free	Not published	5x / 20x Plus	"Virtually unlimited" on eligible base models
Files per project	5	25	25 or 20 — OpenAI's two pages disagree	40	40
Simultaneous uploads (within Projects)	10	10	10	10	10
File uploads	3 per day	Up to 80 files per 3h	Up to 80 files per 3h	Up to 80 files per 3h	Up to 80 files per 3h
Live voice (all "up to"; OpenAI says limits may change)	Limited GPT-Live-1 mini per rolling 24h	1h Instant + 1h Medium/High + 2h mini	Same as Go	$100: 12h Instant + 12h Medium/High + 24h mini. $200: unlimited GPT-Live-1	1h Instant + 1h Medium/High, then 5 credits/min
Library storage	500 MB	4 GB	20 GB	100 GB	20 GB
Create custom GPTs	No	Yes (all paid plans)	Yes	Yes	Yes
Messages per N hours	Everyday text: unlimited	300 per 3h with Think on; plain chat: unlimited	Not published	Not published	GPT-5.5 Thinking: 3,000/week. GPT-5.5 Pro: 15/month
Images per day	Not published	Not published	Not published	Not published	Not published

Two things in that table are worth more than the rest. The first is that you cannot buy a discount by committing to a year on any individual plan — OpenAI's Pro tiers page states flatly that "Currently, we do not support annual billing or the option to pay for multiple months in advance for ChatGPT Go, Plus, or Pro subscriptions." All three, not just Pro. Business is the only plan here with an annual rate at all, and it's the one aimed at teams. The second is that both Pro tiers "include the same core capabilities. The main difference is usage allowance: Pro $100 unlocks 5x higher usage than Plus, while Pro $200 unlocks 20x usage than Plus." Note OpenAI's word is main, not only — the same page adds that "allowances can differ by Pro tier," and the voice row above is a live example, since unlimited GPT-Live-1 is a $200 thing. Mostly, though, the extra hundred dollars buys headroom rather than capability.

Web search stays off that table because OpenAI only publishes it as a Free-tier capability, and it's a good one: "Search the web and obtain up-to-date information" is listed outright on the Free Tier FAQ. You don't have to pay to get current information out of ChatGPT.

The storage and file numbers are the sharpest real difference between Free and paid for people doing actual work. Library storage runs 500 MB on Free, 4 GB on Go, 20 GB on Plus and Business, 100 GB on Pro — a 200x spread, and the single widest gap between any two rungs of this ladder. Projects allow 5 files per project on Free and 40 on Pro and Business. The 10-file simultaneous upload ceiling applies to everyone including the $200 tier, but note that it's a Projects limit specifically, not a global one.

One caveat on the Plus row, in keeping with the rest of this page: OpenAI publishes two different numbers for it. The Projects help article says 25 files per project; the File Uploads FAQ says "up to 20 files per project" for Plus. Both pages were updated within the last fortnight. I don't know which is current, so the table carries both rather than picking the flattering one.

For five days, OpenAI's own help page contradicted itself — here's the record

This section used to be written in the present tense. It's worth keeping in the past tense, because it explains what free users lived through in early August, and because watching a vendor's documentation disagree with itself is the clearest picture you'll ever get of how these rollouts actually work.

The article at help.openai.com/en/articles/20001354-gpt-56-in-chatgpt says two incompatible things about the Free tier, in two different sections of the same page.

The Overview opens with: "GPT-5.6 Luna is becoming the default model for Free and Go users."

The Availability by ChatGPT plan section agrees: "Free and Go users do not have access to GPT-5.6 Sol. Their default model is GPT-5.6 Luna, which also powers Think." But the line introducing that same section's table — a few lines above it, in the same section — reads: "GPT-5.5 Instant is not shown because it remains the default model."

And the Instant limits section further down still describes Free access the old way: "Free-tier users have limited GPT-5.5 Instant access within a 5-hour window."

So on 8 August the page stated that Luna was becoming the Free default and that GPT-5.5 Instant remained the default model, within a few lines of each other, and then metered the Free tier against Instant in a third place. All three passages were live simultaneously.

By 11 August, OpenAI had resolved it. The page (stamped "Updated: 2 hours ago" when I re-checked) deleted both stale legs — "GPT-5.5 Instant is not shown because it remains the default model" and the "limited GPT-5.5 Instant access within a 5-hour window" sentence are gone — and the Instant-limits section now reads: "Free and Go users have unlimited everyday text chats, subject to abuse-prevention safeguards." What remains is only a tense mix (the Overview still says Luna "is becoming" the default, and the Work/Codex/API section says it powers the experience "as it rolls out", while Availability states flatly that it is the default), plus one orphaned sentence: the Free Tier FAQ still warns that "GPT usage follows your current Free tier model limit" without defining what that limit is now that text chats are unlimited. If your free account hit a wall in early August, this five-day window is almost certainly why — the change was in flight, not your account broken.

The numbers everyone quotes that OpenAI does not publish

Search "ChatGPT free tier limit" and you will get a specific message count per 5 hours and a specific number of images per day, repeated across dozens of pages with total confidence. I'm not printing either one, and here's why.

I could not find either figure on any of OpenAI's current limits pages — the Free Tier FAQ, the GPT-5.6 page, the Plus page or the File Uploads FAQ, all checked again on 11 August 2026. (A 2024 release-note archive does mention two DALL·E 3 images a day for Free, but that model retires on 30 August 2026 and the note describes a product two years gone, so it is not a current limit.) What OpenAI's Free Tier FAQ actually says is: "The following tools can have usage limits separate from the main chat limit: Data analysis with ChatGPT, File and image uploads, Create images in ChatGPT." And elsewhere on the same page: "GPT usage on the Free tier follows the same plan limits as ChatGPT. Advanced functionality, including data analysis, file uploads, and image creation, can have stricter limits than paid plans."

"Can have usage limits" is a deliberate non-answer — and since the August rollout, the main-chat side of the question has dissolved entirely: there is no text-chat cap left to publish.

What makes that interesting is that OpenAI is not generally cagey about numbers. Across its help centre it publishes plenty of hard caps, several of which are in the table above and almost none of which get quoted: 3 file uploads per day on Free, 80 files every 3 hours, 500 MB of Library storage on Free against 100 GB on Pro, 300 messages every three hours for Go users with Think switched on (a figure that changed with the August rollout — it was 10 per 5 hours days earlier), 3,000 GPT-5.5 Thinking requests a week on Business. Those are specific, and they're published.

So the silence is narrow and it's deliberate. The two figures OpenAI declines to state are exactly the two the whole internet quotes: how many messages a free user gets per 5 hours, and how many images per day. Those move with load, which is the obvious reason not to commit to them in writing. A community number that was true for someone in March, in one region, on one account, is not a published limit — and quoting it as one is how bad reference pages get built. We took the same approach when we checked whether the Claude API is free: several vendors have quietly stopped publishing free-tier numbers, and the correct response is to say so.

A few more things I deliberately left out of the table because I couldn't verify them:

Deep Research on Free. OpenAI's FAQ confirms allowances "vary by plan" and points you at an in-product counter. It doesn't state a Free-tier number, so I don't have one. The one useful detail it does give applies to everyone: where a plan has a fixed monthly allowance, "it resets every 30 days from the date of your first use." Not calendar month. If you burned your allowance on the 20th, that's your reset date now, and it drifts.

Connectors and memory on Free. No primary page I could fetch states the Free-tier scope for either. Unconfirmed, so unstated.

Ads. Two OpenAI pages disagree on tense. The ChatGPT Go announcement says OpenAI plans to test ads in the free tier and Go in the US "soon," which reads as pending. The Free Tier FAQ says ads "may appear in the Free tier in certain countries," which reads as already possible somewhere. Whether ads are live for you today is not answerable from OpenAI's published material, and I'm not picking a side.

Two things that are simply gone

People still ask about both, so: Sora is not part of the free ChatGPT product, or the paid one. OpenAI's own page says "The Sora web and app experiences were discontinued on April 26, 2026," with the API following on 24 September 2026. And the DALL·E GPT inside ChatGPT is being retired on 30 August 2026 — the release note advises downloading anything you want to keep before then. That's three weeks from this update, so if you have image history sitting in that GPT, go get it.

The context window caveat

GPT-5.6 Luna's documented context window is 128K, with GPT-5.6 Terra also at 128K and GPT-5.6 Sol at 272K. Important qualifier: that figure is published on the ChatGPT Business plan's models-and-limits page, not on any Free-tier page. Luna is the Free/Go default, so 128K is the model's window — but OpenAI does not state anywhere I could find that the Free plan is entitled to the full 128K in practice. Treat it as a model-level number, not a free-plan guarantee.

When paying actually makes sense

If you're hitting the wall on Free, the one genuinely useful mechanic is that you don't wait it out: OpenAI's FAQ says "if you reach a rate limit on your Free tier account, your usage rates will reset when you update your account to a Plus plan, a Pro plan, or a Business plan." Upgrade mid-block and you're unblocked immediately.

Beyond that the ladder is unusually clean for once. Go at $8 buys you the GPT creator, 25 files per project instead of 5, 4 GB of Library storage instead of 500 MB, and real voice time. Plus at $20 buys the same voice allowance as Go and a Projects cap that OpenAI states as either the same or slightly lower — so the honest case for Plus over Go is model access, usage headroom, and 20 GB of storage against Go's 4 GB. Pro's two rungs share the same core capabilities and differ mainly in allowance, with 100 GB of storage and unlimited live voice at $200. A Standard Business seat at $20 billed annually lands on exactly the same monthly price as Plus with the same 20 GB, which is worth knowing if there are two of you and you assumed the team plan carried a premium. Two caveats if you're buying seats. Business has a two-seat minimum, so $20 a head means $40 a month, not $20. And a second seat type is on the way: OpenAI's Business page now announces that "Premium seats cost $100 per user per month when billed annually, or $125 per user per month when billed monthly," including "5x more usage than Standard seats, no 5-hour usage limit, and the flexibility to mix, assign, and reassign seat types." It has not launched — there is a waitlist, open "before August 20" — so the $25/$20 figures above are Standard-seat prices and remain current. Note the detail hiding in that announcement. Premium promising "no 5-hour usage limit" only means something if Standard seats have one — and OpenAI's Premium seats announcement says it twice more, that Premium "removes the five-hour usage limit" and, in its feature list, "No five-hour usage limit." So across two OpenAI pages the five-hour window is confirmed to exist for Standard seats, and on neither one is it given a number. That is the single clearest example on this page of the pattern I keep running into: OpenAI will confirm a limit exists while declining to say what it is.

For most people asking whether ChatGPT is free, the answer they actually want is "free enough" — and since the August change, for text-only chatting, it plainly is. If your use case is programmatic rather than conversational, that's a different question with a different answer; our free AI APIs roundup covers the metered side, and the tools I actually use daily piece covers what earns a subscription.

The rollout landed, the contradiction resolved, and this page was re-verified against the updated pages on 11 August 2026. The next scheduled re-check is the monthly refresh — sooner if the orphaned "Free tier model limit" sentence gets a definition.

GEO vs SEO: How to Rank in AI Search Engines (2026)

Hirak — Mon, 10 Aug 2026 14:30:00 +0000

SEO got you ranked on Google. GEO gets you cited by AI. In 2026, you need both — and they don't work the same way.

Here's the complete guide to Generative Engine Optimization: what it is, why it matters, and exactly how to do it.

What Is GEO?

GEO (Generative Engine Optimization) is the practice of optimizing your content so AI-powered search engines — ChatGPT, Perplexity, Google AI Overviews, Claude — find it, understand it, and cite it in their responses.

When someone asks Perplexity "what's the best AI code editor in 2026?", Perplexity searches the web, reads multiple sources, synthesizes an answer, and cites its sources. GEO is what determines whether your article becomes one of those cited sources.

GEO vs SEO: What's Different?

Factor	Traditional SEO	GEO
Goal	Rank #1 on Google SERP	Get cited in AI-generated answers
Evaluation	Google's algorithm (links, keywords, authority)	AI model's judgment (relevance, clarity, authority)
Content format	Optimized for scanners (headings, bold, images)	Optimized for extraction (stats, quotes, structured data)
Keywords	Exact match and semantic keywords	Natural language, question-based
Links	Backlinks from high-authority domains	Citations from trusted, recent sources
Freshness	Updated content ranks better	Recent content with dates is strongly preferred
Trust signals	Domain authority, HTTPS, backlinks	Author expertise, first-person experience, citations

The key insight: SEO optimizes for ranking algorithms. GEO optimizes for language models. They overlap but they're not identical.

How AI Search Engines Decide What to Cite

I've studied the citation patterns of Perplexity, ChatGPT Search, and Google AI Overviews. Here's what they consistently favor:

1. Specific Numbers and Statistics

AI models love extractable facts. Compare:

Weak: "AI code editors are popular among developers."
Strong: "47% of professional developers use an AI code editor daily, up from 12% in 2024 (StackOverflow Developer Survey 2026)."

The second version is citable. The first is filler.

2. First-Person Authority

AI models weight first-hand experience. "I tested all 8 AI code editors" is more citable than "there are many AI code editors available." E-E-A-T (Experience, Expertise, Authoritativeness, Trustworthiness) matters even more for AI citations than for Google rankings.

3. Direct Answers to Questions

Structure your content around the exact questions people ask AI:

"What is the best AI code editor?"
"How much does Cursor cost?"
"Is Copilot worth it in 2026?"

Put the answer in the first sentence after the heading. AI models extract from the first 1-2 sentences of a section more than anywhere else.

4. Structured Comparisons

Tables, bullet lists, and comparison formats are extracted at a much higher rate than prose paragraphs. AI models can parse tables directly and use them in responses.

5. Recency Signals

AI search tools heavily prefer recent content. Include:

Publication dates in your content
"Updated April 2026" notices
Year in your title and headings
References to current events or recent data

The GEO Playbook: 10 Tactics That Work

Tactic 1: Add llms.txt to Your Site

llms.txt is a markdown file at your domain root that tells AI models what your site is about, what it offers, and how to cite it. Think robots.txt for AI.

This is the single highest-ROI GEO action you can take. Thirty minutes of work, permanent benefit.

Tactic 2: Use Question-Based Headings

Instead of:

## AI Code Editor Features

Write:

## What Are the Best AI Code Editor Features in 2026?

AI models match user questions to content headings. Question-based headings get extracted more often.

Tactic 3: Lead Every Section with the Answer

The "inverted pyramid" from journalism applies perfectly to GEO. Put the most important information first:

Bad:

There are many factors to consider when choosing an AI code editor. Let me walk you through the history of IDE development...

Good:

Cursor is the best AI code editor for most developers in 2026. It offers the fastest autocomplete, reliable multi-file editing, and costs $20/month.

AI models extract from the first 1-2 sentences. Don't bury the answer.

Tactic 4: Include Comparison Tables

Every article comparing options should have a table. AI models extract table data directly and use it in comparative responses.

Include: name, price, key differentiator, best-for use case, and a rating or recommendation.

Tactic 5: Cite Your Sources

AI models trust content that cites external sources. Link to studies, documentation, official pricing pages, and data sources. Content with citations is perceived as more authoritative than unsourced claims.

Tactic 6: Add Schema Markup (JSON-LD)

Structured data helps AI models understand your page type (article, product, FAQ, how-to) and extract specific fields. At minimum, add:

Article schema with author, datePublished, dateModified
FAQPage schema for question-heavy content
HowTo schema for tutorial content
Product schema for product pages with pricing

Tactic 7: Write for Extraction, Not Just Reading

Every paragraph should contain at least one extractable fact, recommendation, or insight. Fluff paragraphs ("in today's fast-paced world...") are skipped by AI models entirely.

Test: Can an AI extract a useful standalone quote from this paragraph? If not, rewrite it.

Tactic 8: Include Author Credentials

Add an author bio that establishes expertise. "Written by a developer who shipped 12 apps using AI tools" is a trust signal AI models weight when deciding which source to cite.

Tactic 9: Update Regularly and Show It

AI models check dates. A post from 2024 about "best tools in 2026" gets deprioritized. Add updatedDate to your posts and display it visibly. Monthly updates to key articles keep them competitive.

Tactic 10: Cover Adjacent Questions

When someone asks about "best AI code editor," they might also ask about pricing, comparisons, and alternatives. Cover these in your article. AI models prefer comprehensive sources over narrow ones because they can extract more answers from a single citation.

How to Track Your GEO Performance

Manual Testing

Ask AI search engines questions related to your content. Search Perplexity, ChatGPT, and Google AI Overviews for your target queries. See if you're cited.

Do this weekly for your top 10 target queries.

Tools

Perplexity Analytics — Check if your domain appears in Perplexity citations
Google Search Console — AI Overview clicks show in the Performance report
Semrush / Ahrefs — Both added AI citation tracking in 2026

Metrics That Matter

Citation rate: What percentage of relevant AI queries cite your content?
Citation position: Are you the first source cited or the fifth?
Click-through from citations: Do people click your link in the AI response?

SEO Is Not Dead

To be clear: traditional SEO still matters. Google still drives the majority of web traffic. Backlinks, page speed, mobile optimization, and keyword targeting still work.

GEO is additive, not a replacement. The smartest content strategy in 2026:

Write content that ranks on Google (SEO)
Structure it so AI models cite it (GEO)
Add llms.txt for site-level AI optimization
Update regularly to maintain both

The good news: most GEO tactics also improve your SEO. Clear headings, structured data, cited sources, and fresh content help you rank better on Google too.

What to Do This Week

Create your llms.txt file. 30 minutes, massive long-term impact.
Audit your top 5 articles. Do they have question-based headings? Comparison tables? First-sentence answers? Statistics?
Add schema markup to your most important pages.
Test your target queries on Perplexity and ChatGPT. See who's currently getting cited.
Update dates on all your key content. Add updatedDate if you don't have one.

AI search is not the future — it's the present. Every week you wait, competitors are getting cited instead of you.

Keep reading:

Seline Review: A Privacy-First Google Analytics Alternative Worth Watching (2026)

Hirak — Fri, 07 Aug 2026 14:30:03 +0000

Last updated: July 21, 2026.

Most teams don't leave Google Analytics because they found something dramatically better. They leave because GA4 got confusing, the cookie banner got embarrassing, and legal started asking questions about where the data lives. That's the gap a whole category of privacy-first analytics tools grew into, and Seline is one of the newer names in it.

I spent time with it to see whether it's a real option or just another Plausible clone with a different logo. Short version: it's genuinely its own thing, with one caveat worth knowing before you get attached.

What Seline actually is

Seline is a cloud-hosted, cookieless web and product analytics platform. It came out of a small bootstrapped team in Warsaw in 2024, and the whole pitch is built around two ideas: keep the tracking script tiny, and keep the data private and in the EU.

The script is about 2kb. For comparison, Google's tag is heavy enough that people build whole performance budgets around deferring it. Seline's claim is roughly 23x lighter, and while I wouldn't treat any vendor's own number as gospel, the practical effect is real: you add one HTML snippet and you're not paying for it in Lighthouse points. Setup is a copy-paste, with documented paths for Next.js, WordPress, Webflow, Framer, Shopify, Ghost, and Carrd.

Privacy is the other half. There are no cookies. Instead of storing an identifier on the visitor's device, Seline uses non-reversible hashing off signals like IP, browser, and device to recognize sessions. Nothing lives client-side, which is why sites using it generally skip the consent banner. Data sits on servers in Germany, the company is EU-based, and they're explicit that they don't sell or share it. If your reason for leaving GA was a compliance conversation, this is the part that matters.

It goes further than "pretty pageview charts"

This is where Seline separates itself from the minimalist crowd. Plausible and Fathom are deliberately simple: traffic, sources, top pages, done. Seline covers that baseline (page views, referrers, countries, devices, UTMs) but then keeps going into territory that's usually a separate product.

You get custom events for the things that actually matter, like button clicks, form submissions, and signups. You get conversion funnels to see where people drop. You get individual visitor journeys, so you can follow a single session through the site instead of only reading aggregates. There are user profiles with custom attributes, which starts to look more like a lightweight product-analytics tool than a website counter.

The one that caught my attention is revenue tracking. Seline integrates with Stripe, Polar, and Shopify, so you can tie traffic and events to actual money. For a small SaaS or store, being able to answer "which source brought revenue, not just clicks" inside your analytics tool, without wiring up a separate pipeline, is a genuinely useful thing to have.

The AI features, with the hype dialed down

Seline leans into AI, and I'll give it a fair but skeptical read. There's an AI chat assistant that lets you ask questions of your data in plain language and have it generate CSVs, and there's an MCP interface, which means you can point an AI agent at your analytics directly. It also flags referrers from AI tools like ChatGPT, Perplexity, and Claude, which is quietly one of the more forward-looking touches given how much discovery is shifting toward AI answers.

Is any of this going to replace an analyst? No. But "ask a question, get a chart or a CSV" removes a real friction point for founders who know what they want to know but not which dashboard to click. Treat it as a convenience layer, not magic, and it holds up.

Rounding out the list: a live globe view of current visitors, bot detection, and filtering by custom attributes, UTMs, dates, and engagement. The globe is eye candy. The filtering is the part you'll use daily.

The catch: there's no free plan

Now the part you need to know before you get attached. Seline has no free tier. It's a single Pro plan, billed monthly or annually, with annual giving you two months free, and it's scoped around 100,000 page views a month. The team is candid about why: they're bootstrapped and run entirely on subscriber fees, not on a free plan subsidized by selling data. I actually respect the honesty of that positioning, and it's consistent with the privacy story. But it does mean Seline isn't the tool for a hobby project or a portfolio site where you just want a free counter.

I'm not going to quote a dollar figure here because these things change and the price loads dynamically on their site. Check the pricing page for the current number before you budget anything off this post. What matters structurally is the model: one plan, no artificially locked features, pay to play.

Who it's for, and who it isn't

Seline fits you well if you're a small-to-mid SaaS, an indie product, or a store that wants privacy-first analytics but has outgrown "just pageviews." The revenue tracking and event funnels are the draw, and the EU hosting closes the compliance question. If you've been running Plausible and keep wishing it did just a bit more on the product side, this is the natural step up.

It's a weaker fit if you need a free tool, if you specifically want self-hosting (Seline is cloud-only, so an open-source option like Umami serves that better), or if your analytics depend on Google's ad-network integrations. Those are real constraints, not dealbreakers for most people, but know them going in.

Bottom line

Seline is a well-scoped, privacy-first analytics tool that does more than the minimalist crowd without turning into an enterprise monster. The 2kb script and EU hosting handle the two reasons people leave GA4, and the revenue tracking plus AI querying give it a reason to exist beyond "Plausible but different." The no-free-plan decision is the one thing that will filter people out, and it should: this is a paid tool for teams that treat analytics as worth paying for.

If that's you, it's worth a look. Start with your highest-traffic site, wire up one revenue integration, and see if the "money, not just clicks" view changes how you read your traffic. That's the test that tells you whether Seline earns its keep.

Disclosure: This is a sponsored review. Seline paid for a dedicated write-up on stackwrite.com. We only accept sponsorships for tools we're willing to cover honestly, the opinions and the caveats here are our own, and outbound links to the sponsor are marked as sponsored.

How to Count Down to a Specific Time on iPhone (Not Just Days) in 2026

Hirak — Wed, 05 Aug 2026 14:30:02 +0000

You set up an iPhone reminder for your flight, your wedding, a product launch — and what you actually want is a visible countdown ticking down to that moment. Not a notification five minutes before. Not a "tomorrow" badge. A real countdown: days, hours, minutes, ticking.

Turns out iOS doesn't ship with anything that does this. Three Apple apps almost do it, and each one falls short in a frustrating way. Here's why, and how to set up an actual iPhone countdown to a specific time in about a minute.

Why Apple's built-in apps don't do this

Calendar is the obvious place to look. You create an event for "Flight to Tokyo, August 15, 2:30 PM" and Calendar shows it on the date grid. It'll even pop a notification when it's close. What it doesn't do is show you a live countdown anywhere — no widget, no Lock Screen view, no "2 days, 4 hours, 17 minutes" anywhere on your phone.

Clock app → Timer counts down. But only from a duration. Set it to 23 hours 59 minutes (the max) and that's the longest countdown it'll do. Close the app, and it keeps running, sure. But it can't count to a specific date. If your event is six weeks away, the Timer is useless.

Reminders is even worse for this. It's a checklist with optional notifications. No countdown view at all.

So the gap is real: Apple has timers (count from a duration) and event reminders (notify near the date), but no countdown to a specific moment. That's a third-party problem.

What you actually need from a countdown app

If you're going to install one app for this, these are the features that matter:

Event date AND time — not just the date. A countdown to "August 15" rounds to midnight, which is wrong if your flight is at 2:30 PM.
Live updates — the countdown should refresh on its own, not just show "in 3 days" forever. Ideally ticking down to the second.
Lock Screen widget — so you don't have to open the app to see it.
Dynamic Island support (iPhone 14 Pro and newer) — for the live ticking experience.
Widget on the Home Screen — at least medium-size, so the time fits.

Bonus features that some apps have and most don't:

Apple Watch app so the countdown is on your wrist
Multiple events visible at once (most apps make you switch)
Counting up for past events (anniversaries, recovery milestones)

Most of the App Store's countdown apps handle #1 and #2 but skip Dynamic Island or charge for it. A few do the whole stack.

The apps that do it properly

I've tested a stack of these for the best countdown apps for iPhone in 2026 roundup. For "countdown to a specific hour and minute, ticking live, visible everywhere" — three are worth installing.

DayDrop

My own app — I built it, so treat this entry as the developer describing what it does rather than an
independent pick. Ticks down to the exact second on the Lock Screen and in the Dynamic Island. Apple Watch app too, with the background image synced from your phone. Free tier supports unlimited countdowns, Small and Medium widgets and photo backgrounds. Paid unlocks the Live Activity ring, Dynamic Island, multi-event widget, exact-time countdown and AI backgrounds — $1.99/month, $12.99/year (one month free), or $24.99 once. Requires iOS 18.0 or later. (Verified 6 August 2026.)

The thing that sells it for this specific use case is the Live Activity Progress Ring. You see the seconds tick down on your Lock Screen, and the Dynamic Island shows the same countdown when the screen's on. For a flight or a wedding, you're glancing at your phone constantly, and the answer is always one glance away.

Get DayDrop on the App Store

Countdown+

Solid widgets, supports specific-time events, no Dynamic Island. Free, ad-supported. Good if you don't have a Pro model iPhone and only need a Lock Screen widget.

Widgetsmith

Not a dedicated countdown app, but the "Countdown to Date" widget supports time-of-day if you tap into the custom settings. Limited customization on the free tier and no live tick — it updates roughly every 15 minutes. Works if you already have Widgetsmith installed for other widgets.

There are a dozen others. Most of them are date-only or stop updating once they're more than 24 hours away.

Setting it up — the short version

Pick an app from above. I'll walk through DayDrop because it's the one that does the full stack; the principle is the same for the others.

Open the app, tap + to add an event.
Type a title — "Flight to Tokyo" — and toggle on Specific time. Set the date and the exact hour and minute.
Pick a category if you want it grouped (Travel, Work, Birthday, etc.).
Tap Save. The countdown is now live.

That gets you the countdown inside the app. To make it visible without opening the app, you have two paths:

Path A — Lock Screen widget

Long-press your Lock Screen → Customize → Lock Screen
Tap the widget area below the clock → Add Widgets
Find the countdown app, pick the inline or circular widget, tap it
It now sits on your Lock Screen showing the live count

Path B — Home Screen widget + Dynamic Island

Long-press an empty part of your Home Screen → tap + in the corner
Find the countdown app and pick a widget size (medium fits the time best)
Place it and pin your event
For Dynamic Island, open the event inside the app and toggle Live Activity on (DayDrop calls this "Pin to Dynamic Island"). The countdown will now show in the Dynamic Island for the next 8 hours by default, and you can extend it.

If you set up the Live Activity, the countdown ticks live in real time when the Lock Screen or Dynamic Island is visible. You don't open anything. You just glance and it's there.

Edge cases that trip people up

Time zones. If you're counting down to a flight in another time zone, decide whether the countdown should be based on your local time or the destination. Most apps store events in your device's local time, which is usually what you want — your departure is in your local clock. But for a wedding or product launch in another city, you might want it the other way. DayDrop and Countdown+ both let you set per-event time zones; Widgetsmith doesn't.

Past events. When the countdown hits zero, what happens? Better apps switch to counting up so you can use the same event for "days since." Cheaper ones just show "0 days" forever or hide the widget.

Recurring events. Birthdays, anniversaries, annual deadlines. If you want the countdown to roll over to next year automatically, check that the app supports a recurring/annual flag before you build out a list of 30 birthdays. DayDrop's birthday import handles this; some others require manually editing each one.

Battery. Live Activities are designed to be efficient — they sip battery, they don't drain it. If a Live Activity is killing your battery, the app is doing something wrong, not Apple. Live Activities have a hard 12-hour ceiling on the Lock Screen anyway, after which they fall back to a static notification.

When you don't need an app at all

Honestly: if your event is within 24 hours and you just need "wake me at 6 AM tomorrow," use the Clock app's Alarm. Or for "remind me an hour before the meeting," use the Calendar event's default alert. The countdown app is for events that are days, weeks, or months out and where you want it on your face the whole time.

The bottom line

iOS doesn't ship with a real countdown to a specific moment. That's the gap, and it's been the gap for the better part of a decade. A handful of third-party apps fill it well — DayDrop is the most complete for live ticking across the Lock Screen, Dynamic Island, and Apple Watch. Countdown+ is fine if you don't have a Pro phone. Widgetsmith works if you've already paid for it.

Set one of them up once and the wedding, the vacation, the launch — they all live one glance away from now until they happen.

If you want the full breakdown of the apps in this space, the countdown apps for iPhone roundup is the deeper version of this post, and the Dynamic Island countdown guide goes into the Live Activity setup in more detail.

Claude Code vs Codex CLI: Which Terminal Coding Agent Wins in 2026?

Hirak — Mon, 03 Aug 2026 14:30:02 +0000

Two terminal coding agents, one decision. Claude Code from Anthropic, Codex CLI from OpenAI. If you just want the answer: go with Claude Code if you care about the richest tooling ecosystem and strong multi-file refactoring; go with Codex CLI if you're already paying OpenAI and want a single bill, or you want an open-source agent you can read and fork. Both do the core job well, so this is mostly about which world you'd rather live in.

A note on scope first. Both of these run in your terminal, read your codebase, edit files, and run commands. Neither is an editor plugin. If what you actually want is AI inside VS Code, that's a different question, and we cover it in the Claude Code vs Cursor vs Copilot comparison. This post is the two big terminal agents, head to head.

The short version

Pick Claude Code if you do heavy multi-file refactors and want the most tooling around the agent. Pick Codex CLI if you're already on a ChatGPT or OpenAI API plan and don't want a second AI subscription, or if you specifically want an open-source tool you can audit or self-host. If you're a team that runs hooks, MCP servers, and subagent workflows, that's Claude Code territory. And if you're just trying a terminal agent for the first time on a side project, honestly, start with whichever ecosystem you already pay for — both are good enough to learn on.

Everything below is "as of 2026." Both tools ship updates almost weekly, so confirm pricing, rate limits, and model availability on the official docs before you commit.

What each one actually is

Claude Code is Anthropic's agentic CLI. You run it in your terminal inside a repo, describe a task, and it plans, edits files across the project, runs your build and tests, and iterates until it's done. It runs on Claude models, and you authenticate either with a Claude Pro or Max subscription or an Anthropic API key.

What sets it apart in 2026 is everything around it. MCP support, so you can connect Model Context Protocol servers for databases, browsers, issue trackers, docs, whatever. Subagents, so you can spin up scoped helpers and keep the main thread focused. Hooks, so you can run your own shell commands at lifecycle points — before edits, after tool calls, on stop. Slash commands you check into the repo and share with the team. There's also a sizable community building configs and plugins on top of all that. If you've never gone past the basics, our Claude Code tips and tricks post is a decent next stop. (New to MCP entirely? Start with how MCP servers work.)

Codex CLI is OpenAI's open-source terminal coding agent. It runs locally, reads and edits your repo, and runs commands — the same core loop. It runs on OpenAI's coding-focused models, and you authenticate with an OpenAI API key or a ChatGPT plan that includes Codex usage.

The headline difference is right there in the description: it's open source. You can read exactly what it does, look at how it sandboxes commands, file issues against it, and fork it if you want a custom build. It's also a lighter footprint — fewer moving parts than Claude Code's full plugin/hook/subagent stack. The flip side is that the ecosystem around it is younger. You won't find the same pile of community MCP integrations and shared workflows yet.

(Worth saying: OpenAI has used the name "Codex" for a few different things over the years — the old code model, a cloud agent, the CLI. This post is about the command-line tool specifically.)

Side by side

	Claude Code	Codex CLI
Pricing	Claude Pro / Max subscription, or Anthropic API key (usage-based)	OpenAI API key (usage-based), or a ChatGPT plan that includes Codex
Models	Claude family	OpenAI's coding models
Open source?	No, closed client	Yes, you can read and fork it
IDE integration	Terminal-first; companion editor integrations exist	Terminal-first
Extensibility	First-class MCP, subagents, hooks, slash commands, plugins	More minimal, growing — check the repo for the current state
Sandboxing / approval	Permission prompts before edits and commands; configurable allow-lists	Approval/sandbox modes for read-only, edit, and full-auto runs
Multi-file editing	Widely praised for whole-codebase refactors	Solid multi-file edits; capable agent loop
Ecosystem maturity	More mature; big community, lots of tooling	Younger but moving fast, backed by OpenAI
Best for	Complex refactors, team workflows, MCP-heavy setups	OpenAI-ecosystem devs, one-bill simplicity, auditability

Treat that as a starting point, not gospel. Both products change fast, and the rows most likely to move are pricing, model names, and extensibility.

Where Claude Code pulls ahead

Ecosystem depth, mainly. This is the biggest gap right now. MCP servers, subagents, hooks, slash commands — Claude Code has all of it, and there's a real community building on top. If your workflow involves wiring an agent into your database, your issue tracker, your docs, and your CI, Claude Code arrives with more batteries included.

Multi-file refactors are the other one. Across developer chatter in 2026, Claude Code is the tool people reach for when a change touches a model, a service, three routes, and a UI component all at once. It tends to read project structure, test patterns, and naming conventions well, and apply changes coherently across the tree. It's the same strength that lands it near the top of broader roundups like our best AI code editors comparison.

And the everyday ergonomics are smooth — the permission model, the diff display, session handling, project-checked-in commands. It feels like a product that's been through a lot of iterations, because it has.

What you give up: you're on Anthropic's pricing and subscription model. If you're not already paying for Claude Pro or Max, that's a new line item. And it's closed source, so you can't inspect or fork the client.

Where Codex CLI pulls ahead

It's open source, and for some people that settles it. You can read the code, see how it sandboxes commands, audit it for a security review, contribute fixes, fork it for an internal build. For teams with compliance requirements — or developers who just don't love a black box running loose in their repo — that matters a lot.

It's also one account, one bill. If you're already paying OpenAI for ChatGPT or running on an OpenAI API key, Codex CLI slots in with no new billing relationship. For a lot of people that's the whole decision: they don't want a second AI subscription, full stop.

And it's lighter. Fewer concepts to learn — no hooks, subagents, or plugin layer to wrap your head around. You point it at a repo and go. For a side project or a quick task, that simplicity is a feature.

What you give up: the younger ecosystem. Fewer community MCP integrations, fewer shared workflows, less of a "here's the config everyone uses" culture, at least for now. And it's only as good as OpenAI's coding models, which are strong, but you're betting on their roadmap.

If you want to widen the field beyond these two, Aider is another terminal-leaning agent worth a look, and our roundup of AI tools developers actually use in 2026 puts all of them in context.

So which should you pick?

Match yourself to the situation:

You do heavy multi-file refactors and want the richest tooling — Claude Code. The MCP/subagent/hook ecosystem plus its refactoring track record make it the default for serious codebase work.

You already pay for ChatGPT or run on an OpenAI API key and want one bill — Codex CLI. No new subscription, no new billing relationship, good models.

You want an open-source agent you can audit, contribute to, or fork — Codex CLI. It's the only one of the two you can actually read.

You're a team that wants hooks, MCP, and subagent workflows — Claude Code. It's built for that, and the community has worn the paths.

You're trying terminal agents for the first time on a side project — start with whichever ecosystem you already live in. Got Claude Pro or Max? Use Claude Code. Got a ChatGPT plan? Use Codex CLI. Both are good enough to learn the workflow on, and switching later costs you almost nothing.

If you forced me to give one blanket answer for "most developers, most of the time, doing real work," I'd say Claude Code, because of the ecosystem and the refactoring strength. But "I already pay OpenAI and don't want another bill" is a perfectly good reason to land on Codex CLI, and you won't be missing the core agent loop — just some of the surrounding tooling.

Can you run both?

Sure, and plenty of people do. They're both just CLIs you run inside a repo; nothing stops you from keeping both installed and picking per task. A common pattern in 2026: Codex CLI for quick, scoped jobs when you're already in an OpenAI-flavored headspace or want the lighter tool, and Claude Code for the gnarly multi-file refactor or the long debugging session or anything that benefits from MCP servers and subagents. You can point both at the same repo on the same day. They don't conflict — they're two terminals. And if you want a model "second opinion" on a tricky change, running the same task through both and diffing the results is genuinely useful.

Quick FAQ

Is Codex CLI free? The tool is free and open source. You pay for model usage via an OpenAI API key or a ChatGPT plan that includes Codex. Current limits are on OpenAI's pricing page.

Is Codex CLI open source? Yes. OpenAI ships it as an open-source project you can read and fork. Claude Code is closed source.

Is Claude Code better than Codex CLI? For multi-file refactors and the richest tooling — MCP, subagents, hooks, slash commands — yes, in 2026. Codex CLI wins on open-source auditability and single-bill simplicity if you're already on OpenAI.

Can Codex CLI edit multiple files? Yes. It reads the repo, plans, edits multiple files, and runs commands, asking for approval based on your sandbox settings.

Which one costs less? Depends entirely on your usage and which plan you're on. Both can run usage-based off an API key or be bundled into a subscription. Run a real week of work through each and compare your actual bill — the marketing numbers won't match your workload.

Still weighing terminal agents against editor-based tools like Cursor and Copilot? Read the Claude Code vs Cursor vs GitHub Copilot comparison next — it puts all three on the same project with real numbers. More head-to-heads in the AI Tools category.

Cursor vs Aider: Which One for a Python Monorepo? (2026)

Hirak — Fri, 31 Jul 2026 14:30:02 +0000

Last updated: May 12, 2026.

You're in a big Python monorepo, and you're deciding between Cursor — the AI-first code editor — and Aider — the open-source terminal pair programmer that drives every change through git. Quick answer: Cursor if you want an all-in-one editor with great autocomplete and a GUI for reviewing multi-file diffs; Aider if you want to keep PyCharm or Vim, control exactly which files are in context, get every change as a reviewable git commit, and choose your own model to keep costs down. Both genuinely work in a monorepo. The decision is about how you want to work, not whether it's possible.

The short version

Want a polished all-in-one editor and you're fine switching IDEs? Cursor. Live in PyCharm or Vim and won't switch — or want bring-your-own-model with a git commit per change and direct cost control? Aider. Doing big agentic multi-file refactors and want a GUI to eyeball the diff before accepting? Cursor. Want an open-source tool you can script into CI or run headless? Aider. On a tight budget with your own cheap API key? Aider. Standardizing a team on one tool with easy onboarding? Cursor.

Everything below is "as of 2026," and both tools move quickly, so verify pricing and current features on their docs.

Cursor and Aider, one line each

Cursor is an AI-first code editor built on VS Code. You get Tab autocomplete that's genuinely good, a chat sidebar, codebase indexing so it "knows" your repo, and Composer/agent mode for multi-file edits. It's a subscription product with a free tier, and it uses frontier models under the hood — you mostly don't think about which one.

Aider is an open-source command-line AI pair programmer. You run it in your repo; it edits files and makes a git commit for each change it applies; it's model-agnostic, so you bring your own API key — Claude, GPT, whatever — and it works alongside the editor you already use. Its signature feature is the repo map: a compact, structural summary of your codebase that it feeds the model, so it has architectural awareness without loading every file. People who want a tight, auditable git workflow tend to love it.

Why the monorepo matters

In a small repo, "which AI tool" is mostly taste. In a monorepo with thousands of files across dozens of packages, real constraints show up. No model holds your whole repo, so both tools need a strategy for what to load, and you need to be deliberate about scoping to the package or files that matter. Cross-package changes — the kind that touch libs/auth and three services that import it — are where multi-file editing quality actually gets tested. Cursor indexes the codebase, which on a huge repo is a one-time cost plus ongoing maintenance; Aider's repo map is lighter, but you're more hands-on about which files you /add. And your tool has to play nicely with the monorepo plumbing — Bazel, Pants, uv workspaces, Poetry, pre-commit hooks, a CI that only runs affected targets — or at least not fight it.

So the question isn't "can it handle a monorepo." Both can. It's "which workflow do I want once the repo is too big to fit in the model's head."

Side by side

	Cursor	Aider
Interface	Full AI code editor (VS Code fork)	Command line, runs in a terminal
Open source?	No	Yes — open source, scriptable
Model choice	Frontier models under the hood; you mostly don't pick	Bring your own API key — Claude, GPT, etc.; you choose
Cost model	Subscription (free tier available)	Free tool plus your own model usage costs
Large-codebase handling	Codebase indexing; scope it on huge packages	Repo map for structure, plus the files you `/add`
Git integration	Standard editor git; you commit	A git commit per change, automatically — easy to review or revert
Multi-file edits	Composer/agent mode, GUI diff review	Edits multiple files; changes land as commits
Autocomplete	Strong Tab completion	Not its focus — it pairs on changes, not inline completion
Works with your existing editor?	No — Cursor is the editor	Yes — runs alongside PyCharm, Vim, VS Code
Learning curve	Low — it's VS Code plus AI	Moderate — CLI workflow, you manage context
Best for	All-in-one experience, autocomplete, GUI diff review, teams	Editor-agnostic devs, cost control, git-tracked changes, scripting/CI

Starting point, not gospel — both ship updates constantly, and the lines most likely to move are pricing, model availability, and the exact monorepo features.

Cursor in a Python monorepo

Cursor's pitch in a big repo is "the editor already knows your code." The codebase indexing means when you ask "where do we validate JWTs," it can find it without you pointing the way, and Composer/agent mode can make a coordinated change across several files and show you a diff to accept or reject in the GUI. If you want one window — editing, AI chat, autocomplete, diff review — and you're happy to switch IDEs, it's a smooth experience. The Tab autocomplete alone is a real bump in Python; it's good at finishing the obvious line.

The thing to keep an eye on is context limits on very large packages. Let it try to reason about a package with hundreds of files and you'll hit the ceiling and get worse results. The fix is the same as with any AI tool: scope it. Open the package you're working in, point Composer at the specific files or directory, and don't ask it to hold the whole monorepo in mind. And remember the index is something you maintain on a repo that changes a lot — exclude generated directories and build artifacts so it stays useful. If you're weighing Cursor against other editors more broadly, our best AI code editors comparison covers the field, and Cursor vs VS Code is the head-to-head for "should I leave plain VS Code at all."

Aider in a Python monorepo

Aider's pitch is control. You decide which files are in context — you /add path/to/file.py for the ones in play — and the repo map gives the model enough structural awareness of everything else to make sensible choices. In a monorepo that's a feature, not a chore. You're never wondering whether the tool quietly pulled in half the repo and torched the context budget, because you put the files there yourself.

Two things make it especially good for a disciplined monorepo workflow. One: a git commit per change. Every edit Aider applies becomes its own commit with a generated message, which means reviewing the AI's work is just git log, git diff, git revert — the same workflow you already use for code review, applied to the AI. On a big repo where you're careful about what lands, that's reassuring. Two: bring your own model. You pick it and pay for it directly. Want the cheap fast model for boilerplate and the expensive one for the gnarly refactor? You're in charge. On a tight budget with your own API key, Aider is the cost-control option, and it pairs naturally with the cheap-usage notes in our free AI coding tools roundup.

Because it's a CLI that runs next to your editor, PyCharm and Vim users don't have to give up their IDE — Aider just edits files and commits, and your editor sees the changes show up. It's also scriptable, so you can wire it into CI or run it headless for batch refactors. The tradeoff: it leans power-user. You manage context, you live in the terminal, and there's no inline autocomplete — Aider is for making changes, not finishing your lines. If you want to see where it sits relative to the assistants, Aider vs GitHub Copilot is the comparison.

So which should you pick?

Match the situation.

You want a polished all-in-one editor with great autocomplete, and switching IDEs is fine — Cursor. It's VS Code with AI baked in; the indexing helps it navigate the monorepo, and Composer handles multi-file changes with a GUI diff.

You live in PyCharm or Vim and won't switch — or you want bring-your-own-model, a git commit per change, and direct cost control — Aider. Keep your editor, control context, review changes as commits, pick your model.

You're doing big agentic multi-file refactors and want to see the whole diff in a GUI before accepting — Cursor. The diff-review UX is the draw there.

You want an open-source tool you can script into CI, run headless, or audit — Aider. It's the only one of the two you can do that with.

You're on a tight budget with your own cheap API key — Aider. No subscription; you pay only for the model tokens you use.

You're a team picking one tool with easy onboarding — Cursor. "It's VS Code, but smarter" is a five-minute pitch; Aider's CLI workflow takes more ramp-up.

If I had to give one default for "an experienced dev working solo in a large Python monorepo who cares about reviewing what the AI did," I'd say Aider, because the commit-per-change workflow and explicit context control fit a big repo's discipline so well. But "I want one window and great autocomplete and I'll happily use Cursor as my editor" is a perfectly good reason to pick Cursor — and a team will almost always onboard faster on it. For the bigger picture across all the AI coding tools, our Claude Code vs Cursor vs Copilot comparison and the roundup of AI tools developers actually use in 2026 are the next reads.

Tips for either tool in a big repo

Whichever you land on, a monorepo rewards discipline. Scope to one package or a handful of files — don't ask the tool to reason about the whole repo at once, you'll hit context limits and get worse output. Keep a CLAUDE.md or conventions file at the repo root, and per-package if needed, so the tool doesn't re-derive your patterns every session. Exclude generated and vendored directories from the index or repo map — build outputs, node_modules, generated protobufs are just noise. Use the tool's ignore file (Cursor's index ignore, Aider's .aiderignore) the way you'd use .gitignore. Review every diff — AI changes in a shared monorepo are exactly where you want a human in the loop; Aider's per-change commits make this trivial, and in Cursor you should actually read the Composer diff before accepting. And run the affected package's tests after each change — in a monorepo, "it compiles" isn't enough.

TL;DR

Both Cursor and Aider work in a Python monorepo; the choice is workflow, not capability. Cursor is the all-in-one AI editor — strong autocomplete, codebase indexing, GUI diff review, subscription pricing, easiest team onboarding; scope it on huge packages. Aider is the open-source CLI pair programmer — you control which files are in context (repo map for the rest), a git commit per change, bring-your-own-model for cost control, keeps your existing editor, scriptable. Pick Cursor for the polished single-window experience; pick Aider for control, auditability, and cost. Either way: scope to one package, keep a conventions file, exclude generated dirs, review every diff, run the package's tests. And verify pricing and features on the official docs, since both move fast.

Deciding between more than just these two? Claude Code vs Cursor vs GitHub Copilot: Honest 2026 Comparison puts three tools on the same project with real numbers. More head-to-heads in the AI Tools category.

Is the Claude API Free? Real Rate Limits & Costs in 2026

Hirak — Wed, 29 Jul 2026 14:30:03 +0000

Last verified: 6 August 2026, with the Sonnet 5 pricing re-checked on 19 August 2026. Every price and limit below was checked against Anthropic's own pricing and rate-limit docs on those dates. Two things moved since the May version: Opus is no longer the top of the price ladder, and the usage tiers have been renamed. A third has since been corrected — the September rise on Sonnet 5, reported here as scheduled, was cancelled by Anthropic and this page previously said otherwise.

No. The Claude API isn't free, at least not in any ongoing way. New Anthropic Console accounts get a small bit of trial credit to kick the tires, and after that it's pay-as-you-go — you prepay credits and get billed per million tokens. There's no permanent free tier, nothing like the "1,500 requests a day, forever" deals you see on some other APIs. The better news is that it's cheap for light use, and there are a few legitimate ways to keep your bill near zero. Here's how it actually works in 2026.

One disclaimer up front: Anthropic changes pricing and limits from time to time. This post is about the structure — what you're paying for, how the rate limits scale — not about exact dollar figures. Always confirm current prices on Anthropic's pricing and docs pages before you budget anything off it, including this article.

The short answer

Free forever? No. Free to start? Yes — new Console accounts get a one-time-ish trial credit, enough to build a prototype, not enough to run a product. After that, it's pay-as-you-go: prepay credits, billed per million input and output tokens, with the price depending on which model you call.

Is it cheap? For light use, yes. A short completion is a fraction of a cent. For heavy agentic work — big context, long outputs — it adds up fast.

And if what you actually want is "Claude, but flat-rate instead of metered," you probably want a subscription, not the API: Claude Pro/Max, or Claude Code running on it. That's a fixed monthly fee with a usage allotment, which is what a lot of people mean when they search "is the Claude API free."

What "free" actually means here

When people ask whether the Claude API is free, they're usually asking one of a few different things. Honest breakdown:

The new-account trial credit. Create an account in the Anthropic Console and you get a small amount of credit to play with. It's real, it's free, and it's the closest thing to a free tier — but it's a one-time grant, not a recurring quota. Treat it as enough to validate an idea, not run one.

Prompt caching and the Batch API. Not "free," but the biggest lever you've got on cost. A cache read costs 10% of the standard input price — 90% off — on the parts of your prompt that repeat across calls: system prompts, long context, few-shot examples. Writing to the cache costs more than a normal input token, 1.25x for the five-minute cache and 2x for the one-hour one, so caching pays for itself after a single read on the five-minute tier. The Batch API is exactly 50% off both input and output for asynchronous work. The two discounts stack, per Anthropic's own docs, so a batched job hitting a warm cache is paying a fraction of list. (We get into cross-provider cost-cutting in our free AI APIs for developers roundup.)

A subscription instead of the API. If your use case is interactive — chatting with Claude, coding with Claude Code — you probably don't want the API at all. Claude Pro is $17/month billed annually or $20/month billed monthly; Claude Max starts at $100/month for either 5x or 20x Pro's usage. Claude Code runs on that subscription (or on an API key, your call). Worth knowing that Anthropic announced a change to how Agent SDK usage is billed against subscriptions and then paused it on 15 June 2026 — as of this check, claude -p, the Agent SDK and third-party apps still draw from your subscription allotment rather than metered API billing. That's an area they've been actively tinkering with, so it's not guaranteed to stay. For a solo dev doing day-to-day work, the subscription usually beats metering every token. This is genuinely the answer for most people asking "is it free": it isn't, but it's flat, which feels close enough.

Claude through a cloud marketplace. You can call Claude via AWS Bedrock, Google Cloud Vertex AI, and similar. Still metered usage — but if you're a new cloud customer, your provider's signup credits may apply, which is effectively free Claude until those run out.

Student and startup credit programs. Where they exist, accelerator and education programs sometimes bundle Anthropic credits. Worth checking if you qualify. Don't build a business plan on it.

What you won't find is a "use it free up to N requests a day, forever" tier. That's not how Anthropic prices the API.

How the pricing works

Three things decide what a call costs.

First, which model you pick. Here are the current per-million-token prices, checked against Anthropic's pricing docs on 6 August 2026:

Model	Input / MTok	Output / MTok
Claude Haiku 4.5	$1	$5
Claude Sonnet 5	$2	$10
Claude Sonnet 4.6	$3	$15
Claude Opus 5	$5	$25
Claude Fable 5	$10	$50

One thing in that table is worth more than the rest of this article. Sonnet 5 launched at $2/$10 as introductory pricing due to end on 31 August 2026, and a rise to $3/$15 was scheduled for 1 September. That rise has been cancelled: Anthropic's pricing docs now state that the $2/$10 rate "is now the standard price" and that the increase "will not occur". Size a Sonnet budget off $2/$10.

And Opus is no longer the top of the ladder. Claude Fable 5 sits above it at $10/$50, double Opus 5. The May version of this article described a three-rung ladder — Haiku, Sonnet, Opus — and that's now a four-rung one. If you've been assuming Opus is your worst case on cost, it isn't.

The gap between cheapest and priciest is ten times on input and ten times on output. Picking the smallest model that actually does your job is the single biggest budget decision you'll make.

Second, input versus output tokens. You're billed separately for what you send (input) and what Claude generates (output), and output tokens cost more — often several times more. An app that sends a huge prompt and gets a one-line answer back is cheap. An app that sends a small prompt and gets a 2,000-word essay is not.

Third, how much context you send, which is the one that sneaks up on people. Every API call is stateless — there's no server-side memory — so if you're building a chatbot or an agent, you re-send the conversation history (and any retrieved docs, and the system prompt) on every single turn. A 20-turn conversation means turn 20 is paying for ~19 turns of history as input. Agentic coding tools are the extreme version: they shovel file contents, tool outputs, and long instructions into context, which is exactly why a serious coding session costs real money. Context size is the driver. Get a handle on it and the bill drops.

Rough intuition: one short Q&A on a small model is a fraction of a cent. A typical Sonnet request with moderate context is in the cents. A long agentic session with lots of files in context and long generated diffs can be a few dollars. Your actual numbers depend entirely on your workload — the only way to really know is to run a realistic week and look at the dashboard.

Rate limits, explained

Anthropic uses usage tiers. As of August 2026 they're named Evaluation, Start, Build, Scale and Custom — if you've read an older guide referring to "Tier 1" through "Tier 4," that naming is gone. New organisations land in Evaluation, whose limits Anthropic doesn't publish ("limits below the standard limits shown on this page"). Everything above it is documented. For Claude Sonnet 5, per the rate-limits docs:

Tier	Requests/min	Input tokens/min	Output tokens/min	Monthly spend cap
Start	1,000	2,000,000	400,000	$500
Build	5,000	5,000,000	1,000,000	$1,000
Scale	10,000	10,000,000	2,000,000	$200,000

Note the last column, because it surprises people: the Start tier caps you at $500 of API spend per month whether you want the ceiling or not. Limits are also per-model, not one blanket number for your org — Claude Fable 5 runs lower limits at the same tier (1,000 RPM but only 500,000 input tokens/min).

One genuinely useful detail that isn't widely known: cached input doesn't count toward your input-tokens-per-minute limit on any current model. Anthropic's own worked example is a 2,000,000 ITPM limit with an 80% cache hit rate effectively processing 10,000,000 input tokens per minute. If you're rate-limited rather than cost-limited, prompt caching is the fix for both.

You can request increases through the Console if you've got a legitimate need outgrowing the automatic tiering.

What that means in practice: don't load-test from a fresh account, because you'll hit the per-minute caps immediately and conclude the API is "rate-limited" when really you're just on tier one. Build retry-with-backoff from day one — when you do hit a limit, the API tells you, and a well-behaved client backs off rather than hammering. And plan your launch around tiering: if you expect a spike, get your account spending (and aging) ahead of time, or request a limit increase before launch, not the morning of.

Exact rate-limit numbers per tier change, so check the current docs rather than trusting a number you read in a blog post. (Yes, including this one — which is why the date at the top of this page is the date every number on it was last checked.)

Models retire, too, and faster than most people plan for. Claude Opus 4.1 was retired on 5 August 2026, the day before this refresh. Opus 4 and Sonnet 4 went on 15 June 2026; Sonnet 3.7 and Haiku 3.5 on 19 February 2026. Anthropic commits to at least 60 days' notice, and requests to a retired model ID fail outright on the first-party API even where the same model lingers on Bedrock or Google Cloud. If you hardcoded a dated model string a year ago, go and check it.

How to use Claude without burning money

A few habits do most of the work. Turn on prompt caching if any meaningful chunk of your prompt repeats across calls — it's the big, easy win. Run non-urgent work through the Batch API for roughly half off: classification jobs, bulk summarization, overnight processing. Pick the smallest model that works — Haiku-class for extraction, classification, routing; Sonnet for most coding and reasoning; Opus only when the task genuinely needs it. Test down the ladder, not just up. Trim your context — don't re-send the entire conversation when a summary will do, don't dump whole files when a function will do. Set a monthly spend cap in the Console so a runaway loop or a bad deploy can't drain the account. Watch the usage dashboard, especially after you ship something new — costs that surprise you in week one are cheap to fix; costs that surprise you in month three aren't. And for interactive use, lean on a subscription: if you're personally coding with Claude all day, Claude Code on Pro/Max is almost certainly cheaper than the API. Our Claude Code tips post covers getting the most out of it, and the Claude Code vs Cursor vs Copilot comparison puts it next to the alternatives.

API or subscription?

Quick way to decide. If you're building an app or automation that calls Claude programmatically, you need the API — there's no subscription path for that. You'll pay per token; optimize with caching, batching, and model choice. If you're personally coding, chatting, or doing day-to-day work with Claude, get a subscription (Claude Pro/Max, Claude Code). Flat fee, big allotment, no per-token anxiety — and this is what most "is the API free" askers actually want. If you're just prototyping or exploring, start with the new-account trial credit on the API, or the free tier of the Claude consumer app, then decide. And if you're already deep in AWS or Google Cloud, consider Claude via Bedrock or Vertex AI so it rolls into your existing cloud bill, possibly against your cloud credits.

TL;DR

The Claude API isn't free on an ongoing basis. New accounts get a small one-time trial credit; after that it's pay-as-you-go — prepaid credits, billed per million tokens. Cost comes down to model choice times (input plus output tokens) times how much context you send; output costs more than input, and context size is the main driver. Rate limits scale by usage tier — new accounts start low and get promoted automatically as they age and spend — so build backoff/retry and don't load-test from a fresh account. The cheapest way to use it: prompt caching, the Batch API, the smallest model that works, trimmed context, a spend cap, and an eye on the usage dashboard. And if you want flat-rate instead of metered Claude, that's a subscription (Claude Pro/Max, Claude Code), not the API.

Pricing and limits change. Confirm the current numbers on Anthropic's official pages before you budget.

Want the wider view — which AI APIs actually have usable free tiers, and which "free" offers come with a catch? Read Best Free AI APIs for Developers (2026) — With Real Rate Limits. For non-AI freebies, Every Free Credit and Promo Code for Developer Tools is the companion list. More in the AI Tools section.

Claude Code Keeps Running Out of Context — How to Fix It (2026)

Hirak — Mon, 27 Jul 2026 14:30:04 +0000

Last updated: May 12, 2026.

You're halfway through a refactor, three files deep, and Claude Code pops up a "context low" warning. Or worse: it quietly summarizes the conversation and forgets a decision you made twenty minutes ago, so now it's "fixing" the thing you already fixed. It always happens at the wrong moment. Below is why it happens and how to make it stop, ordered by what gives you the most room back the fastest.

Why this keeps happening

Claude Code keeps everything from your session in one place: every message, every file it read, every command's output. On most models that's a window of roughly 200,000 tokens. Sounds enormous until you notice what fills it.

Long conversations are the obvious one. Every exchange stays in there. A two-hour session with a lot of back-and-forth is a lot of tokens.

Big file reads are the sneaky one. Ask Claude to "take a look at the auth module" and it might pull in a 2,000-line file in full. That's gone now, sitting in context for the rest of the session.

Then there's tool output. A complete npm run build log, a giant git diff, an accidental ls of node_modules — all of it lands in context verbatim. MCP servers can be the worst offenders here: a database server that returns 500 rows, or a docs server that hands back an entire API reference page, can blow a hole in your budget in a single call. (If you haven't set any of those up yet, our walkthrough of how MCP servers work covers what they actually do.)

And finally, the logs you paste "just in case." That 400-line stack trace you dropped in? Those are 400 lines Claude is now carrying around.

When the window gets close to full, Claude Code auto-compacts: it summarizes what's happened so far and keeps going with the summary instead of the raw history. Your session survives, which is the point. But summaries lose things. The exact line numbers. The reason you rejected the first approach. The "we agreed to use middleware, not decorators" decision. So the real goal isn't just avoiding a crash — it's staying in control of what Claude actually remembers.

The fixes, fastest first

Here's the short version. The details are below.

What	When you reach for it	Effort
`/clear`	Switching to an unrelated task	Instant
`/compact` with an instruction	Mid-task, need room, want to keep specifics	Instant
One task per session	Always — it's preventative	A habit
Point Claude at exact paths	Every request	A habit
Keep a `CLAUDE.md`	Once per project	10 minutes
Hand big searches to subagents	Heavy exploration	Per task
Quiet down noisy MCP servers	One-time setup	One-time
Don't paste big logs — save to a file	Anytime you'd paste 50+ lines	A habit
`/context` to see what's eating tokens	When the warning surprises you	5 seconds
The 1M-token window	Genuinely huge codebases, last resort	Plan-dependent

`/clear` between unrelated things

You just finished the login bug. Now you're starting on the CSV export. Type /clear. It dumps the conversation and gives you a full window again. There is no reason to drag login-debugging history into export work. Honestly, most "I keep running out of context" complaints are really "I never cleared between three different jobs." This is the habit that fixes it.

`/compact`, and tell it what to keep

When you're still in the middle of something and just need breathing room, /compact it. Left alone, it summarizes the whole conversation and continues. Better to give it a hint:

/compact keep the auth refactor details — which files changed, the new token flow, and the decision to use middleware not decorators

That instruction steers what survives. Without it, Claude decides what's important. With it, you do. Reach for /compact when you need continuity, /clear when you don't.

One task per session

A session that starts as "fix this failing test" and grows into "also refactor the API client, oh and update the docs, and let's talk about the deploy pipeline" is going to run out of room — and the work gets worse on the way down, too. One session, one task. Done? /clear. If you want to carry something forward, ask for an end-of-session summary (there's a pattern for this in our Claude Code tips post) and paste it as the first message of the next session.

Be specific so it reads less

"Fix the bug in the checkout flow" sends Claude exploring: it reads the cart component, the checkout component, the payment service, the order model, probably three of them in full. "In src/checkout/PaymentForm.tsx, validateCard rejects valid Amex numbers — the regex is too strict" gets it to read one function. Same fix, a fraction of the tokens. Whenever you know the path and the symbol, say so.

A `CLAUDE.md` so it doesn't re-learn your project every time

Drop a CLAUDE.md in the repo root with your conventions, a quick architecture note, and your "always do X" rules. Claude reads it automatically at the start of every session, so it doesn't have to go spelunking to discover that you use Swift 6 concurrency or that tests live under Tests/. You pay for that context once, cheaply, instead of re-burning it every session. The 17 Claude Code tips post goes into what's worth putting in there.

Push big searches to a subagent

"Find every place we still call the legacy auth endpoint" is exactly the kind of noisy, file-heavy job that doesn't belong in your main context. Hand it to a subagent via the Task tool. The subagent does the grepping and reading in its own throwaway window and comes back with just the answer. Your session stays lean. Works the same for "audit all our error handling" or "list every component importing this deprecated module."

Turn down the chatty MCP servers

MCP servers are great, but a verbose one is a tax you pay on every call. If your database server returns 200 columns when you wanted three, fix the query. If you've got a docs server, a Jira server, a Slack server, and a Postgres server all loaded but you're only touching one today, disable the rest for this session. Some servers let you cap result size — do it. Our best MCP servers roundup flags which ones behave themselves about output.

Don't paste the whole log

Pasting a 600-line build log puts all 600 lines in context, permanently. Instead, send it to a file (npm run build &> build.log) and tell Claude "the build failed — read the last 40 lines of build.log." Or filter it before it ever reaches the chat: npm test 2>&1 | grep -A5 -i fail. Claude Code reads your terminal output natively anyway, so even just running the failing command and letting it pick up the tail beats copy-pasting the lot.

`/context` when the warning blindsides you

If the warning shows up earlier than you expected, run /context (and keep an eye on the context indicator in the status line). It shows you how the window is carved up: system prompt, CLAUDE.md, MCP tool definitions, conversation, file reads. Usually the culprit is obvious — one enormous file read, or a stack of MCP servers whose tool schemas alone are eating 15K tokens before you've said a word. /cost is worth a glance too; token spend and context pressure tend to track each other.

The 1M-token window — it exists, don't lean on it

Some Claude models and plans offer a 1M-token context window. It's real and it genuinely helps with large codebases. But it costs more per token, the model can still get a bit lost in the middle of a giant context, and it does nothing about the underlying habit of letting sessions sprawl. Treat it as headroom for a hard problem, not as permission to skip everything above.

/clear vs /compact, in one table

	`/clear`	`/compact`
What it does	Wipes the conversation; full fresh window	Summarizes the conversation; continues from the summary
What you keep	Nothing. Clean slate.	The gist. Specifics can vanish.
Use it when	Starting something unrelated	Mid-task, low on room, want to keep going
Can you steer it?	No	Yes — `/compact <what to keep>`
The risk	Clearing too eagerly and losing useful context	The summary drops a detail you needed

If you remember one thing: different task, /clear; same task, no room, /compact with an instruction. And if you're about to do something where you'll definitely want the earlier detail, write it down somewhere first.

When auto-compaction bites you

Auto-compaction is fine when what you need going forward is the gist. "Keep building the feature we've been working on" survives it without trouble. Where it hurts is when you need precise earlier detail: the exact diff from step two, the reason approach A was a dead end, the line numbers you were about to touch. A summary papers over those.

So before it triggers — you'll usually get the warning, or you can watch the indicator creep up — checkpoint the stuff that matters. Ask Claude: "Summarize what we've changed so far, every file modified with a one-line note, plus the key decisions, and write it to NOTES.md." Or drop the decisions straight into CLAUDE.md ("auth is middleware-based, not decorators"). Then clear or compact freely, because the record that matters is on disk now, not at the mercy of a summarizer. Treat the context window like RAM, not storage. Anything you'd hate to lose, write it down.

TL;DR

The context window is finite — around 200K tokens, 1M on some tiers — and Claude Code auto-compacts when it fills, which is lossy. Different task: /clear. Same task, out of room: /compact <what to keep>. To stop hitting it at all: be specific about file paths, keep one task per session, maintain a CLAUDE.md, push big searches to subagents, quiet down noisy MCP servers, and never paste a log you could've grepped first. Use /context to see what's eating tokens. And checkpoint important state to a file before auto-compaction hits.

One caveat: slash commands and limits move between Claude Code versions, so if /compact or /context behaves differently than what's here, run /help for your version's current list.

If you're also wondering whether a different tool handles long sessions better, our Claude Code vs Cursor vs Copilot comparison gets into how each one deals with context.

Want more out of Claude Code than just "stop running out of context"? 17 Claude Code Tips That 10x Your Productivity covers the CLAUDE.md patterns, subagent tricks, and custom slash commands — the same habits that keep your context lean in the first place. More in the AI Tools section.

Free AI Coding Tools in 2026 — 10 Genuinely Free Options (No Credit Card)

Hirak — Fri, 24 Jul 2026 14:30:07 +0000

Last updated: April 24, 2026.

Paid AI coding tools cost $20–$40 per month, per seat. For solo devs and small teams, that adds up fast. The good news: 10 tools give you genuinely useful free access in 2026 — without a credit card, without a 14-day trial, without "free for the first 500 requests."

The bad news: "free" means different things across these tools. Some are truly free forever (open source). Some have free tiers that will let you build real projects. Others give you just enough to kick the tires before making you pay.

Here's the honest breakdown.

The truly free forever options

These are open source or have permanent free tiers that aren't going anywhere.

1. Continue.dev (open source, free forever)

Continue is an open-source AI coding extension for VS Code and JetBrains. You bring your own model — it supports Claude, OpenAI, Gemini, and local models via Ollama. If you use local models, the tool itself is free and you pay nothing for inference.

Catch: Setup takes 10 minutes. Local models are noticeably slower and less capable than Claude Sonnet 4.6 or GPT-5. For serious work, plug in an API key.

Best for: Developers who want full control and no vendor lock-in.

2. Aider + Ollama (CLI, open source)

Aider is a terminal-based AI pair programmer. It reads your whole codebase, edits files, and commits changes. Pair it with Ollama running a local model like qwen2.5-coder:32b and the whole stack is free — no API bills, no rate limits.

Catch: Local inference needs a decent GPU (16GB+ VRAM for a 32B model). Slower than cloud models. Works best as a supplement to one of the hosted tools, not a full replacement.

Best for: Terminal-first developers and anyone paranoid about code leaving their machine.

3. Windsurf (free tier)

Codeium rebranded to Windsurf in 2024 and kept a genuinely useful free tier: unlimited autocomplete, 5 "premium" model requests per month, and unlimited basic chat. That's enough for a solo developer to ship real work.

Catch: Premium models (Claude Sonnet, GPT-4.1) are capped. For agentic, multi-file edits you'll hit the 5/month limit fast.

Best for: Individual developers who want tab-completion to feel magical without paying.

4. Cody (Sourcegraph, free tier)

Cody's free tier gives you 500 autocompletions per month and 20 chat messages. It's tightly integrated with Sourcegraph's code search, which matters more as your codebase grows.

Catch: 20 chats/month runs out in an afternoon. Good for light use, not primary driver.

Best for: Developers working in large monorepos.

5. Tabnine (free tier)

Tabnine's free tier is dated but still useful: basic autocompletions trained on permissive open-source code. No cloud calls, runs locally. Zero privacy concerns.

Catch: The free model is noticeably weaker than Claude or Copilot. Good for snippets, weak for reasoning.

Best for: Privacy-sensitive developers and people who want offline support.

The generous free tiers (you can actually ship with these)

These require a credit card only if you want to upgrade — the free tier is real.

6. GitHub Copilot (free tier, launched Dec 2024)

As of late 2024, GitHub rolled out a free Copilot tier for everyone: 2,000 code completions and 50 chat messages per month. Plus, if you're a verified student, teacher, or maintainer of a popular open-source project, you get Copilot Pro entirely free.

Catch: 2,000 completions sounds like a lot until you use it for a week. At that point you're paying $10/mo.

Best for: Developers already in the GitHub ecosystem, students, and OSS maintainers.

7. Cursor (free trial-ish)

Cursor's free tier gives you 2,000 "slow" completions and 50 premium requests per month. "Slow" means you wait in a queue during peak hours. It's enough to evaluate whether Cursor's agentic workflow fits your brain.

Catch: Unlike Windsurf, Cursor's free tier is explicitly designed to funnel you to the $20/mo plan. You'll hit limits within days of real work.

Best for: Anyone evaluating Cursor before committing. Not a long-term free solution.

8. Amazon Q Developer (free tier)

AWS quietly shipped a usable free tier for individual developers: unlimited code completions, 50 agent interactions per month. No credit card required for the free tier.

Catch: Deeply integrated with AWS. If you don't work in AWS, Q's value proposition drops significantly.

Best for: AWS developers. Pointless for everyone else.

The "free with API credits" category

These tools are free to use — but they call paid APIs behind the scenes, and you pay the API bill. New accounts usually get a small free credit balance.

9. Claude Code (free if you have credits)

Claude Code is Anthropic's terminal-based agentic coding tool. It's free to install and use, but every action consumes Claude API tokens. Anthropic gives new accounts $5 in free credits to start.

Catch: $5 in API credits lasts about two evenings of serious work. After that, you're either on Claude Pro ($20/mo, which includes Claude Code access) or paying per-token.

Best for: Developers willing to pay $20/mo for what is arguably the best agentic coding experience in 2026. See our Claude Code vs Cursor vs Copilot comparison for a deeper look.

10. Zed (free editor, free AI if BYO)

Zed is a fast, open-source code editor with built-in AI features. The editor is free forever. The AI features work with your own API key — Zed doesn't mark up tokens or charge a subscription.

Catch: You're paying the underlying API provider (OpenAI, Anthropic) for every completion. But at pass-through rates, that's often cheaper than a $20/mo tool subscription if your usage is moderate.

Best for: Developers who want a fast editor and fine-grained control over AI costs.

Which "free" should you actually pick?

It depends on your constraint.

Zero budget, ever: Aider + Ollama with qwen2.5-coder:32b locally. Slower, but genuinely zero dollars.
Zero budget, need speed: Windsurf's free tier. Unlimited autocomplete is a real floor under your productivity.
In the GitHub ecosystem: Copilot Free, especially if you qualify as a student, teacher, or OSS maintainer.
Trialing Cursor: Use their free tier for exactly one week, then decide. Don't stretch it.
Privacy-sensitive: Tabnine or Continue.dev with local models.

The honest truth about "free" AI coding tools

Most free tiers in 2026 are designed to hook you into paying. That's not a criticism — running these models costs real money, and the tools need to recoup it somehow. But if you really want free forever, your options narrow to the open-source stack: Continue.dev, Aider, Zed, and local models via Ollama.

Everything else is a trial in slow motion.

For a broader look at what professional developers actually pay for once their free tier runs out, see our guide to 12 AI Developer Tools Worth Using in 2026 — the piece that compares the paid tiers head-to-head.

Want more free developer stuff? We also track every free API credit and promo code for dev tools — updated monthly as new deals drop.