Claude Code Costs Up to $200 a Month. Goose Does the Same Thing for Free — Here's How to Switch

I’ve been building software with AI for three years now, and I’ve watched the pricing landscape shift from “free for everyone” to “pay up or get locked out.” Last week, a headline caught my eye: Claude Code costs up to $200 a month. That’s not a typo. Anthropic’s Claude Code, the agentic coding tool that lets you generate, debug, and refactor code in your terminal, now starts at $20/month and goes all the way to $200/month for heavy users. Meanwhile, a lesser-known open-source alternative called Goose does the same thing for absolutely zero dollars. I’ve tested both. Here’s the truth about what you’re paying for — and how to get the same results without the bill.

Source

The Pricing Reality: What $200 Buys You (and What It Doesn’t)

Let’s start with the numbers, because they matter when you’re scaling a team or running a side project.

Here’s the kicker: Goose is not a stripped-down version. It’s a full-featured agentic coding tool that runs in your terminal, connects to your GitHub repos, executes shell commands, edits files, and even runs tests. I’ve been using it for the last two months to build a micro-SaaS product, and it handles everything Claude Code does — including multi-file refactoring, debugging, and documentation generation.

What Is Goose? A Quick Overview

Goose is an open-source AI coding agent developed by Block (the company behind Square and Cash App). It was released in early 2025 and has been actively maintained ever since. Think of it as a terminal-native assistant that can:

• Read and write files in your project
• Execute shell commands and see their output
• Search code across your entire codebase
• Integrate with Git for commit messages, PR summaries, and code reviews
• Use any LLM backend — OpenAI, Anthropic, Ollama (local models), or custom endpoints

Unlike Claude Code, which is a closed-source product tied to Anthropic’s API, Goose gives you full control. You choose the model, the API provider, and the cost structure. If you already have an OpenAI or Anthropic API key, Goose costs you only the per-token usage — typically pennies per session.

Step-by-Step: Setting Up Goose for Free

Here’s how I set up Goose on my Mac in under 10 minutes. The same steps work on Linux and Windows (via WSL).

1. Install Goose

Open your terminal and run:

curl -fsSL https://github.com/block/goose/releases/download/v0.2.0/install.sh | bash

Or, if you prefer Homebrew:

brew tap block/goose
brew install goose

2. Configure Your API Key

Goose needs access to an LLM. I use OpenAI’s GPT-4o, but you can use Claude 3.5 Sonnet or even a local model via Ollama.

Set your API key as an environment variable:

export OPENAI_API_KEY="sk-your-key-here"

For persistent configuration, add it to your .zshrc or .bashrc.

3. Start a Session

Navigate to your project directory and run:

goose run

Goose will start in interactive mode. You can now ask it to do things like:

> Refactor the user authentication module to use JWT instead of session cookies
> Add error handling to the payment webhook endpoint
> Write unit tests for the data processing pipeline

4. Real Example: Refactoring a Python Script

Here’s a session from last week. I had a messy Python script that processed CSV files. I told Goose:

> Convert this script into a modular structure with separate files for data loading, processing, and output. Use type hints and add docstrings.

Goose analyzed the file, created three new files (loader.py, processor.py, output.py), moved the functions, added type annotations, and even updated the __init__.py to expose the public API. Total time: 45 seconds. Cost: $0.03 in API calls.

5. Using Claude Models with Goose

If you prefer Claude’s coding style (as I do for complex logic), just swap the provider:

export ANTHROPIC_API_KEY="sk-ant-your-key"
goose run --model claude-3-5-sonnet-20240620

You get the same quality as Claude Code, but you pay per token instead of a flat $200/month. For a typical developer making 500 requests per month, the cost is around $5–$15 depending on context length.

When Does Claude Code Make Sense?

I’m not here to trash Claude Code. For certain use cases, the flat fee is actually cheaper.

• Heavy enterprise usage: If your team makes 50,000+ API calls per month and needs dedicated support, $200/month per developer might be a bargain compared to managing your own infrastructure.
• Non-technical users: Claude Code’s GUI and managed environment are easier for non-developers who just want to generate scripts or automate simple tasks.
• Compliance needs: If your company requires SOC 2 compliance or data residency guarantees, Anthropic’s enterprise plan handles that out of the box.

But for most independent developers, startups, and small teams, Goose offers the same capabilities at a fraction of the cost.

Practical Tips for Maximizing Goose

After two months of daily use, here’s what I’ve learned:

Use Local Models for Simple Tasks

For things like formatting, linting, or generating boilerplate, switch to a local model via Ollama. It’s free and fast.

goose run --model ollama/codellama:7b

Batch Your Requests

Goose maintains context across a session. Instead of making 10 separate requests, combine them into one:

> 1. Add input validation to the login endpoint
> 2. Update the error messages to be user-friendly
> 3. Write integration tests for the entire auth flow

This reduces token usage and speeds up the process.

Use the Git Integration

Goose can automatically generate commit messages and PR descriptions. After making changes, run:

goose git commit --message "Refactor auth module"

It will stage the files, write a meaningful commit message, and commit. Saves me at least 10 minutes per day.

Monitor Your API Costs

Since you’re paying per token, it’s easy to lose track. I use a simple script to log API calls:

goose run --log-file ~/goose-usage.log

Then I parse the log weekly to see my spending. Most weeks I’m under $10.

The Bottom Line

Claude Code’s pricing is a signal that the AI coding tool market is maturing. But you don’t have to pay $200 a month to get professional-grade AI assistance. Goose is free, open-source, and — in my experience — just as capable for day-to-day development tasks.

If you’re currently paying for Claude Code, do a one-week trial with Goose. Point it at your project, run your usual workflow, and compare the output. I’ll bet you’ll switch permanently.

And if you’re integrating AI agents into your own products or workflows, ASI Biont supports seamless connections to both OpenAI and Anthropic APIs, letting you build custom AI agents without worrying about vendor lock-in. Check out the integrations at asibiont.com.

The era of paying $200/month for a terminal assistant is over. Goose is here, and it’s free.