My AI Coding Stack: A 2025 Retrospective

A developer's real-world look at using Cursor, Claude Opus 4.5, and Gemini-3 for shipping production code.

Two versions available: Read the AI-formatted version (default) for better structure and readability, or switch to my original thoughts below. (Original is my raw thoughts put into notes without sections or headings, just long paragraphs)

As we close out 2025, I wanted to share my experience with the current landscape of AI coding tools. My experience might differ completely from yours depending on your stack, so let’s start there.

The Context: My Tech Stack

I am a full-stack web developer building simple, functional products. TypeScript is the only language I work comfortably in, alongside the necessary HTML/CSS.

  • Frontend: Next.js or Astro.
  • Backend: Mostly Next.js API routes. For standalone APIs, I reach for Bun or Express.
  • Database: Postgres with Drizzle ORM (my default for almost everything).
  • UI: Shadcn/ui.

I haven’t given much thought to “no-code” or “low-code” products like Lovable, Replit, Bolt, or v0. While they are fun to try out, I am not their target user. I prefer full control over my environment.


The Daily Driver: Cursor

Cursor has been my default IDE for the entire year. While my recent experience has been marred by some bugs, it honestly still offers the best-in-class auto-complete experience.

When I want to write code myself but need intelligent suggestions, Cursor is unbeatable. Its codebase indexing is superior to the competition, making context retrieval very accurate.

  • Plan Mode: This is great for mapping out what you want to do before implementation, though it can be buggy.
  • Composer-1 Model: I use this on the simple pro plan. It has no rate limits and is perfect for single-file tasks or small tweaks.

The Heavy Hitters: OpenAI vs. Claude

OpenAI Codex (GPT-5)

When OpenAI released the GPT-5 Codex model, it was the king of UI development. I used it almost exclusively for a while because of its design sensibilities.

  • The Good: Best UI and design capabilities.
  • The Bad: It is incredibly slow. It “thinks” a lot. In my experience, running tasks in Codex would take 20+ minutes on average. The latency eventually made for a poor developer experience.

Claude Code (Opus 4.5)

For most of the year, I avoided Claude Code because I was already paying for Cursor and OpenAI. But with the launch of Opus 4.5, I had to switch.

I’ve tried accessing Opus 4.5 via various tools (Antigravity, Kiro), but the native Claude Code CLI gives the best experience.

  • The Magic: Opus 4.5 simply does not fail. I can give it complex tasks spanning 5 to 20 files, and it implements them correctly on the first try. It is the only model I trust for deep architectural logic.
  • The Cost: It is expensive and has a surprisingly short context window. I often burn through the context limits in the planning phase alone.
  • My Rule: I almost never ask Opus to do design or UI tweaks. It’s too expensive for that. I save it for “must-work” feature implementations.

The Specialists: Gemini & Kiro

Gemini-3 (Flash & Antigravity)

There was a lot of hype on X about Gemini-3 before release, and it didn’t disappoint. It has become my go-to for visual work.

  • Antigravity: My initial experience with the Antigravity was horrible—it was buggy and would generate incomplete, boring landing pages. However, it has improved significantly.
  • Gemini-3-Flash: This is the sweet spot. It creates excellent designs and almost never hits rate limits. For static landing pages, I now prefer using Antigravity powered by Gemini-3-Flash.

Kiro (Spec-Driven Development)

I wasn’t interested in Kiro initially, but their “spec-driven” approach is useful for specific workflows. I mostly used it because I had free credits for Opus 4.5 on the platform.

Kiro shines when I need a verified, step-by-step implementation (e.g., adding a complete Auth system):

  1. It generates a design doc (choosing libs, auth modes).
  2. It implements the DB schema (which I verify).
  3. It adds the API routes (which I verify).
  4. It adds the Frontend components.

Unlike Claude Code, which creates a plan and executes everything at once, Kiro allows me to check the code at every stage.


My Workflow: End of 2025

So, how does this all fit together?

  1. Default: I open every project in Cursor.
  2. UI Iteration: If I need to redesign a UI and iterate 3-5 times, I use Gemini-3-Flash (via CLI or Antigravity).
  3. Complex Features: For new feature development, Opus 4.5 via Claude Code is the default.
    • I ask it to make a plan and write it to my repo.
    • I read and tweak the plan manually.
    • Implementation hack: If the plan is straightforward, I ask the cheaper models in Cursor to implement it to save Claude rate limits. If it’s critical to get it right immediately, I let Opus 4.5 handle the implementation.
  4. Code Review: I use Cursor’s Bugbot. It auto-reviews PRs and is great at catching fine details, like broken links or easy-to-miss logic errors.