DEV Community: makayis

How to claim the free OpenAI API credits that now come with ChatGPT Pro and Business

makayis — Fri, 30 Oct 2026 16:01:52 +0000

If you pay for ChatGPT Pro or Business, you can now get free OpenAI API credits every month. OpenAI added this on Oct 28. Here is what I found reading the docs.

How much
Pro gives $100, $200 or $500 a month, matching your Pro tier. Business gives $20 per paid Standard seat and $100 per paid Premium seat, pooled and capped at $500 a month per workspace.

Who qualifies
The subscription has to be paid and at least 7 days old. Trials, Plus, Go and Free don't count. You need to own both the subscription and the API organization, with the same email on both.

How to claim
In ChatGPT go to Settings → Billing (Business uses the workspace billing settings), or start from Billing on the API Platform. Pick the API org and confirm. You only do this once, and no API payment method is needed. If you don't see the option yet, it seems to be rolling out gradually.

The catches
The first grant is prorated, and credits expire at the end of each billing cycle. They cover the Responses, Agents, Realtime and Images APIs plus built-in tools, but not Codex through an API key, and they don't raise your ChatGPT or Codex limits. When they run out, calls fail with a 429 credit_balance_exhausted unless you have paid credits.

Since Codex can't use them, I've been spending mine in CodeCook, a free, MIT-licensed VS Code extension I made. It takes an OpenAI API key, and in long sessions it summarizes older turns and bulky tool output with a cheaper model, so the credits go further. Repo: https://github.com/makayis/codecook

Vibe coding left the laptop this month. The review step needs to come with it.

makayis — Fri, 23 Oct 2026 08:02:56 +0000

For most of its short life, "vibe coding" meant something you did on your own machine for your own amusement: describe what you want, accept what comes back, keep going. In the first half of October, three announcements pushed it somewhere else: onto phones, into company tools, and into agents that run commands on your behalf. The safety net hasn't moved as fast.

I build a VS Code coding agent, so I spend a lot of time thinking about the moment between "the model wrote it" and "it's real". Here's what changed and what I think it means.

1. Vibe-coded apps can now live in Google Play

On 13 October, Google Play started letting people build Android apps in Google AI Studio and run them privately on their own devices through a personal library, without a paid developer account. The apps aren't publicly listed or searchable, and Google says sharing with friends and family, and eventually public publishing after Trust & Safety review, will come later (TechCrunch).

That's a genuinely nice thing for personal tools. It also means a prompt-built app now has a direct path to the device in your pocket, the one with your contacts, photos and banking apps on it. "Private" limits who can install it, not what the code does once it's there.

2. Inside companies, nobody can see most of it

A survey of 307 CIOs, CTOs and CISOs, published by VentureBeat as a piece sponsored by Retool (so read it with that in mind), found:

only 5% are very confident they have full visibility into the internal tools running across their organization
60% of builders say they've built something outside IT's oversight in the past year
just 4% of leaders say they have governance that covers AI-generated code (VentureBeat)

The vendor angle is obvious, but the scenario they describe is one most of us have seen: someone exports customer data to a CSV, builds a dashboard on a personal account, and publishes it to a public URL.

3. Agents got sandboxes, but you have to turn them on

On 7 October, GitHub made local sandboxing for Copilot generally available in Copilot CLI, the Copilot app and VS Code sessions using Agent Host. It limits which files agent-run commands can read or modify, controls network and credential access, and lets enterprises require it (GitHub changelog).

This is real progress. The docs are also refreshingly blunt about the default: local sandboxing is off, and until you enable it, shell commands Copilot runs "can read, write, and delete wherever you can, reach any network your machine can reach, and use your credentials without restriction" (GitHub Docs). That's true of most coding agents today, not just Copilot.

Models are being trained to stop and ask

Google's Gemini 4 Argon announcement (13 Oct) says the model was trained to "respect system boundaries, report negative findings honestly, and pause for human confirmation before taking irreversible steps." Google reports shortcut attempts dropped to 2% on coding benchmarks where models have no incentive to hold back (Google). That's the lab's own number, but the direction matters: labs are treating "know when to stop" as a capability.

