Why I Switched from GitHub Copilot to Claude Code Max

TL;DR

GitHub Copilot is an autocomplete engine. Claude Code is a junior engineer who can read your entire repo, run commands, edit files, and execute multi-step plans. After a year with Copilot and a month with Claude Code Max ($100/month for the Max plan with Opus), I moved my primary workflow to Claude Code for infrastructure and backend work. Copilot still wins for inline code completion in the editor. Claude Code wins for everything else – debugging, deployment, refactoring, writing tests, and any task that requires understanding context across multiple files.

What I Was Using Before

My setup for the past year:

• GitHub Copilot ($19/month) for inline code completion in VS Code
• Claude Pro ($20/month) for the web chat when I needed to think through architecture or debug complex problems
• ChatGPT Plus ($20/month) for a second opinion and image generation
• Manual terminal work for all kubectl, terraform, ansible, and git operations

That is $59/month across three subscriptions, none of which could actually touch my codebase. Every interaction was copy-paste: copy the error, paste it into chat, read the suggestion, manually apply it, copy the next error, repeat. The context window resets every conversation. The AI never learns your codebase conventions. You are the integration layer.

What Claude Code Actually Is

Claude Code runs in your terminal (or as a VS Code extension) with direct access to your filesystem, shell, and git. When I say “debug why the digital signage CI pipeline is failing,” it does not ask me to paste the error. It runs the workflow, reads the logs, identifies the Docker Hub rate limit, checks the Dockerfile, and proposes a fix – then edits the file and runs the build again.

The mental model shift: Copilot completes the line you are typing. Claude Code completes the task you are describing.

The Skills System

Claude Code reads CLAUDE.md files at the repo root and .github/copilot-instructions.md for project context. But the real power is in the skills system. I have 30+ skill files across my repos that encode domain knowledge:

.claude/skills/
├── k3s-deployment/     # How to deploy to my cluster
├── k3s-debugging/      # Failure patterns and triage steps
├── docker-ecr/         # Build conventions, --provenance=false
├── terraform-infra/    # Proxmox + AWS module patterns
├── grafana-dashboards/ # ConfigMap-based dashboard creation
└── openclaw-operator/  # OpenClaw-specific operations

Each skill file is a prompt that gets injected when the task matches. When I say “deploy a new service,” Claude Code loads k3s-deployment and follows my exact checklist: namespace, deployment, service with the right selector labels, ingress with cert-manager annotation, ServiceMonitor for Prometheus, RBAC for the CI runner. It knows about the service selector trap (the app.kubernetes.io/component: web label that has caused four production incidents) because that is encoded in the skill.

Copilot has no equivalent. It autocompletes based on the current file. It does not know that my cluster requires Recreate strategy because I use single-replica Longhorn PVCs. It does not know that MetalLB breaks if you specify metallb.universe.tf/address-pool: default. That knowledge lives in my skill files, and Claude Code reads them before writing a single line.

Memory Across Sessions

Claude Code has a persistent memory system that survives across conversations. It stores facts about my setup:

• The cluster is amd64-only (Lima VM removed June 2025)
• Longhorn is disabled on k3s-agent-4 (aging NVMe on pve4)
• Prometheus and Grafana must use nfs-monitoring StorageClass, never Longhorn
• AWS spend is ~$476/month and changes should be flagged

This means I do not re-explain my infrastructure every session. When I start a new conversation and say “add a new CronJob for log aggregation,” Claude Code already knows which namespace conventions I use, which storage classes are available, and which nodes have scheduling constraints.

Copilot starts fresh every time. There is no institutional memory.

The Cost Math

I dropped Claude Pro and ChatGPT Plus when I switched to Claude Code Max. My total AI tooling cost went from $59/month to $100/month – a $41 increase. But the throughput difference is not 1.7x. It is closer to 5-10x for infrastructure tasks.

On March 21, I shipped work across five repositories in a single day: a 13,674-line stock trading platform, Harbor registry migration across 13 CI workflows, API key authentication for digital signage, inventory sell signals for a trading card tracker, and OpenClaw cost optimization. Every commit was co-authored with Claude Code. That volume of work across that many codebases would have taken me a week with copy-paste workflows.

The $41/month pays for itself in the first hour of a serious debugging session.

Where Claude Code Wins

Multi-File Refactoring

“Rename the trade_bot namespace to stock-automation across all manifests, Terraform files, and CI workflows.” Copilot cannot do this. Claude Code greps the codebase, identifies every reference, edits each file, and shows you the diff.

Infrastructure Debugging

“The Grafana dashboard is not loading data.” Claude Code checks the pod status, reads the ConfigMap, verifies the Prometheus datasource URL, checks the ServiceMonitor selector labels, tails the Grafana logs, and identifies that the datasource was pointing to the wrong Prometheus service name after a Helm upgrade. It fixes the ConfigMap and restarts the pod. Total time: 90 seconds. With Copilot, I would have done every one of those steps manually.

Writing Tests

