Over the past year I have used AI coding assistants more and more: GitHub Copilot, Cursor, Claude Code, and a few others. They do improve productivity, but not in the magical way marketing posts describe. This is a more practical note about where AI actually helps, where I do not trust it, and how I split work with it now.
What AI Is Really Good At
If I had to summarize the value in one phrase, it would be "fast lookup." Humans are slow and annoyed by this kind of work; AI is fast enough to make it feel almost free.
For example:
- You vaguely remember an API but not the exact name. Asking AI is faster than digging through docs.
- You do not understand a piece of unfamiliar code. A quick explanation can save half an hour.
- You need boilerplate: CRUD endpoints, form validation, simple unit tests. Let AI draft it, then edit.
- You have a confusing error message. If you give the error and the code to AI, it can often point to the problem directly.
The IT Revolution study mentions a 26% productivity improvement from AI coding assistants. In simple tasks, my own feeling is that the speedup can be more than 50%. But as soon as the task becomes complex, the speedup drops close to zero, and sometimes becomes negative.
What AI Is Bad At
The short version: it struggles when the task requires real judgment.
- Business logic design. AI does not understand the history and intuition behind your product. It can produce pretty code that is wrong for your actual business rules.
- Cross-file consistency. AI only sees the current context window. It may miss existing utilities and create a duplicate abstraction.
- Architecture decisions. Whether to split a service, add Redis, or change frameworks is not a question you can safely outsource to a generic answer.
- Boundary conditions. AI-generated code often forgets null checks, empty arrays, concurrent calls, and permission edge cases.
My Current Workflow
I have settled into a simple division of labor.
- For complex tasks, I think first and let AI draft later. I decide what needs to be built, the inputs and outputs, the edge cases, and what existing code should be reused. Then I ask AI for a first pass.
- For repetitive tasks, AI drafts and I normalize. If I need ten similar CRUD endpoints, I let AI generate the skeleton and then adjust them consistently.
- For unfamiliar areas, AI accelerates the first hour. If I am learning a new library, an AI-generated minimal example can be faster than reading the whole doc site. But for production code, I still check official docs.
- For critical code, AI does not write the final version. Money, permissions, migrations, and security-sensitive logic are my job. AI can review them, but I do not let it own them.
A Real Counterexample
Recently I asked an AI assistant to add debounce logic to a React component. It produced this:
function SearchBox({ fetchResults }) {
const [query, setQuery] = useState('')
const debouncedSearch = useMemo(
() => debounce((q) => fetchResults(q), 300),
[]
)
return <input onChange={(e) => debouncedSearch(e.target.value)} />
}
At first glance it looks fine. But there are two bugs. First, the empty dependency array means the debounced function is never cleaned up, so timers can leak after unmount. Second, fetchResults comes from props but gets captured from the first render, so if the parent passes a new version later, the debounced callback still uses the old one.
A better solution should clean up the debounce with useEffect, or use a tested useDebounce hook. The scary part is that the AI version looks correct if you scan it quickly. That is why I say AI is weak at complex logic: its wrong code often looks plausible until the bug shows up three days later.
Bottom Line
AI coding assistants are not magic. They are good axes: very useful for chopping wood, terrible for designing the house. Once you understand their boundaries and give them the right kind of work, the productivity gain becomes real.