AI Tools That Actually Help Me Code Better

Introduction

There's a lot of noise around AI coding tools right now. Some developers swear by them, others find them more hindrance than help, and a vocal minority treats using them as a personal failing. My view is more pragmatic: these are tools, and like any tool, their value depends entirely on how you use them.

After integrating AI tools into my daily workflow for over a year across TypeScript, Node.js, Next.js, and C projects, I have a clear picture of what actually helps, what doesn't, and where the real leverage is. This isn't an endorsement of any particular product — it's an honest account of where AI assistance makes me noticeably faster and where it doesn't.

Core Concepts

The Right Mental Model for AI Coding Assistance

The biggest mistake developers make with AI coding tools is treating them as search engines for code. If you're using them to paste in a question and expect a perfect answer, you'll be disappointed often. The better mental model is pair programming with a very fast junior developer who knows a lot but makes mistakes and needs direction.

• Can implement boilerplate rapidly
• Knows syntax and APIs across many languages
• Makes logical errors under complex constraints
• Needs you to review their output
• Benefits enormously from specific, context-rich prompts

With that model, you stop being surprised by hallucinated APIs or subtly wrong logic, and you start extracting real productivity from the tools.

Tools I Actually Use

GitHub Copilot (In-Editor Completion)

Copilot in VS Code is the AI tool I use most consistently, because it's always present. It doesn't require context switching — suggestions appear as ghost text while I type and I press Tab to accept.

Where it genuinely helps:

• Repetitive patterns within a file
• Test case completion
• Regex

// I write this, Copilot completes the rest
export async function getUserById(id: string): Promise<User | null> {
  // Copilot: return db.user.findUnique({ where: { id } });
}

// Match ISO 8601 date strings like 2024-01-15
const dateRegex = /^d{4}-d{2}-d{2}$/;
// Copilot generates this from the comment above

Where it doesn't help:

• Complex business logic, security-sensitive code, and anything that requires understanding your broader system architecture

Chat-Based AI for Problem Decomposition

This is where I've found the most leverage: talking through problems before writing code. Before implementing a non-trivial feature, I describe the requirements, data shapes, and constraints to an AI assistant. The conversation often surfaces edge cases I hadn't considered and helps me settle on an approach before I've written a line.

This is fundamentally different from "write me this code." It's closer to rubber duck debugging but with a duck that asks useful questions.

"I need to implement a rate limiter in Express. It needs to be per-user (based on JWT userId), support different limits for different endpoint types, and store state in Redis. I'm using TypeScript. Before writing code, what are the main design decisions I need to make?"

AI for Explaining Unfamiliar Code

When I encounter code in an unfamiliar language, library, or paradigm, AI explanation is faster than documentation in many cases. Paste in a C function with manual memory management, ask what it does step by step, and get a plain English explanation in seconds.

static inline uint32_t hash_fnv1a(const char *str) {
  uint32_t hash = 2166136261u;
  while (*str) {
    hash ^= (uint8_t)*str++;
}