“Add unit tests for the sell signals engine.” Claude Code reads the source file, understands the five strategy functions, writes tests covering normal cases, edge cases (insufficient data, boundary conditions, null values), mocks the price history provider, and runs the test suite to verify they pass. It wrote 25 tests in one pass. With Copilot, I would write one test at a time with inline completion, manually thinking through each edge case.

Kubernetes Manifest Generation

“Deploy a new Flask app called rag-bridge to the polymarket-lab namespace.” Claude Code generates the complete manifest following my conventions: namespace reference, deployment with Recreate strategy, service with app.kubernetes.io/component: web selector, ingress with letsencrypt-prod cluster issuer, ServiceMonitor scraping /metrics, and a CI workflow for building and pushing to Harbor. It knows all of this from the skill files.

Where Copilot Still Wins

Inline Completion Speed

When I am typing Python in VS Code, Copilot’s ghost text appears in milliseconds. It completes function signatures, dictionary keys, f-string interpolations, and boilerplate patterns faster than I can think about them. Claude Code does not do inline completion at all – it is a different interaction model. You describe a task, it executes. There is no ghost text while you type.

I kept Copilot active alongside Claude Code for the first two weeks. Eventually I dropped it because the $19/month was not justified when Claude Code handles the harder tasks and VS Code’s built-in IntelliSense covers basic completion. But if your workflow is primarily writing new code line by line in a single file, Copilot is better at that specific interaction.

Simple, Single-File Edits

“Add a try/except around this database call.” Copilot handles this instantly with inline completion. Claude Code would read the file, make the edit, and return – correct, but slower for something this trivial. Use the right tool for the scale of the task.

What Surprised Me

The Context Window Matters More Than the Model

Claude Code with Opus has a massive context window and it uses it aggressively. It reads your CLAUDE.md, skill files, relevant source files, test files, and git history before generating a response. The quality difference between “AI that read your repo instructions” and “AI that is guessing from a code snippet you pasted” is enormous. Most of the improvement I attribute to Claude Code is not model quality – it is context quality.

The Approval Flow Is the Right Default

Claude Code asks before running destructive commands. It shows you the diff before writing files. It asks before pushing to remote. This felt annoying for the first day and essential by the second. When an AI agent has shell access to your infrastructure, you want a confirmation step before kubectl delete or git push --force. The permission system is configurable – you can auto-approve reads and file edits but require approval for shell commands. I landed on auto-approve for reads and edits, manual approval for anything that touches the cluster or git remote.

It Makes Mistakes Differently Than Humans

Claude Code’s failure mode is not “wrong answer.” It is “correct answer to a slightly different question.” It will write a perfect Kubernetes manifest that uses RollingUpdate instead of Recreate because that is the Kubernetes default, ignoring my documented convention. It will add a ServiceMonitor that scrapes the wrong port because it inferred the port from the Deployment instead of reading the application’s metrics configuration. The skill files and CLAUDE.md mitigate this, but you still need to review every diff. It is a junior engineer who reads the docs, not a senior engineer who knows the system.

The Setup That Works

My current configuration:

1. Claude Code Max ($100/month) as the primary development tool for all multi-file tasks, debugging, deployment, and refactoring
2. VS Code with Claude Code extension for the IDE integration (inline diff view, accept/reject changes)
3. CLAUDE.md + skill files in every repo encoding project conventions, anti-patterns, and deployment checklists
4. Memory system storing user preferences, project state, and operational knowledge across sessions
5. No Copilot, no ChatGPT Plus – consolidated to a single AI subscription

The key insight: the value of an AI coding tool scales with how much context it has about your specific project. Copilot has zero persistent context. Claude Code has your entire repo, your documented conventions, your failure patterns, and your preferences from previous sessions. For a solo engineer running a homelab with 15+ applications across 7 Kubernetes nodes, that context is the difference between an AI that helps and an AI that generates plausible-looking code you have to heavily edit.

What I Would Change

The Claude Code Max pricing is steep for hobbyists. $100/month is fine if you are shipping production software daily. It is hard to justify if you code on weekends only. I would like to see a usage-based tier – the API pricing model applied to Claude Code, where you pay for what you consume rather than a flat rate.

The skill system could also be shareable. Right now, every user writes their own skill files. A community registry of skills for common platforms (k3s, Terraform, Ansible, Django, Rails) would accelerate onboarding significantly. The skills are just markdown files with prompts – there is no technical barrier to sharing them.

Finally, Claude Code needs better integration with CI/CD. It can run tests locally, but it cannot trigger a GitHub Actions workflow and wait for the result. I end up switching to the terminal to run gh workflow run and check status manually. An MCP server for GitHub Actions would close this loop.

Bottom Line

If you write code in one file at a time and your primary need is autocomplete, keep Copilot. If you manage infrastructure, debug across multiple services, write tests in bulk, or do any work that requires understanding a codebase rather than a single file, Claude Code is a different category of tool. The $100/month is the best money I spend on developer tooling.