GitHub Copilot Castaway: Claude Code, Google AI Studio, and Finally Codex

SASAKI Naoya — Wed, 17 Jun 2026 16:59:16 +0000

Overview

GitHub Copilot Pro has become a mess, so I decided to try several alternative AI coding services.

Conclusion

Codex through ChatGPT Plus feels the closest to the semi-vibe coding workflow I was used to with VS Code + Copilot.
Claude Code is more geared toward full-vibe coding and less suitable for semi-vibe workflows.
VS Code's drag-and-drop and range-selection context controls deserve more recognition.
Usage-based pricing creates a sunk-cost effect, making poor implementations harder to discard.
AI coding usability depends not only on model quality but also on context control.

Background

On June 1, 2026, GitHub Copilot introduced a new pricing structure, effectively raising prices and adding usage-based billing.

Even as a GitHub Copilot Pro annual subscriber, I was affected immediately. Some AI models suddenly required six to nine times more premium requests, making it impractical to continue using Copilot at the same pace.

The official emails and announcements recommend switching to the new monthly plans. However, the account page currently offers only two options: upgrade to Pro+ or "cancel and refund subscription." It may be a bug.

GitHub Copilot has already faced significant backlash, so I'll leave the debate to others. Instead, I decided to use this opportunity to explore other AI coding services.

Before Moving to Other Services

For annual subscribers, premium request consumption has increased dramatically. However, requests are still charged per task, not by execution time or token usage.

If a single prompt can replace six or nine traditional requests, the new pricing model might still be worth it.

To make a single prompt run autonomously for an extended period of time, the AI needs to be capable of trial and error and self-improvement.

Something like this:

Let's try a different approach.
First, implement a feature that returns a screenshot of the current application state over HTTP.
Likewise, expose APIs that allow display mode switching and camera movement through HTTP.
Using these APIs, I want you, as the agent, to debug the rendering system.
Once the implementation is complete, summarize the HTTP interface in a Markdown document and report the current state of the renderer before making any further changes.

With this setup, I can give instructions such as:

Improve the rendering performance until the application consistently runs above 30 FPS.

In theory, that creates a fully autonomous improvement loop.

In practice, however, things are not quite so simple. The AI often decides that it has achieved the objective and terminates the process long before the target has actually been reached.

I still believe that letting AI debug and operate applications through an HTTP interface has a lot of potential, but building a reliable autonomous workflow is more challenging than it first appears.

By this point, I had already burned through more than 50% of my monthly premium requests, so I decided to stop experimenting.

One word of caution: this approach can become very expensive when used with usage-based pricing models.

In that scenario, defining robust termination conditions becomes even more important.

Claude Code

Claude Code is a CLI-based coding agent.

In practice, it is a combination of an LLM, a set of tools, and a host program that orchestrates them.

Because of their different origins,

Claude Code → agent-first from the beginning
Copilot → code completion first (with chat added later)

there is still some debate over whether Claude Code retains an edge in agentic workflows, or whether the gap has already disappeared.

Although GitHub Copilot subscriptions allow access to models such as Claude Sonnet and Opus, they do not provide access to Claude Code itself.

To use Claude Code, you have two options:

Subscribe to a Pro plan

This is the traditional subscription model. Usage is included up to a certain point, after which rate limits may apply.

Purchase API credits

This is usage-based billing from the beginning.

Beyond pricing, there are several practical differences between the subscription and API approaches:

Both provide access to Claude Code, but when using the API, Claude Code cannot be controlled from Claude for Windows.
With API usage, browser-based chat remains on the free plan.
API access allows you to create an API key and use Claude from any compatible application. (Important)

The recent GitHub Copilot Pro situation made me curious about how a usage-based model would compare in practice, so I decided to give it a try.

Because I was using the API, I worked through the CLI.

As of June 2026, the default model is Opus.

Its pricing is nearly double that of Sonnet.

After launching Claude Code, check the active model with /model and switch if necessary.

When working with a repository for the first time, running /init causes Claude Code to scan the project and generate a CLAUDE.md file containing an overview of the project.

This time, I used the following repository:

https://github.com/ssknaoya/autonomous-warfare/

Since CLAUDE.md was generated in English, I had Claude translate it into Japanese.

By this point, I had already spent roughly $1.

Next, I switched to Plan Mode with Shift + Tab and gave it a task.

This time, I intentionally left some ambiguity in the requirements to see how capable Claude Code's agentic workflow was.

I want to display a Season Result screen when a season ends.

Show changes in genome rankings within each pool

Display detailed information for any newly crowned #1 genome

Clearly indicate which genomes were removed and which were newly generated

Support scrolling when not all genomes fit on the screen

Show the Season Result screen for 3 seconds by default before closing automatically

Stop the timer if the user interacts before the timeout expires

Allow the timeout duration to be configured in System Settings

Setting the timeout to 0 should disable the Season Result screen entirely

Generating the plan consumed another $2, bringing the total to roughly $3.

I believe the total cost reached around $5 by the time the implementation was complete. Unfortunately, the first version crashed the application when the newly created screen should be displayed.

I then had Claude Code fix the crash and address several display issues. Before long, the total cost had reached $10.

The resulting screen looked like this:

At a glance, it looked good, and the functionality was not bad.

However, the visual style was inconsistent with the rest of the application. (This was after I had already instructed it to match the appearance of existing screens.)

My impression was that, despite reading a large amount of source code, it failed to pick up on the project's design language and overall feel.

Perhaps I expected too much from Claude Code because of its reputation as a pioneer in agentic coding.

