Using AI Coding Assistants Effectively: Patterns That 10x Productivity and Patterns That Waste Time

I use AI coding assistants (GitHub Copilot, Claude, Cursor) daily. They are not uniformly helpful. Some tasks: 10x faster with AI. Other tasks: slower with AI than without (because you spend time correcting AI output that was faster to write yourself).

Here are the specific patterns where AI genuinely accelerates my work and the patterns where I have learned to skip AI and write it myself.

Where AI Excels: Boilerplate and Repetitive Code

Writing the 15th React component with the same structure: props interface, component function, return JSX, export. AI generates this in seconds. The pattern is well-established. The output is correct 95% of the time.

Similarly: test boilerplate (describe block, setup, teardown, standard assertions), API route structure (request parsing, validation, response formatting), database queries (Prisma findMany with common filters and includes), and configuration files (ESLint, Tailwind, TypeScript configs).

For these: describe what you want in a comment or prompt. Accept the output. Minor tweaks if needed. Total time: 30 seconds instead of 3 minutes. Genuine productivity gain.

Where AI Excels: Unfamiliar APIs and Syntax

When I need to use an API I have not used before: AI provides a working starting point faster than reading documentation.

Example: "Write a function that uses the Stripe API to create a checkout session with a monthly subscription product." AI generates code that: imports the right package, uses the current API version, includes the required parameters, and handles the response correctly.

I still verify against documentation (AI can be outdated or subtly wrong). But the starting point saves 15-20 minutes of documentation reading for common patterns.

Where AI Excels: Code Transformation

Refactoring a block of code from one pattern to another: AI handles this well because the transformation is mechanical.

Examples: converting a class component to a function component, converting callback-based code to async/await, converting a switch statement to an object lookup, changing variable naming from camelCase to snake_case, and adding TypeScript types to untyped JavaScript.

These are deterministic transformations. AI applies them correctly and quickly.

Where AI Fails: Complex Business Logic

When implementing business logic with multiple interacting rules, edge cases, and domain-specific requirements: AI produces plausible-looking code that is subtly wrong.

Example: "Implement the billing calculation that accounts for: pro-rated charges, trial periods, discount codes, tax rates by jurisdiction, and refund handling." AI generates code that looks reasonable. But: the proration calculation has an off-by-one error. The trial period interaction with discount codes creates impossible states. The tax calculation uses the wrong jurisdiction logic.

You spend 30 minutes verifying and fixing AI output that you could have written correctly in 20 minutes. The "help" was net negative.

Where AI Fails: Architecture Decisions

Asking AI to design your system architecture: you get generic advice that does not account for your specific constraints, team size, traffic patterns, and existing infrastructure.

"Should I use microservices or a monolith?" AI gives a balanced answer covering both options. But: the right answer for YOUR situation depends on context that AI cannot fully understand from a prompt.

For architecture: use AI to explore options ("what are the tradeoffs of X vs Y?"), but make decisions based on your own judgment and domain knowledge.

Where AI Fails: Debugging Complex Issues

Simple bugs (null reference, missing import): AI fixes instantly.

Complex bugs (race condition that occurs under specific timing, memory leak in a long-running process, intermittent test failure): AI often makes things worse. It suggests fixes that address symptoms, not root causes. The suggested fix might mask the bug without resolving it.

For complex debugging: use AI as a rubber duck (explain the problem to it, generate hypotheses). But verify every suggestion carefully. Do not apply AI-suggested fixes without understanding why they work.

Effective Prompting Patterns

Pattern 1 — Be specific: "Write a function" → bad. "Write a TypeScript function that takes a list of Tool objects and returns them grouped by category, where each category key maps to an array of tools sorted by rating descending" → good. Specificity reduces ambiguity and improves output quality.

Pattern 2 — Provide context: include relevant type definitions, explain the surrounding code, and describe constraints. "This function is called from a Next.js API route. The Tool type has these fields: [list]. The function should handle the case where category is null."

Pattern 3 — Iterate: if the first output is close but not right, describe what is wrong and ask for correction. AI improves with feedback. "This is close, but it should handle the empty array case by returning an empty object, not throwing."

Pattern 4 — Verify, then trust: for the first use of a pattern with AI, verify the output thoroughly. Once you have confirmed AI handles this type of task correctly: trust it for subsequent similar tasks. Build a mental model of what AI does well versus poorly.

The Meta-Skill: Knowing When to Use AI

The skill that maximizes AI productivity: recognizing which tasks benefit from AI assistance and which do not. This develops through experience.

Quick heuristic: if the task is primarily about structure, syntax, or well-known patterns: AI helps. If the task is primarily about logic, domain knowledge, or novel architecture: AI hinders (or requires careful verification that negates the time savings).

The Efficiency Trap

AI makes it easy to generate large amounts of code quickly. This creates a temptation: generate first, understand later. This is dangerous because: code you do not understand is code you cannot debug, AI-generated code can contain subtle bugs that manifest later, and maintaining code you did not think through is painful.

The discipline: only accept AI output you fully understand. If AI generates 50 lines and you do not understand lines 23-31: stop. Understand those lines before committing. The speed gain of AI means nothing if you cannot maintain the code it produces.

My Daily Usage Pattern

Morning coding session: use AI heavily for boilerplate (new components, test files, API routes). The structure is established. AI fills it in.

Complex feature development: write the logic myself. Use AI for the repetitive parts around the logic (validation, error handling, response formatting). Do not use AI for the core algorithm or business rules.

Code review and debugging: minimal AI usage. Reading and understanding code requires human attention. AI cannot meaningfully review a PR in context.

Documentation and comments: AI drafts, I edit. AI is good at generating documentation structure. But the specific explanations of WHY decisions were made require human knowledge.

The Honest Assessment

AI coding assistants make me roughly 30% faster overall. Not the 10x that marketing claims. The distribution: some tasks are 5-10x faster (boilerplate, transformations, familiar patterns), some tasks are unchanged (complex logic, architecture, debugging), and some tasks are slower (when I trust AI output that is wrong and spend time fixing it).

The 30% improvement is still significant — it compounds daily. But it requires discipline: knowing when to use AI, when to skip it, and when to verify carefully. The developers who benefit most from AI are those who already know how to code well — they can evaluate AI output and catch mistakes. AI amplifies existing skill more than it replaces missing skill.