Claude vs GPT-4 vs Copilot: What I Use When

Commit 1: Fix method name in file A
→ New error in file B (calls renamed method)
Commit 2: Fix file B
→ New error in file C (type mismatch)
Commit 3: Fix file C
→ New errors in files D, E, F (dependency chain)
...
Commit 30: Still broken

# Step 1: Understand all breaking changes (30 min)
- save() → db_save()
- client field → client() method
- RepositoryError → EventStoreError

# Step 2: Batch fix (45 min)
rg "\.save\(" -t rust | xargs sd '\.save\(' '.db_save('
rg "\.client\b" -t rust | xargs sd 'self\.client' 'self.client()'
# Add error type conversions

# Step 3: Verify (15 min)
cargo check --workspace  # ✅ Clean
cargo test --workspace   # ✅ 142 tests passing

Breaking change needed:
├─ Use Claude: Design migration plan
├─ Use human: Execute batch fixes
└─ Use Claude: Verify result

// I write test 1:
#[tokio::test]
async fn test_subscription_activated_creates_bundle() {
    let svc = setup_test_service().await;
    let event = SubscriptionActivatedEvent { /* ... */ };
    svc.handle(event).await.unwrap();
    assert_bundle_created(&svc, "bundle_id").await;
}

// Copilot suggests test 2 (I just accept):
#[tokio::test]
async fn test_subscription_cancelled_deactivates_bundle() {
    let svc = setup_test_service().await;
    let event = SubscriptionCancelledEvent { /* ... */ };
    svc.handle(event).await.unwrap();
    assert_bundle_deactivated(&svc, "bundle_id").await;
}

// And test 3, 4, 5... all following same pattern

Task: Implement usage metering pipeline
Claude's code: 85% correct, needed 15% tweaks
Claude's documentation: 100% usable, zero changes needed

The code had bugs. The documentation was perfect.

Me: "Should I use event sourcing for user authentication?"

Claude: "Here's how you could implement event sourcing for auth..."
[Proceeds to design event-sourced auth system]

GPT-4: "No. Authentication needs fast reads (every request) and event
sourcing optimizes for writes. Use traditional state-based auth with
audit logging if you need history."

// I write:
let config = load_config()

// Copilot suggests:
let config = load_config().unwrap();

// What I want:
let config = load_config()
    .context("Failed to load config")?;

Task: Design API visibility filtering for SDK generation

Claude approach (200K context):
- Load entire API route definitions (127 routes)
- Load existing SDK generation code
- Load documentation on visibility requirements
- Design complete solution in one session

GPT-4 approach (128K context):
- Session 1: Understand requirements
- Session 2: Design approach (re-explain context)
- Session 3: Plan implementation (re-explain context again)

Claude: 1 session, 3 hours, $4
GPT-4: 3 sessions, 5 hours, $8

Winner: Claude (context is king)

Typical design session context:
- File tree (5K tokens)
- 10 relevant files (40K tokens)
- 3 ADRs (15K tokens)
- Requirements doc (10K tokens)
- Conversation history (30K tokens)
Total: 100K tokens

Claude: Fits comfortably
GPT-4: Hitting limits, need to summarize or split session

// Complex trait hierarchy with associated types
trait Repository<E: Event> {
    type Aggregate: Aggregate<Event = E>;
    type Error: std::error::Error;

    async fn save(&self, aggregate: &Self::Aggregate) -> Result<(), Self::Error>;
}

// Claude understands this on first try
// GPT-4 sometimes confuses associated types with generics

Session type: Design
Tool: Claude Sonnet
Tasks:
- Review yesterday's progress
- Design today's features
- Create ADRs for major decisions
- Plan implementation approach

Cost: $2-4 per session
Output: Planning documents, architecture decisions

Tool: GitHub Copilot (running continuously)
Tasks:
- Write code with autocomplete
- Generate boilerplate
- Quick fixes

Cost: $0 (subscription)
Value: Massive time savings on mechanical coding

Session type: Review
Tool: Claude Sonnet
Tasks:
- Review today's PRs
- Verify test coverage
- Check for edge cases
- Generate verification report

Cost: $1-3 per session
Output: Review comments, test suggestions

Session type: Documentation + Planning
Tool: Claude Sonnet
Tasks:
- Document this week's decisions (ADRs)
- Update architecture diagrams
- Plan next week's work
- Generate learning summaries

Cost: $3-5
Output: Documentation, session notes, planning docs

Budget: $40/month
- GitHub Copilot: $10/month
- Claude Sonnet: $30/month pay-as-you-go usage

ROI: 30-40 hours saved per month
Equivalent value: $1,200-1,600 (at $40/hour)
Actual cost: $40

Return: 30-40x

Budget: $210-270/month
- GitHub Copilot: $10/month
- Claude Sonnet: $180-220/month (heavy usage)
- GPT-4: $20-40/month (occasional)

ROI: 60-80 hours saved per month
Equivalent value: $2,400-3,200 (at $40/hour)
Actual cost: $210-270

Return: 9-15x

// Copilot suggests:
let result = data.iter().map(|x| x.unwrap()).collect();

// Beginner: "Looks good!" (compiles)
// Experienced: "This panics if any item is None. Bad suggestion."