DEV Community: ミント

Why I Switched Fully from Cursor (After 6 Months) to Claude Code

ミント — Thu, 07 May 2026 10:42:10 +0000

I used all three tools in production. Ran them across real products. Spent over $60/month at my peak. The answer is clear now.
To Cursor users: this might make you switch.

The Basics: 3 Tools at a Glance (as of May 2026)

	Claude Code	Cursor	Aider
Price	$20/mo (Max) or API pay-as-you-go	$20/mo (Pro)	Free (API costs separate)
Interface	Terminal (CLI)	VSCode-based IDE	Terminal (CLI)
Model	Claude 3.5/3.7/4.x Sonnet	GPT-4o / Claude 3.5	GPT/Claude (selectable)
Context	Whole project	Per-file + @mentions	git diff + /add
Autonomy	High (agentic)	Medium (suggestion-based)	Medium (commit-unit)

I'm running 4 SaaS products solo in production right now. I've used all three tools across every part of that process. This is that comparison.

Claude Code: The Reality

How It Works

The core of Claude Code is CLAUDE.md — a file where you feed the project context. Once it's there, context carries over across sessions without any extra work.

# Project: Real Estate Video SaaS

## Stack
- Next.js 15 (App Router)
- Supabase (PostgreSQL + Auth + Storage)
- Stripe (Subscription)
- Vercel (Deploy)

## DB Tables
users / properties / videos / subscriptions / tenants

## Coding Rules
- Use Server Actions (API routes for webhooks only)
- Errors: console.error + send to Sentry
- env: centralized in lib/env.ts
- Types: generated from Database type in /types/database.ts

Say "add Stripe webhook handling" and it reads CLAUDE.md, matches your existing patterns, and outputs this:

// app/api/webhooks/stripe/route.ts
import { NextRequest, NextResponse } from 'next/server'
import Stripe from 'stripe'
import { stripe } from '@/lib/stripe'
import { createClient } from '@/lib/supabase/server'

export async function POST(req: NextRequest) {
  const body = await req.text()
  const sig = req.headers.get('stripe-signature')!

  let event: Stripe.Event
  try {
    event = stripe.webhooks.constructEvent(
      body,
      sig,
      process.env.STRIPE_WEBHOOK_SECRET!
    )
  } catch (err) {
    return NextResponse.json({ error: 'Webhook Error' }, { status: 400 })
  }

  const supabase = await createClient()

  switch (event.type) {
    case 'customer.subscription.created':
    case 'customer.subscription.updated': {
      const sub = event.data.object as Stripe.Subscription
      await supabase
        .from('subscriptions')
        .upsert({
          stripe_subscription_id: sub.id,
          stripe_customer_id: sub.customer as string,
          status: sub.status,
          current_period_end: new Date(sub.current_period_end * 1000).toISOString()
        })
      break
    }
    case 'invoice.payment_failed': {
      const invoice = event.data.object as Stripe.Invoice
      await supabase
        .from('subscriptions')
        .update({ status: 'past_due' })
        .eq('stripe_customer_id', invoice.customer as string)
      break
    }
  }

  return NextResponse.json({ received: true })
}

It picked up the lib/supabase/server import style, the subscriptions column names — all from reading the existing project files. I specified nothing.

What's Not Great

Cost is unpredictable. The Max plan is $20/month unlimited, but on API billing I've hit $10+ in a single day. Also the "confidently writes outdated APIs" problem persists. It sometimes doesn't know the latest API for newer libraries — always review before shipping.

Best for: implementing new features end-to-end, scaffolding from scratch, large refactors

Cursor: The Reality

Autocomplete and Chat Are Solid

Cursor's inline completion was the most comfortable of the three. The feeling of Tab-predicting the next line is real.

For small fixes, Cursor is fast:

// Original (loose typing)
const { data } = await supabase.from('users').select('*').eq('id', userId).single()

// Just say "tighten the types" and Cursor outputs:
const { data, error } = await supabase
  .from('users')
  .select('id, email, name, plan, created_at')
  .eq('id', userId)
  .single<Pick<Database['public']['Tables']['users']['Row'],
    'id' | 'email' | 'name' | 'plan' | 'created_at'
  >>()
if (error) throw error

Single-file edits like this feel noticeably snappier in Cursor.

Breaks Down Across Multiple Files

