•5 min read

How I Actually Use ChatGPT, Claude, and Gemini for Development Work

How I Actually Use ChatGPT, Claude, and Gemini for Development Work

Every few months someone asks me which AI tool is "best." The answer depends entirely on what you're doing. I use all three, for different things, and none of them replaces thinking.

Here's my honest breakdown after a year of using them daily for development work.

Audio Briefing
0:00 / 0:00

What Each One Is Good For

ChatGPT: Best for open-ended coding tasks where I need a quick script or boilerplate. GPT-5's code output is solid for one-shot generation: "write me a Python script that does X." I reach for it when I know exactly what I want and just need it typed out.

Claude: Better at reasoning through messy problems. When I have a half-baked idea and need to talk through the design before writing code, Claude's longer context window means I can paste in the relevant files and get a coherent analysis. I use it for architecture discussions, code review, and refactoring.

Gemini: The Google ecosystem integration is genuinely useful. I use it when I need to pull real-time information: documentation lookups, API reference checks, current pricing. It reads web pages natively in a way the others still struggle with.

My Default Workflow

Quick code generation → ChatGPT. Design/refactoring → Claude. API docs and web lookups → Gemini. Each covers a gap the others don't.

Advertisement

Where They All Fall Short

The same limitations across all three:

  • They hallucinate APIs. Every model confidently invents function signatures. I've had ChatGPT write me Stripe code using methods that don't exist. Always check the docs.
  • They flatten your thinking. If you ask for a solution, you get the most statistically common answer, not the best one for your specific situation. You have to prompt for alternatives explicitly.
  • Context is still too short for real codebases. Even with 200K tokens, you can't fit a meaningful project. You're always cherry-picking files to include, which means the AI is missing half the picture.

How to Actually Get Good Results

The single most important skill is writing a good prompt. Not "prompt engineering" in the ceremonial sense: just being specific.

Instead of: "Write a login form" Try: "Write a React login form with email and password fields, using react-hook-form for validation, shadcn/ui components, and a POST to /api/auth/login. Handle loading, error, and success states."

The difference is night and day. The first prompt gets you a generic form. The second gets you something you can use.

The Real Skill

Learning to prompt well isn't about memorizing templates. It's about learning to specify. The more constraints you give, the better the output. This applies to every model equally.

What I Don't Use AI For

  • Debugging race conditions. The models don't have a mental model of time or async execution. They guess, and they're often wrong.
  • Security-sensitive code. I've seen AI suggest eval()-adjacent patterns too many times.
  • Novel problems. If I'm doing something I haven't seen done before, the AI's training data won't help. It'll give me confident-sounding wrong answers.

Pick the tool that fits the task, keep your expectations realistic, and always verify the output. Same as working with a junior developer, except this one never gets tired of code review.

Advertisement

You Might Also Like

Frequently Asked Questions

Claude 3.7 Sonnet and Claude 3.5 Sonnet demonstrate superior performance in multi-file refactoring, understanding architectural dependencies, and avoiding deprecated API calls. OpenAI models excel at single-prompt autonomous scripts, while Google Gemini 2.0 Flash/Pro leads in massive multi-modal file ingestion and documentation extraction.
Explicitly pin the library major version in your prompt (for example, 'Use Next.js 15 App Router and React 19 APIs'), provide TypeScript interface signatures in your prompt, or connect the model to live documentation using Model Context Protocol (MCP) or search tools.
Avoid dumping massive monolithic directories into the context window, which dilutes attention. Instead, use focused rules files (.cursorrules or CLAUDE.md), supply only the relevant dependency interfaces, and isolate refactoring tasks into single-module increments.
Asynchronous race condition debugging, multi-threaded timing bugs, cryptography or sensitive token handling, and zero-day framework integrations. LLMs extrapolate from existing historical patterns and frequently misdiagnose transient concurrency issues.
Focus on pull request turnaround time, cycle time, test suite coverage depth, and time-to-first-prototype rather than raw lines of generated code. Real gains come from faster test writing, scaffolding, and boilerplate elimination.
Share this article:

Stay Updated

Get the latest posts delivered straight to your inbox.

Free Developer Utilities

Free In-Browser Developer Tools

Clean AI CLI logs, build cron expressions, decode JWTs, and calculate chmod permissions offline.

Explore Tools
Advertisement