When I first read the VSCode 1.118 release notes, I honestly didn't expect much. The headline was about adapting to Copilot's pricing change, which looked like routine maintenance. But after a month or so on consumption billing, using AI completions daily as an indie developer running several projects, those three quiet items — prompt caching, context compression, and pay-as-you-go support — turned out to land directly on my end-of-month bill.
This piece is about what I learned after actually living with the change, not what I expected going in: how to measure your token use, which habits cost more, and a break-even take on flat-rate versus consumption pricing, all from what I could verify firsthand.
Copilot's Pay-As-You-Go Is Already Here
The context first. Starting June 1, 2026, GitHub Copilot offers a consumption-based option alongside the existing monthly plans. VSCode 1.118, released at the end of April, shipped with the groundwork for that shift.
Pay-as-you-go means you pay for what you use. Light months come out cheaper; a month of all-day completion runs can end up pricier. Before the move I assumed flat pricing was the safer bet — but I found you can't actually tell which is cheaper until you measure your own usage. The reliable starting point is making your consumption visible.
Start by Measuring Your Own Usage
The first thing to do under consumption billing isn't learning features — it's knowing how much you burn per month. GitHub's billing dashboard (Settings → Billing → Copilot usage) breaks it down by day and by billable item.
If you want a copy on hand from the command line, the GitHub CLI's billing API returns usage as JSON.
# Pull Copilot billing metrics via GitHub CLI (org scope)
gh api \
-H "Accept: application/vnd.github+json" \
/orgs/YOUR_ORG/settings/billing/usage \
--jq '.usageItems[] | select(.product == "copilot")'I run this once a week and just check that request counts haven't spiked week-over-week. Once you get in the habit of glancing at the numbers, you develop a feel — "I was spraying completions yesterday" — before the bill arrives. Making it visible means no month-end surprises.
Prompt Caching (KV Cache) Lands on Your Bill
The change with the biggest cost impact in 1.118 is deeper use of prompt caching. With Anthropic models (Claude), frequently referenced context is stored in a KV cache, and cached tokens are billed at roughly one-tenth of a normal request when they hit.
This isn't a vibe — you can confirm it in the token breakdown returned with each request. Ask consecutive questions against the same set of files, and from the second request onward cache_read tokens dominate.
# When calling via the API, usage returns the cache breakdown.
# A larger cache_read_input_tokens means that request came in cheaper.
usage = response["usage"]
cached = usage.get("cache_read_input_tokens", 0)
fresh = usage.get("input_tokens", 0)
total = cached + fresh
if total:
print(f"Cache hit rate: {cached / total * 100:.1f}%")
print(f"Fresh input tokens: {fresh} / cache read: {cached}")What became clear is that to keep the cache warm you have to pass the same context, back to back, in the same order. Reopening files or slipping in unrelated questions invalidates the cache and puts you back on full-price billing. The longer the task, the cheaper it is to batch your questions in one continuous run.
Context Compression Cut the "It Went Weird Mid-Session" Problem
When a custom agent calls several tools or loads large reference documents, the chat context balloons fast. Previously, the AI's answers would go off the rails partway through a long session — context pollution.
VSCode 1.118 compresses already-processed tool results before keeping them in context. In my setup, even investigations spanning ten-plus files hold together better than they used to. As a side effect, a smaller context also means lower token spend under consumption billing. It's a rare case where quality and cost pull in the same direction.
Cleaner Extension Permission Model
Alongside the pricing move, the extension API was updated, clarifying the permission model for third-party extensions that touch Copilot's context. Tools like database connectors and API testers now integrate with Copilot's agent features more cleanly — one less bit of working around ambiguous access boundaries.
Flat Rate vs. Pay-As-You-Go: A Break-Even Take
The question I get most after the move is "so which one's cheaper?" It depends on usage, but framing the break-even makes the call easier. The table below assumes placeholder tiers — check the actual rates against your own plan.
| Usage pattern | Rough monthly requests | Better billing model |
|---|---|---|
| Weekends / spot use | A few hundred or fewer | Pay-as-you-go (you won't use up a flat fee) |
| Daily use for weekday coding | A few thousand | Roughly a toss-up (measure to decide) |
| All-day real-time completion | Tens of thousands+ | Flat monthly (a ceiling is reassuring) |
My own workload swings a lot month to month, so rather than switching plans by season I decided to run consumption billing for a month or two and measure first, then choose. Once the numbers pile up, next month's decision stops being a guess. For the bigger picture on usage and tiers, the Antigravity usage and pricing explainer and my measured record of switching the default to Gemini 2.5 Flash round out the picture.
Keeping Your Bill in Check on Consumption Billing
Here are the habits that actually held costs down after the move.
Patterns that push costs up
- Leaving the editor open all day, spraying real-time completions
- Re-generating entire long code blocks over and over with small tweaks
- Asking in fragments while reopening files, invalidating the cache each time
Patterns that keep costs down
- Batching related questions into one conversation so the cache stays warm
- Revisiting completion triggers to cut unnecessary auto-completions
- Checking the usage dashboard weekly and reviewing what caused any spike
Moving from "pay a flat fee" to "pay for what you use" is a nudge to rethink how you work. Call the AI only when you need it, and batch your work — those two habits alone visibly changed my bill. Where to draw the line on how much to hand to the agent is something I also cover in Antigravity vs. Claude Code.
Looking back
VSCode 1.118 isn't about headline features. It's about the AI coding infrastructure maturing — prompt caching, context compression, and pricing adaptation all in one release, each of which quietly reaches your bill if you use these tools daily.
Now that consumption billing is the norm, the next thing to do is measure your own usage properly. Open the dashboard, check last week's request count — start there, and next month's plan choice stops being a guess. Thanks for reading.