It's weak at grasping the full project. "Add stripe_customer_id to users table and use it in the webhook" goes like this:

# Real Cursor exchange (close approximation)
You: add stripe_customer_id to users and use it in the webhook
Cursor: Which files should I reference? Please @-mention them.
You: @lib/stripe @types/database.ts @app/api/webhooks/stripe
Cursor: Where should the migration file go?
You: supabase/migrations/
Cursor: (creates migration) Any other files that need changes?
You: ...end up doing it yourself

When I become the context-feeding assistant for large tasks, that alone costs me 20-30 minutes.

Best for: partial edits to existing code, small bug fixes, tab-completion-driven daily work

Aider: The Reality

Git Integration Is Genuinely Good

Auto-commits per change is legitimately useful. "I can roll back to exactly here" becomes concrete.

# Aider session example
$ aider --model claude-3-5-sonnet-20241022

/add app/api/webhooks/stripe/route.ts lib/stripe.ts types/database.ts

# Prompt:
# Add stripe_customer_id to users and write an upsert in the webhook

# After changes, auto-commits:
# Commit 9f3c1a2 feat: add stripe_customer_id to users and webhook upsert

And it's free (just API costs). If you're trying AI coding for the first time, Aider has the lowest barrier to entry.

Low Autonomy Is the Ceiling

When a complex task hits a wall, Aider stops. Claude Code debugs the error and retries on its own. Aider asks "what do you want to do?" Running 4 products solo, this difference shows up every single day.

Also, context resets between sessions. You restart every time by re-adding files with /add.

Best for: one-off fix tasks, first steps into AI-assisted coding

Landmines I Actually Hit (from real experience)

Only listing what I personally stepped on.

Claude Code landmines

Tried to hardcode .env.local values by guessing them — secret almost ended up in git
Reported "ran tests and confirmed" when tests hadn't actually run (happened twice)
Doesn't know the latest API for some newer libraries — need to specify the version and say "check the official README"

Cursor landmines

Ignores .cursorrules mid-task during long Composer sessions
After applying multi-file Composer changes, stale code sometimes remained
Tab completion misread a long comment and deleted it along with surrounding code

Aider landmines

Sometimes edits files you never added via /add — unintended changes end up in git
Without --model specified, falls back to an old default model
Long sessions cause it to forget instructions from earlier in the conversation

Why I Went All-In on Claude Code

Three reasons.

1. "Just handle it" works

My style is: decide the high-level spec, delegate the implementation. Claude Code takes that. Cursor asks "which part do you want to fix?" Aider asks "which files should I add?" Every interruption breaks my focus.

2. Context management disappears when running 4 products

With CLAUDE.md in each project, context carries over across sessions. With Cursor, every project switch meant re-feeding context via @filename. Ten times a day, that adds up.

3. The cost math worked out

Tool	Estimated monthly cost
Claude Code Max	$20 + API $15-30
Cursor Pro	$20
Aider	Free + API $10-20

Claude Code is the most expensive. But thinking in hourly rate terms — if 1 hour of work compresses to 20 minutes, the extra $30/month is cheap. Higher implementation speed means my own time costs less.

The Verdict: When to Use Which

Scenario	Pick
Implementing a feature from scratch	Claude Code
Partial edits to existing code	Cursor
Trying AI coding for the first time	Aider
Zero budget	Aider
Running multiple production products solo	Claude Code
Team with existing VSCode workflow	Cursor

There are people for whom Cursor is the right answer. If you're on a team and maintaining an existing VSCode setup, Cursor fits naturally. Under my conditions, Claude Code was the only call.

The question isn't "which is the best" — it's "which fits your use case."

I say this as someone who used Cursor for 6 months. No regrets switching. But I don't think everyone should. Try one week and you'll have your own answer.

Originally posted on note (Japanese): https://note.com/mintototo1/n/na615d239961f

The Complete Stripe Billing Template for Next.js: 5 Production Landmines

ミント — Tue, 05 May 2026 10:39:33 +0000

The Complete Stripe Billing Template for Next.js: 5 Production Landmines and How to Avoid Them

I spent 8 hours debugging Stripe on my first SaaS. Now I can wire it up in 30 minutes. Here's the full template with every gotcha documented.

This is what I actually use in production — not a toy demo. Copy-paste it and adapt.

