I've tried roughly fifty AI developer tools across the last two years. Most are gimmicks. A small set are genuinely transformative, and they all share one property: they make me faster at things I was already good at, instead of pretending to make me good at things I wasn't. My current daily stack is Claude (primary assistant, both Claude.ai and Claude Code), Cursor for in-editor edits when I want a graphical workflow, Lovable for rapid full-stack prototypes, and a few specialized tools (NotebookLM, ChatGPT for a second opinion, GitHub Copilot for autocomplete) that fill specific gaps. What didn't stick: AI-generated tests that look right but test nothing meaningful, AI code-review bots that drown signal in false positives, and AI project managers that are great at brainstorming and useless at actual project management. The meta-lesson: AI tools augment skill; they don't replace it. The developers who'll thrive over the next five years are the ones who know exactly when to reach for AI and when to think for themselves.
I've tried dozens of AI tools over the past two years. Most are gimmicks dressed up with good marketing. A few are genuinely transformative — they change how I work, not just how I look. Here's what survived contact with my daily workflow, ranked honestly by how much value they actually deliver versus how much they claimed they would.
My primary AI assistant for coding, writing, thinking, and most things in between. I use both Claude.ai for general work and Claude Code for terminal-based development. The combination handles, on any given week:
What makes Claude different from the alternatives, in my experience: it reads my entire codebase when I let it, understands context across files, and writes code that fits the patterns I've already established instead of generic boilerplate. It's also the only assistant that has consistently been willing to tell me my approach is wrong, which is the most underrated property of a useful collaborator.
The newer Claude Code workflow — running Claude as an autonomous agent in the terminal, giving it goals instead of step-by-step instructions — has shifted what's possible. I now routinely set Claude on a multi-hour task while I work on something else, and it shows me a diff at the end. That's not a marginal improvement over "AI autocomplete." It's a different category of tool.
AI-native code editor based on a fork of VS Code. The tab-completion is good — better than Copilot, in my experience — but the real value is Cmd+K for inline edits and the chat panel for asking questions about the codebase. When I want a graphical workflow with file diffs and a familiar editor, Cursor is what I reach for.
Where Cursor shines: targeted edits where you say "make this function async and update the callers" and watch it propagate the change across files correctly. Where it doesn't: long autonomous work where Claude Code's terminal-driven workflow is cleaner.
My secret weapon for rapid prototyping. I describe what I want, Lovable generates a working React + Supabase app, and I customize from there. It's cut my initial setup time from hours to minutes, and the generated code is genuinely usable as a starting point — not a sandbox demo.
Typical workflow: a client describes an app, I scaffold it in Lovable overnight, pull the code locally the next morning, replace the generic UI with their brand, fix anything that won't scale, and ship. Project that used to take three weeks now takes one.
The limitation: Lovable's UI is competent but generic, and the architecture decisions it makes are sensible but not opinionated. Anything that needs to feel like a specific brand or that needs unusual architectural choices needs serious hand-finishing after.
For grounded research, document Q&A, and turning long source material into navigable knowledge. I use it to ingest specs, client documents, RFP responses, and academic papers, then query against them. The audio overview feature — generating a podcast-style discussion of a document — is occasionally useful for getting a second pass through dense material.
Not an AI tool itself, but AI-generated TanStack Query hooks are remarkably good. The pattern is consistent enough that AI nails the shape every time: define the query key, write the queryFn, handle errors at the boundary, generate corresponding mutations with optimistic updates. I now write almost no data-fetching code by hand.
Still useful for autocomplete, especially for repetitive patterns where you don't want to engage a full conversation. But Claude Code has replaced most of what I used Copilot for, and the value gap has narrowed enough that I sometimes consider dropping the subscription.
I keep ChatGPT around specifically for cases where I want a second model to weigh in on a decision Claude already made. Two models agreeing makes me more confident; two models disagreeing makes me think harder. The diversity is worth the second subscription.
For UI component generation when I don't want to fight Tailwind. I describe a component, get back a working React + Tailwind implementation, and adapt. Not part of my daily flow, but the right tool when I need a specific component shape fast.
For research where I want web-grounded answers with citations. Not a replacement for proper search, but better than vanilla ChatGPT or Claude when I need facts that may have changed recently and I want to verify them quickly.
For transcribing meetings, podcasts, and voice notes. The transcription quality on Arabic is genuinely surprising — it handles dialects better than any other tool I've tried, which matters a lot when working with clients in Damascus or Riyadh.
For terminal-based agentic coding when I want something lighter than Claude Code. Less polished, less integrated, but useful for specific tasks where Claude Code feels like overkill.
I don't use any of these tools in isolation. A typical flow when I'm building a feature:
The flow that ships fastest in my experience is "AI does the volume, human does the judgment." Any flow that tries to flip that ratio produces output that looks fine but breaks in surprising ways.
AI tools work best when they augment a skill you already have. If you're a good developer, AI makes you faster, helps you ship things that would otherwise sit on a backlog forever, and frees you from the parts of the job that were always boring. If you're learning, AI can absolutely teach you — but you have to understand what it generates and why, not just accept it.
The trap I see junior developers fall into: using AI to skip the parts of learning that are uncomfortable. The discomfort is the learning. AI that helps you avoid it is, in that specific case, hurting you.
The developers who'll thrive over the next five years are the ones who know exactly when to use AI and when to think for themselves. That's a skill, and it's being trained right now by everyone who uses these tools intentionally instead of compulsively.
Right now, in 2026, the tools above are my answer. By 2028 the list will look different. The meta-skill — picking the right tool for the work in front of you — is the only thing that'll still be valuable then.