AI Coding Assistants: A Practical Guide

AI Coding Assistants Are Here. Now What?

AI coding assistants have moved from novelty to standard tooling in a remarkably short time. GitHub Copilot, Claude, ChatGPT, Cursor, and a growing list of alternatives are now part of many developers’ daily workflows.

The discourse around these tools tends to oscillate between uncritical hype and dismissive scepticism. Neither is useful. The reality is more nuanced: these tools are genuinely powerful in specific contexts and genuinely problematic in others. Knowing the difference is what separates productive use from frustration. In my experience using these tools daily for the past two years, the key is understanding precisely where they add value and where they create risk.

What AI Assistants Actually Do Well

Boilerplate and Repetitive Code

This is where AI assistants shine brightest. Writing CRUD endpoints, form validation logic, database migration files, test scaffolding, and configuration files is tedious but necessary work. AI assistants handle it well because these patterns are well-represented in training data and follow predictable structures.

If you are writing your fifteenth React form component or your tenth Express route handler, let the AI generate the skeleton. Your time is better spent on the parts that are unique to your application.

Translating Between Formats

Need to convert a JSON schema to TypeScript interfaces? Transform a SQL query into an ORM call? Convert a REST API response into a different data structure? These mechanical transformations are perfect AI tasks. They are well-defined, have clear inputs and outputs, and require no creative judgement.

Explaining Unfamiliar Code

When you inherit a legacy codebase or encounter an unfamiliar library, AI assistants are excellent at explaining what code does. Paste a function you do not understand and ask for an explanation. The results are usually accurate and often faster than reading documentation.

Writing Tests

AI assistants are surprisingly good at generating test cases, especially when you provide the function signature and describe the expected behaviour. They often catch edge cases you might have missed, like null inputs, empty arrays, or boundary values. For more on writing effective tests, see our article on how to write tests that actually help.

Quick Prototyping

When you need to explore an idea quickly, AI assistants can generate a working prototype in minutes. This lets you evaluate approaches before committing to a full implementation. The prototype code is often throwaway, but the speed of iteration is valuable.

Where AI Assistants Fall Short

Task Type	AI Reliability	Risk Level	Recommendation
Boilerplate and CRUD	High	Low	Let AI generate, then review
Format translation	High	Low	Good AI task
Test generation	Medium-High	Medium	Review edge cases carefully
Explaining code	Medium-High	Low	Cross-reference when critical
System design	Low	High	Use AI for brainstorming only
Complex business logic	Low	High	Write manually, use AI for iteration
Security-critical code	Low	Very High	Never trust without thorough review
Performance-sensitive code	Low	High	Always benchmark AI output

System Design and Architecture

AI assistants operate at the level of individual functions or files. They cannot reason about your system as a whole. Asking an AI to “design a microservices architecture for an e-commerce platform” will produce generic advice that ignores the constraints, team size, traffic patterns, and business context that should drive those decisions.

Architecture requires understanding tradeoffs in context. AI tools lack that context. For guidance on architectural thinking, our article on the pragmatic approach to microservices covers the human judgement that these decisions require.

Complex Business Logic

When the requirements are nuanced, domain-specific, or involve complex interactions between multiple system components, AI-generated code frequently misses important edge cases. The code looks correct at first glance but fails in the scenarios that matter most.

Always be most sceptical of AI output when the problem is complex and domain-specific. That is precisely where mistakes are hardest to spot.

Security-Critical Code

AI assistants can and do generate code with security vulnerabilities. A Stanford University study ↗ found that developers using AI coding assistants produced significantly less secure code than those who did not, partly because the AI-generated code gave a false sense of confidence. Never trust AI-generated code in security-critical paths without thorough review.

Performance-Sensitive Code

AI-generated code tends to be functionally correct but not optimised. It may use naive algorithms where efficient ones are needed, or create unnecessary allocations in hot paths. For performance-critical sections, always benchmark and profile the output.

Getting the Best Results

Provide Rich Context

The quality of AI output is directly proportional to the quality of your input. Instead of asking “write a function to process orders,” try:

“Write a TypeScript function that takes an array of OrderItem objects (each with productId, quantity, and unitPrice) and returns a summary with subtotal, tax at 20%, and total. Handle the case where the array is empty by returning zeros.”

The more specific your prompt, the less you need to correct the output. For a deeper look at prompting techniques, our article on prompt engineering for developers covers the strategies that work best.

Use Your Type System

If you are working in a typed language, provide your interfaces and types to the AI. This constrains the output and dramatically improves accuracy. The AI can generate code that conforms to your existing data structures rather than inventing its own.

Iterate, Don’t Accept

Treat the first output as a draft. Review it critically. Ask for modifications. “This looks good, but can you add error handling for the database connection failing?” or “Refactor this to use the repository pattern instead of direct database calls.”

Iterative refinement usually produces much better results than trying to get the perfect output in a single prompt.

Review Everything

This cannot be overstated. Read every line of AI-generated code before it enters your codebase. Check for:

• Logic errors and missed edge cases
• Security vulnerabilities
• Performance issues
• Consistency with your codebase’s patterns and conventions
• Unnecessary complexity or over-engineering
• Incorrect or outdated API usage

This review process is essentially a code review, and the same principles apply. The SonarSource AI Code Assurance tools ↗ can help automate parts of this review for AI-generated code.

Know When to Stop

Sometimes the AI cannot produce what you need, and continuing to prompt it is less efficient than writing the code yourself. If you have spent more than 10 minutes trying to get the AI to generate a correct solution, you would likely have been faster writing it manually.

Practical Workflow Integration

The AI-Assisted Development Loop

A productive workflow with AI assistants looks something like this:

1. Think first. Understand the problem and sketch your approach before involving the AI.
2. Generate scaffolding. Let the AI handle the boilerplate and predictable structure.
3. Write the hard parts yourself. Complex logic, architectural decisions, and performance-critical code benefit from human judgement.
4. Use AI for iteration. Refactoring, adding error handling, and writing tests are good AI tasks once the core logic exists.
5. Review everything. Treat AI-generated code as you would a pull request from a junior developer.

Editor Integration

The most seamless experience comes from AI tools integrated directly into your editor. Inline suggestions reduce context switching compared to copying code from a chat window. Tools like GitHub Copilot, Cursor, and Windsurf provide this kind of tight integration. For more on optimising your editor setup, see VS Code extensions that will change how you code.

Chat-Based Tools for Exploration

For more open-ended tasks like exploring approaches, understanding tradeoffs, or learning new concepts, chat-based tools like Claude or ChatGPT are more effective. They allow for conversation, follow-up questions, and deeper exploration than inline suggestions.

The Skills That Still Matter

AI assistants amplify existing skills; they do not replace them. The developers who benefit most are those who already understand:

• Software design principles: You need to evaluate whether generated code is well-structured.
• Debugging methodology: When AI code does not work, you need to diagnose why.
• System thinking: Understanding how pieces fit together is still entirely human work.
• Code reading: Reviewing AI output quickly and accurately is a critical skill.
• Communication: Translating business requirements into clear prompts is its own skill.

Looking Forward

AI coding assistants are improving rapidly. Capabilities that were unreliable a year ago are now solid. Capabilities that seem futuristic today will likely be routine soon. For a look at where things are heading, our article on how AI agents are changing software development explores the next wave of AI-assisted tooling.

The developers who will thrive are those who learn to use these tools effectively without becoming dependent on them. Understand what they do well, compensate for their weaknesses, and keep investing in the fundamental skills that no tool can replace.

The goal is not to use AI for everything. It is to use it for the right things, so you can spend your attention on the work that genuinely requires a human mind.