The Stack

Next.js 14+ (App Router)
Supabase (auth + DB)
Stripe (subscriptions + Customer Portal)

DB Schema First

Before any code, add these columns to your profiles table:

alter table profiles
  add column if not exists stripe_customer_id text,
  add column if not exists subscription_status text default 'free',
  add column if not exists price_id text,
  add column if not exists current_period_end timestamptz;

create index if not exists idx_profiles_stripe_customer_id
  on profiles(stripe_customer_id);

Step 1: Create Customer on Signup

Landmine #1: Don't create the Customer lazily.

The temptation is to create a Stripe Customer only when the user tries to pay. Don't. Create it at signup. If you create it lazily, you'll end up with race conditions and orphaned sessions.

lib/stripe.ts

import Stripe from 'stripe'

export const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!, {
  apiVersion: '2024-04-10',
})

export async function getOrCreateStripeCustomer(
  userId: string,
  email: string
): Promise<string> {
  const { createClient } = await import('@/lib/supabase/server')
  const supabase = createClient()

  const { data: profile } = await supabase
    .from('profiles')
    .select('stripe_customer_id')
    .eq('id', userId)
    .single()

  if (profile?.stripe_customer_id) {
    return profile.stripe_customer_id
  }

  // Create and immediately persist — never leave this in memory only
  const customer = await stripe.customers.create({
    email,
    metadata: { supabase_user_id: userId },
  })

  await supabase
    .from('profiles')
    .update({ stripe_customer_id: customer.id })
    .eq('id', userId)

  return customer.id
}

Step 2: Checkout Session (Initial Payment)

Landmine #2: Pass idempotencyKey on Checkout sessions.

Without idempotency keys, a user double-clicking "Subscribe" can create two subscriptions. Always generate a key tied to the user + price combination.

app/api/stripe/checkout/route.ts

import { NextRequest, NextResponse } from 'next/server'
import { createClient } from '@/lib/supabase/server'
import { stripe, getOrCreateStripeCustomer } from '@/lib/stripe'

export async function POST(req: NextRequest) {
  const supabase = createClient()
  const { data: { user } } = await supabase.auth.getUser()
  if (!user) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })

  const { priceId } = await req.json()
  const customerId = await getOrCreateStripeCustomer(user.id, user.email!)

  const session = await stripe.checkout.sessions.create(
    {
      customer: customerId,
      mode: 'subscription',
      payment_method_types: ['card'],
      line_items: [{ price: priceId, quantity: 1 }],
      success_url: `${process.env.NEXT_PUBLIC_APP_URL}/dashboard?checkout=success`,
      cancel_url: `${process.env.NEXT_PUBLIC_APP_URL}/pricing`,
    },
    {
      idempotencyKey: `checkout-${user.id}-${priceId}`,
    }
  )

  return NextResponse.json({ url: session.url })
}

Step 3: Webhook — The Most Critical Part

Landmine #3: You MUST use req.text() for the raw body.

This is the #1 cause of webhook failures. If you use req.json(), the body gets parsed and Stripe's signature verification fails. Always read the raw text first.

app/api/stripe/webhook/route.ts

import { NextRequest, NextResponse } from 'next/server'
import { headers } from 'next/headers'
import Stripe from 'stripe'
import { stripe } from '@/lib/stripe'
import { createAdminClient } from '@/lib/supabase/admin'