Personally, I may be better off using VS Code, where I can explicitly provide relevant files through drag-and-drop or text selection.

Because Claude Code runs in a CLI, there is no convenient way to specify context through mouse operations.

I also found it easier to review and verify code changes in VS Code simply because I was already familiar with the workflow.

In terms of overall usability, Claude Code may not be the right fit for my development style.

One advantage of using the API is that it allows Claude to be used outside of Claude Code itself.

By configuring an API key in VS Code, Claude can be used with virtually the same workflow as VS Code + GitHub Copilot, making it a direct replacement for Copilot.

From Claude's settings page in the browser, select API Keys.

n the next screen, click + Create Key in the upper-right corner and generate an API key.

In VS Code, click the gear icon in the upper-right corner of the model selection popup within the chat panel.

Select + Add models... → Anthropic, use Anthropic as the Group Name, and then enter the API key you just created.

After that, Claude models from Anthropic become available alongside the standard Copilot model selection menu.

For reasonably substantial coding tasks, it is not uncommon for a single prompt to consume $1–$2 worth of credits.

Whether through Claude Code or VS Code, I'd probably burn through more than $20 in a single day if I used it without restraint.

Maintaining that level of spending for a hobby project is difficult to justify.

There is also a psychological aspect.

Once billing becomes usage-based, bad code becomes harder to throw away.

Even knowing the term sunk cost effect, it is surprisingly difficult to ignore.

When additional credits are spent fixing a poor implementation, it starts to feel uncomfortably similar to chasing losses at a casino.

I've never been to one, though.

Google AI Studio

Earlier, I mentioned that combining VS Code with APIs is like a "rich man's programming." However, Google’s Gemini API is a unique exception: you can query the latest models directly from VS Code without spending a single penny, as long as you stay within the free tier limits.

Crucial Rule: Never register your credit card (or billing info)
You might think, "I'll link my card just in case I exceed the limit, so it can switch to pay-as-you-go." Do not do this. The instant you link a credit card on the Google Cloud side, your free tier privileges vanish, and you'll be charged right from your very first request.
If you want to keep it 100% free, completely ignore the "Set up billing" prompt on the AI Studio screen. Exceeding the quota will simply stop the request with an error, which is by far the safest approach for hobby development.

Those were Gemini's own words.

Technically, it wasn't lying.

Unfortunately, it wasn't practical either. Unless you're simply curious, I'd recommend skipping this experiment.

First, open the Google AI Studio page and create an API key from the key icon.

Just as with Claude, launch VS Code and open the model selection menu in the chat panel.

Select + Add models... → Google, then enter your API key.

Once configured, Gemini models become available from the model selector.

Gemini 3.5 Flash currently carries a 14x premium-request multiplier in Copilot.

Through AI Studio, you can technically use it for free.

The catch is the rate limits.

The first restriction is a limit of five requests per minute.

Even if the user submits only a single prompt, VS Code may internally generate additional requests while reading files, editing files, or invoking tools.

As a result, even simple tasks often hit the rate limit before they can be completed.

Waiting a minute resets the limit, but there is another issue.

If you click Retry in VS Code after the cooldown expires, the request appears to resume from an intermediate state, often resulting in another error and leaving the task unrecoverable.

Oddly enough, creating a new prompt in the same session—something like "Please continue where you left off"—usually works.

Even if you manage to work around the per-minute limit, there is a second restriction:

20 requests per day.

There is not much you can do about that.

It was an interesting experiment, but in the end, the offer was only as generous as reality allowed.

Codex

Unlike Claude Code, which requires payment before you can use it at all, Codex can be explored for free.

Open the Codex page, download the application, and install it.

Compared to a CLI, the desktop app provides a much clearer view of the available context and tools.

(To be fair, I might have had a different impression of Claude Code if I had used it through Anthropic's subscription plan and desktop applications rather than through the API and CLI.)

Pasting images is also effortless.

Like Claude, Codex can be used either through a subscription plan or through API billing.

If you want to use Codex under a fixed-price subscription, ChatGPT Plus is the obvious choice.

The subscription plan uses two separate rate limits, which reset every five hours and every week respectively.

So far, I haven't come close to either limit while using it in a semi-vibe coding style.

(Updated: June 24, 2026)

Shortly after I finished writing this article, I noticed that my usage quota started being consumed much more quickly.

My impression is that both OpenAI and Anthropic are still in the process of fine-tuning their rate limits and usage policies

Perhaps because providing context is so much easier, GPT feels noticeably more responsive than Claude in day-to-day use.

At least for me, using Codex through ChatGPT Plus comes closest to recreating the GitHub Copilot experience before the recent pricing changes.

Until the Copilot situation settles down, Codex will probably become my primary tool.

Final Thoughts

I had been curious about both Claude Code and Codex for some time, but never found a good excuse to try them.

Thus, the recent GitHub Copilot pricing controversy turned out to be a good opportunity.

Because I rely heavily on Agent Mode, I assumed I had already become a vibe coder.

After experimenting with these tools, I realized that I care much more than I thought about explicitly providing context and reviewing modifications.

In other words, I am less of a vibe coder and more of a semi-vibe coder.

Viewed from that perspective, VS Code + Copilot was actually an excellent solution for semi-vibe coding, thanks to its drag-and-drop file selection.

The rise of AI agents has also reminded me that the usefulness of these tools depends on far more than the underlying LLM itself.

As AI development tools mature, factors such as workflow, context control, and user experience may matter just as much as the model behind them.

DEV Community: SASAKI Naoya