There’s a lot of noise about AI coding tools. Every week brings a new “revolutionary” assistant that will “replace developers.” Most of it is marketing nonsense.

But buried in the hype are tools that genuinely change how you work. I’ve been a professional developer for fifteen years, and my workflow has shifted more in the last eighteen months than in the previous decade.

Here’s what’s actually worth your time.

Coding Assistants: The Core Decision

You need one of these. The productivity difference between “using AI assistance” and “not using AI assistance” is now too large to ignore.

GitHub Copilot remains the default choice for a reason. It’s integrated into every major editor, the suggestions are consistently good, and at $10/month it’s cheap enough to not think about. For most developers, this is the right answer.

Cursor is what I use when I want more power. It’s not just autocomplete—it’s an IDE built around AI from the ground up. The ability to make multi-file changes by description (“refactor authentication to use JWT”) is genuinely transformative.

The learning curve is steeper. You’re switching IDEs. But if you do complex refactoring or work across large codebases, Cursor’s Composer feature alone justifies it.

Codeium is free and good. Not quite Copilot level, but close. If budget matters or you philosophically object to paying for what should be infrastructure, it’s a legitimate option.

Amazon CodeWhisperer wins if you’re deep in AWS. It understands Lambda context, IAM policies, and CloudFormation in ways the others don’t. Outside AWS, it’s mediocre.

My setup: Cursor for complex projects, Copilot in VS Code for quick scripts. Yes, I pay for both.

Beyond Autocomplete: Chat and Understanding

Autocomplete is just the beginning. The chat interfaces are where AI gets genuinely useful.

Copilot Chat integrates directly into VS Code. Highlight code, ask questions, get explanations. “Why might this cause a race condition?” or “Generate unit tests for this function” right in your editor.

Claude (the API or Pro subscription) has become my rubber duck. It’s better at nuanced technical discussions than any other model I’ve tried. When I’m architecting something complex and need to think through tradeoffs, Claude catches edge cases I miss.

ChatGPT with GPT-4 is still strong for general coding questions, but I find Claude more reliable for code that actually runs correctly on the first try.

The key insight: These aren’t replacements for thinking. They’re amplifiers. I use them most when I’m learning new frameworks or debugging unfamiliar code. My own expertise hasn’t atrophied—if anything, it’s grown because I can explore more territory.

Documentation: Finally Solved

Documentation has always been the thing developers hate and users need.

Mintlify generates documentation from code. It’s not perfect—you’ll still need to edit—but getting 70% of docs automatically changes the calculus. Suddenly documentation isn’t a massive time investment, so it actually happens.

Notion AI helps write technical docs, READMEs, and internal wikis. Give it bullet points, get prose. It understands technical content better than most tools.

Grammarly (yes, really) catches errors in documentation, commit messages, and code comments. Developer writing often suffers because we’re not trained writers. Grammarly fills that gap.

For API documentation specifically, Swagger/OpenAPI combined with tools like Readme auto-generate interactive docs from your specs. Less writing, better results.

Testing: The Tedious Part Automated

Unit tests are valuable. Unit tests are also tedious to write. AI handles this beautifully.

Copilot and Cursor can both generate tests from code. “Write comprehensive unit tests for this function” gets you something usable about 70% of the time.

Codium AI (different from Codeium) specializes in test generation. It analyzes your code, identifies edge cases, and generates tests that actually find bugs. The quality is noticeably better than general-purpose assistants for this specific task.

For end-to-end testing, Testim and Functionize use AI to create and maintain tests. When your UI changes, the tests adapt instead of breaking. If you’ve ever maintained a brittle Selenium test suite, you understand why this matters.

Code Review: A Second Set of Eyes

CodeRabbit does AI-powered code reviews. It catches bugs, suggests improvements, and explains potential issues in pull requests. It’s not a replacement for human review—context and judgment still matter—but as a first pass, it catches things humans miss.

Sourcegraph Cody understands your entire codebase and can answer questions about it. “Where is authentication handled?” or “What functions call this method?” with answers that understand your specific code.

The value isn’t replacing code review. It’s augmenting it. AI catches the mechanical stuff; humans focus on architecture and design decisions.

DevOps and Operations

Kubiya and similar tools let you manage infrastructure through natural language. “Scale the production cluster to 5 nodes” instead of writing YAML and kubectl commands.

Pulumi now has AI assist for generating infrastructure code. Describe your architecture, get Terraform or CloudFormation. It’s not perfect but it’s a great starting point.

For incident response, Datadog and New Relic have AI features that correlate alerts and suggest root causes. During a 3 AM outage, having AI say “This looks similar to the incident on January 15th, which was caused by a database connection leak” is genuinely helpful.

The Honest Truth About Productivity

Here’s my actual experience: AI tools have increased my productivity by maybe 30-40%. Not 10x. Not “revolutionary.” But 30-40% is massive when compounded across every working hour.

Where the time goes:

• Boilerplate: Nearly eliminated. Config files, CRUD operations, repetitive patterns—AI handles these.
• Documentation: Cut in half. First drafts are automatic.
• Testing: Cut by 60%. Tests still need review, but generation is fast.
• Debugging: Maybe 20% faster. AI helps narrow down issues but still requires human judgment.
• Architecture and design: No change. This is still entirely human.

The developers who claim AI made them “10x productive” were either doing something very repetitive or are exaggerating.

What I Don’t Use

AI agents that work autonomously (like Devin). They’re impressive demos but not reliable for production work yet. Too much supervision required.

AI for security-critical code. Authentication, encryption, anything involving user data—I write and review this myself. The stakes are too high for AI mistakes.

Generated code without review. Everything AI produces gets read before it runs. The time savings come from not writing from scratch, not from trusting blindly.

The Developer Stack

My current setup:

• Cursor: $20/month (primary IDE for complex work)
• GitHub Copilot: $10/month (for VS Code quick tasks)
• Claude Pro: $20/month (rubber duck debugging, architecture discussions)
• Mintlify: $40/month (documentation)
• Codium AI: Free tier (test generation)

Total: about $90/month

For a professional developer, this is trivial compared to salary. If it saves an hour a week—which it saves much more than—the ROI is absurd.

The Bigger Picture

AI tools have raised the floor for developer productivity, not the ceiling. Junior developers with good AI tooling can now do what mid-level developers did three years ago.

But senior developers haven’t become obsolete. If anything, the gap between “can write code” and “can architect systems” has widened. AI handles the former; humans remain essential for the latter.

The developers thriving right now are the ones who’ve integrated AI into their workflow without losing the critical thinking that makes them valuable. They use AI for leverage, not replacement.

That’s the game. Play it well.

---

Developer tools are moving fast. I’ll update this as the landscape shifts.