export async function POST(req: NextRequest) {
  // Critical: use req.text(), NOT req.json()
  const body = await req.text()
  const signature = headers().get('stripe-signature')!

  let event: Stripe.Event
  try {
    event = stripe.webhooks.constructEvent(
      body,
      signature,
      process.env.STRIPE_WEBHOOK_SECRET!
    )
  } catch {
    return NextResponse.json({ error: 'Invalid signature' }, { status: 400 })
  }

  const supabase = createAdminClient()

  switch (event.type) {
    case 'checkout.session.completed': {
      const session = event.data.object as Stripe.CheckoutSession
      const customerId = session.customer as string
      const subscriptionId = session.subscription as string

      const subscription = await stripe.subscriptions.retrieve(subscriptionId)
      const { data: profile } = await supabase
        .from('profiles')
        .select('id')
        .eq('stripe_customer_id', customerId)
        .single()

      if (profile) {
        await supabase.from('profiles').update({
          subscription_status: subscription.status,
          price_id: subscription.items.data[0]?.price.id ?? null,
          current_period_end: new Date(
            subscription.current_period_end * 1000
          ).toISOString(),
        }).eq('id', profile.id)
      }
      break
    }

    case 'customer.subscription.updated': {
      const subscription = event.data.object as Stripe.Subscription
      const { data: profile } = await supabase
        .from('profiles')
        .select('id')
        .eq('stripe_customer_id', subscription.customer as string)
        .single()

      if (profile) {
        await supabase.from('profiles').update({
          subscription_status: subscription.status,
          price_id: subscription.items.data[0]?.price.id ?? null,
          current_period_end: new Date(
            subscription.current_period_end * 1000
          ).toISOString(),
        }).eq('id', profile.id)
      }
      break
    }

    case 'customer.subscription.deleted': {
      const subscription = event.data.object as Stripe.Subscription
      const { data: profile } = await supabase
        .from('profiles')
        .select('id')
        .eq('stripe_customer_id', subscription.customer as string)
        .single()

      if (profile) {
        await supabase.from('profiles').update({
          subscription_status: 'canceled',
          price_id: null,
        }).eq('id', profile.id)
      }
      break
    }
  }

  return NextResponse.json({ received: true })
}

Step 4: Customer Portal (Subscription Management)

Landmine #4: Configure the Portal in Stripe Dashboard BEFORE writing code.

The Portal needs to be explicitly enabled in Stripe Dashboard → Settings → Billing → Customer portal. Test mode and live mode are configured separately — I've been burned by this more than once.

app/api/stripe/portal/route.ts

import { NextRequest, NextResponse } from 'next/server'
import { createClient } from '@/lib/supabase/server'
import { stripe, getOrCreateStripeCustomer } from '@/lib/stripe'

export async function POST(req: NextRequest) {
  const supabase = createClient()
  const { data: { user } } = await supabase.auth.getUser()
  if (!user) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })

  const customerId = await getOrCreateStripeCustomer(user.id, user.email!)

  const session = await stripe.billingPortal.sessions.create({
    customer: customerId,
    return_url: `${process.env.NEXT_PUBLIC_APP_URL}/dashboard`,
  })

  return NextResponse.json({ url: session.url })
}

Step 5: Env Switching (Test vs Live)

Landmine #5: Different webhook secrets for test and live mode.

STRIPE_WEBHOOK_SECRET from stripe listen (local dev) is different from the one in Stripe Dashboard (production). I once deployed with the test secret to production and spent an hour wondering why all webhooks were failing.

# .env.local (development)
STRIPE_SECRET_KEY=sk_test_xxxx
STRIPE_WEBHOOK_SECRET=whsec_xxxx   # from: stripe listen --forward-to localhost:3000/api/stripe/webhook
NEXT_PUBLIC_APP_URL=http://localhost:3000

# .env.production (Vercel)
STRIPE_SECRET_KEY=sk_live_xxxx
STRIPE_WEBHOOK_SECRET=whsec_yyyy   # from: Stripe Dashboard → Developers → Webhooks
NEXT_PUBLIC_APP_URL=https://yourdomain.com

checkout.session.completed
customer.subscription.updated
customer.subscription.deleted

10 Rules I Follow Every Time

Create Stripe Customer at signup, not at payment time
Always use req.text() in webhook handler — never req.json()
Use idempotencyKey for Checkout sessions (user ID + price ID)
Enable Customer Portal in both test and live Stripe Dashboard
Use separate STRIPE_WEBHOOK_SECRET per environment
Store stripe_customer_id in DB immediately after creation — don't hold it in memory
Access control = subscription_status + current_period_end (not just status)
Use stripe.webhooks.constructEvent — never skip signature verification
Handle subscription.updated with status: canceled for end-of-period cancellations
Index profiles(stripe_customer_id) — you'll query by it on every webhook

What Takes 8 Hours vs 30 Minutes

The first time: figuring out raw body, Customer creation order, idempotency, environment mismatches.

With this template: copy, replace env vars, enable Portal in Dashboard. Done.

Next up: "Supabase + Vercel + Next.js: 15 Landmines" (→ #7)

Originally posted on note (Japanese): https://note.com/mintototo1/n/nc7cf608b62e4