The best-documented example of the human side is Cockroach Labs' five-month coding-agent pipeline: more than a million lines landed with 7 reverts, with human approval kept in the loop (Cockroach Labs). Even there, one urgent one-line fix took 11 rework rounds over two days. The team responded with a circuit breaker that hands off after four consecutive new-finding rounds or six rounds of any kind (Reveneau's summary). Agents need a rule for when to stop, and so does the process around them.

What I think "reviewing a vibe-coded change" should look like now

None of this means you should stop vibe coding. It means the cheap, fast part needs a cheap, fast check attached:

Turn the sandbox on if your agent has one. If it doesn't, at least run it in a project folder without secrets in reach.
Make every agent step undoable. A checkpoint per turn, so a bad step costs you a revert, not an afternoon.
Read the diff, not the chat. The model's summary of what it did is a claim. The diff is what happened.
Keep secrets and customer data out of prompts. Neither a sandbox nor a private listing fixes data you've already sent.
Decide in advance where "just accept it" is fine. A personal to-do app and an auth middleware deserve different levels of trust.

In CodeCook, my VS Code agent, every turn is checkpointed with native diffs, keep all / revert all and rewind, for exactly points 2 and 3. Whatever you use, the point is the same: in October, vibe coding got a lot more reach. The review step has to keep up.

Sources checked 21 October 2026.

October's model price cuts are real. Your long agent session will still find a way around them.

makayis — Thu, 22 Oct 2026 09:33:13 +0000

Almost every lab cut prices in the last four weeks. If you build or use coding agents, that sounds like the problem is solving itself. Reading the pricing pages closely, I think it's more interesting than that: per-token prices are dropping, but the pricing is increasingly shaped around how you send tokens: cache hits, prompt length, and which model does which step. A careless long session can still burn money on cheaper models.

Here's what changed, with sources, and what I take from it as someone building a VS Code coding agent.

What actually got cheaper

Claude Opus 5.5 (22 Sep) lists at $4 per million input tokens and $20 per million output, down from $5 / $25 for Opus 5 (Anthropic pricing). Its cache hits are priced at 0.05x base input, i.e. $0.20.

Claude Haiku 5.5 (7 Oct) is the big one: $0.10 / $0.50 per million for prompts up to 100,000 tokens, against $1 / $5 for Haiku 4.5 (announcement). Anthropic positions it for "summaries, compactions, database queries, and classification" and says it "pairs well with Opus 5.5 and Sonnet 5.5 as a subagent on coding work."

The same day, Sonnet 5.5 cache reads were halved from $0.20 to $0.10 per million, which Anthropic says makes Sonnet 5.5 "around 20% cheaper on most agentic work", because cache reads are a large share of what agents consume (announcement).

Gemini 4 Argon (13 Oct) launched at an introductory $2 / $10 per million, with cached input at 95% off and a 1M unified input-output token limit. After 30 November the price becomes $4 / $20 (Google).

The fine print is where agents live

Three details in those pages matter more to agent builders than the headline numbers.

1. The 100K cliff. Haiku 5.5 costs $0.10 / $0.50 only under 100,000 tokens. Above that it's $0.50 / $2.50 (model docs). Anthropic notes about 90% of requests to the previous Haiku fell under that line (announcement). A short classification call stays under it easily. A coding agent that has been running for an hour, resending its whole transcript and every old tool result, does not. The same model can be 5x more expensive per input token depending on how much history you drag along.

2. Cache pricing is now the main discount. Look at where the cuts landed: Sonnet's cache reads halved, Opus 5.5 cache hits at 0.05x, Argon's cached input at 95% off. The cheapest token is one you've already sent with an identical prefix. That rewards keeping the start of the prompt stable and penalizes anything that keeps rewriting it.

Claude Code's 2.1.299 release shows the tools adapting to this. A conversation over 200K tokens that sits idle for about 54 minutes is now compacted before its one-hour prompt cache expires, so your next message doesn't reprocess the whole history (Offsite's October digest). That's a feature built entirely around cache timing.

3. Cheap small models only help if something routes to them. Haiku 5.5 is explicitly sold as a subagent. But it scores 39.2% on Terminal-Bench 4.0 against 70.6% for Sonnet 5.5, as summarized by Vibe Coding Weekly #52, so it isn't a drop-in replacement. The same newsletter points to Michael Lynch's complaint that agents "use expensive models for gruntwork and never delegate to cheaper ones or escalate."

The best real-world cost data I found this month

Cockroach Labs published five months of running a coding-agent pipeline on its MOLT tools (21 April to 11 September): just over $135,000 in Claude tokens, around $84 per GitHub issue, more than a million lines of code landed with 7 reverts (Cockroach Labs).

What I found most useful is how they control cost. Planning now runs on their strongest model, the plan chooses the model for implementation, and work that struggles on Sonnet or Opus can escalate to a stronger one. They also run optimization rounds every couple of weeks after model switches.

One detail from coverage of the post stuck with me: one of their review agents loaded about 21,800 words of instructions, roughly 29,000 tokens, on every run before even reading the pull request, and a July audit flagged 23% of their skill files as removable without changing a gate (Reveneau's summary). Fixed per-run context is a cost line, even in a well-run pipeline.

What I take from this as an agent builder

Track tokens per task, not price per token. A 20% list-price cut disappears if the session carries twice the history.
Keep prompts short and prefixes stable. Tier cliffs like Haiku's 100K line and cache discounts both reward this. Compaction helps, but rewriting history also changes the prefix, so it's worth doing deliberately rather than constantly.
Give the cheap model the cheap jobs. Summaries and compaction are exactly what Haiku-class models are pitched for. Planning and hard reasoning still deserve the strong model.
Prices change on a calendar. Argon's price doubles after 30 November. Hard-coded cost estimates go stale, so keep per-million prices configurable.

That last point is personal: in CodeCook, the VS Code agent I'm building, the summary model is a separate setting from the agent model, and per-million prices are configurable for exactly these reasons. But the lesson applies to whatever tool you use. This month, the model you pick matters less than what you keep sending it.

Prices as listed on the linked pages on 21 October 2026. Check them before you rely on them; they move.

Where the tokens go in a long agent session, and how CodeCook stops resending them

makayis — Wed, 21 Oct 2026 16:18:23 +0000

If you've run an AI coding agent through a long session, you've probably seen how the cost grows. Turn 3 is cheap. Turn 30 isn't, even when all you ask for is a one-line fix. I've written about CodeCook before. This post is about the mechanics: what actually gets sent on every turn, what I decided is safe to stop sending, and where that trade-off still goes wrong.

What a "turn" really sends

A chat model has no memory between requests. Every time the agent takes a turn, the client sends the whole working context again:

the system prompt and tool definitions
every earlier user message and model reply
every earlier tool result: file reads, directory listings, terminal output, test logs

That last group is the problem. A single file read or a noisy test run can be thousands of tokens. It helped the model once, on the turn it happened, and after that it's mostly dead weight. It still gets resent, and billed as input, on every turn that follows. So the cost of a session doesn't grow with the work you're doing now. It grows with everything that came before.

The approach: summarize the old, keep the recent

CodeCook is a VS Code extension, a coding agent in the sidebar, and its main job is to stop that resending. The idea is simple:

Older turns get compressed into a summary. Later turns send that summary instead of the full earlier text.
Bulky tool output gets compressed too, so a 2,000-line log from twenty minutes ago doesn't ride along forever.
Recent turns are still sent in full, because that's where the details the model needs right now live.

You can also trigger summarization yourself ("summarize a long conversation on demand") when you know you've finished one phase of the work.

Summarization uses its own model setting, codecook.summaryModel, separate from codecook.model for agent turns. That way you can use a cheaper model to write summaries and save the stronger one for the actual coding. Token budgets and tool-result limits are configurable too, under CodeCook in Settings.

The plan lives outside the summary

The biggest risk with summarizing is that the agent forgets what it was trying to do. A summary of "we discussed auth" doesn't help much at step 6 of a 10-step refactor.

So the plan is kept separately and survives summarization. You build it, you can reopen it from the command palette, and the agent keeps following it in long sessions even after the turns where it was written are compressed. Constraints like "keep the existing database tables" or "auth stays on the existing provider" belong in the plan, not in chat history that might get summarized away.

The code itself is another safety valve. The real state lives in your workspace files, not in the chat. If turn 7 needs a function written in turn 3, the agent can read the file again instead of relying on the conversation remembering it.

What the numbers look like (honestly)

In one long agent session, a single turn went from 800,787 tokens to 14,857 after compression, about 98% fewer, with the plan and the work intact.

To be clear about what that is: one turn, deep into a long session, and a best case, not an average. Savings depend on how long the conversation is, which model you use, how much tool output piled up, and when you summarize. A short session won't see anything like that.

To make this visible rather than a claim, the token panel compares "history if sent in full" with "history actually sent" for each turn, and the savings report adds that up. Those token and cost numbers are estimates, not your provider's bill. Client-side token counts can drift from what the server counts, so the usage your provider reports is the real number. Checking those estimates against actual billed cost across many sessions is the next thing I'm measuring.

Spend caps, because estimates still help

Since the per-turn cost is estimated anyway, CodeCook can stop a session from running away. You can set daily, weekly, or monthly caps:

{
  "codecook.spendLimitDailyUsd": 5,
  "codecook.spendLimitWeeklyUsd": 20,
  "codecook.spendLimitMonthlyUsd": 60
}

0 means no cap. Per-million-token prices are configurable, so the estimates can match the model you actually use.

Checkpoints: the other half of trusting a summary

A summary can leave details out. I'd rather admit that and make mistakes cheap to undo. Every turn is checkpointed. You see every file the turn changed, can open one diff or all of them in VS Code's native diff view, keep all, revert all, or rewind to an earlier turn and restore your files. If a compressed context leads the agent somewhere wrong, you roll back that turn instead of untangling it by hand.

Setup, including the sign-in step

Bring your own key. Google Gemini (Vertex AI with gcloud login, or a Gemini API key), OpenAI (API key or your ChatGPT plan), Anthropic Claude, Azure OpenAI, or AWS Bedrock. You only need one. You pay the provider directly, with no markup. Vertex AI is the default; set codecook.gcpProject if you use it.
There's a sign-in step. When you first open CodeCook, you sign in with Google or GitHub. That creates a CodeCook account stored only in your local VS Code install. It's separate from your model provider and gives CodeCook no access to your repositories. GitHub sign-in uses the device-code flow. I know any sign-in is friction, so tell me if it stopped you.
Requires VS Code 1.85+. MIT-licensed and free.

Where it still falls short

It isn't symbol-level dependency tracking. If a detail lived only in an old turn and never made it into a file or the plan, the summary can lose it.
Savings vary a lot; the 800K → 15K turn is not typical.
Cost numbers are estimates until I've finished checking them against real bills.

Try it

VS Code Marketplace: https://marketplace.visualstudio.com/items?itemName=makayis.codecook
Open VSX (Cursor, VSCodium and other VS Code-compatible editors): https://open-vsx.org/extension/makayis/codecook
Website: https://www.codecook.makayis.com

If you try it on a long session, I'd really like to hear two things: where a summary dropped something you needed, and how far the estimate was from what your provider billed. Those two answers decide what I work on next.

I built a Blender-style 3D editor from a few prompts. Cost: €0. Using codecook with Gemini 4 Argon

makayis — Wed, 14 Oct 2026 18:11:27 +0000

I built a Blender-style 3D editor from a few prompts. Cost: €0.
Using codecook (https://lnkd.in/e4Kh6Khj) with Gemini 4 Argon, I got a working 3D editor in the browser in just a few iterations.
What’s in it:
🧊 A 3D viewport with grid, axes and a transform gizmo
📂 A scene outliner (Cube, Key Light, Rim Sun Light)
🎛️ A Transform panel for Location, Rotation and Scale
📊 Live scene stats (vertices, edges, faces, tris) and an FPS counter
🗂️ Workspace tabs: Layout, Modeling, Sculpting, UV Editing, Shading, Rendering
No paid API and no big budget. I described what I wanted, reviewed the output and refined it a few times, and it came together.
The takeaway for me: the barrier to prototyping complex software is collapsing. What matters now is knowing what to ask for and how to guide the iterations.
If you want to try it yourself, codecook is a free VS Code extension: https://lnkd.in/e4Kh6Khj
What would you build if a first prototype took an afternoon instead of a month?

AI #GenAI #VibeCoding #Gemini #VSCode #3D #Blender #BuildInPublic #gemini4argon #argon

AI coding is entering its "efficiency-first" phase: tokens, memory, and skills

makayis — Mon, 12 Oct 2026 20:45:34 +0000

A year ago the question was "which model is best?" This week the GitHub
trending lists point somewhere else: how do we make agents cheaper, less
forgetful, and more reusable?

I looked through a few daily open-source trend reports from this week
(one,
two). Three themes
keep showing up.

1. The "token economy"

One report describes a strong push to cut LLM overhead through context
compression. Tools like Headroom and Caveman keep appearing, and Headroom
advertises up to 95% token savings on tool outputs and logs.

A caution from me: a published study of agent sessions
(arXiv 2607.12161) found that cutting
tokens doesn't always lower the billed cost, because prompt caching dominates
the bill, and that compression can hurt task success. Token counts are not the
same as dollars.

2. Persistent memory

Projects like mem0 and claude-mem keep trending. The idea is to move agents
from stateless scripts to something that remembers across sessions. That's
exciting, but it raises a real question: what should an agent remember, and
how do you stop stale memory from misleading it?

3. Skills and harnesses

Reusable "agent skills" for tools like Claude Code are getting a lot of
attention, as developers package their workflows instead of re-prompting
from scratch.

What I make of it

Stars are a popularity signal, not proof that something works, and these
reports are automated summaries. But the direction is clear: the next gains
seem to come from how we use models, not only from bigger ones.

What are you using to keep AI coding costs under control? Memory, compression,
skills, or just shorter chats?

Stop paying for old chat history: a free BYOK VS Code AI agent that compresses long sessions

makayis — Mon, 12 Oct 2026 20:41:21 +0000

Long AI coding chats get expensive for a simple reason: every turn resends
the whole conversation, so turn 30 costs far more than turn 3.

I built CodeCook to fix that. It's a free, MIT-licensed VS Code extension
(disclosure: I'm the author).

What it does

Summarizes older turns and bulky tool output so you stop paying for them again
Keeps your plan intact across summaries
Shows token and cost estimates per turn, with daily, weekly, or monthly spend caps
Checkpoints every turn: review diffs, revert, or rewind
BYOK: Gemini, OpenAI, Claude, Azure OpenAI, or Bedrock, with no markup

In one long session, a single turn went from about 800k to about 15k tokens.
That's a best case, not an average, so I'm testing real billed cost next.

Try it: https://marketplace.visualstudio.com/items?itemName=makayis.codecook

I'd love feedback on what breaks or what's missing.

I built a BYOK VS Code agent that cuts token costs by compressing old chat turns

makayis — Sun, 11 Oct 2026 18:58:07 +0000

The problem

In a long AI coding session, every turn resends everything you already paid for: all the old messages and all the tool output. The bill keeps growing even when the work doesn't. I wanted to use bigger models without worrying about tokens.

What is CodeCook?

CodeCook is a free, MIT-licensed VS Code extension: a coding agent in your sidebar that you run with your own API key (BYOK). You pay your provider directly, with no markup and no lock-in.

Demo

How it cuts cost

Compression of old turns: older turns and bulky tool output are summarized instead of resent every time, so you pay for new work, not old work.
Plans survive summarization: build a plan, reopen it from the command palette, and the agent keeps following it in long sessions.
Visible costs: a token optimizer, savings report, and spend estimates, plus daily, weekly, or monthly caps so a long session never surprises you.

In one long agent session, a single turn went from 800,787 to 14,857 tokens (about 98% fewer) with the plan and work intact. That was one turn in a long session, not an average. Savings vary with session length.

Built for real work

Every turn is checkpointed. Review native diffs, keep or revert all edits, or rewind to an earlier turn and restore your files.
Highlight code in the editor or text in the terminal and choose Add to Chat.

Providers

Google Gemini (Vertex AI or API key), OpenAI, Anthropic Claude, Azure OpenAI, and AWS Bedrock. You only need one.

Getting started

Install from the Marketplace: https://marketplace.visualstudio.com/items?itemName=makayis.codecook
Open CodeCook in the activity bar and sign in with Google or GitHub. This creates a local account stored only in VS Code and gives CodeCook no access to your repositories.
Connect one provider
Ask the agent to work on your workspace and review the diffs

Website: https://www.codecook.makayis.com

Feedback

CodeCook is free and I'm improving it actively. I'd love to know:

How much you save in real sessions
Which providers or features are missing
Anything that feels rough

Thanks for reading!