2026. 05. 06. / TECH · 3 min read
AI Coding Assistants — Do They Actually Work in Practice?
Used one for a few months. Verdict: "Useful, but don't get your hopes up"
Everyone seemed to be using one, so I tried it for a few months.
Bottom line: "Useful, but don't get your hopes up"
At First, I Was Impressed
Simple tasks are genuinely fast.
Make me a function, define a type, stamp out some boilerplate — this stuff comes back almost copy-paste ready.
Speed: acknowledged.
But Complexity Exposes It Quickly
It can't follow context. It pulls in libraries that don't exist. It stitches code together and then suddenly the flow breaks.
Especially when there's an existing codebase and you say "modify this to fit here" — it looks right on the surface, but the internals are off more often than you'd expect.
That's when it hits you: "Oh, this is basically just a really good autocomplete."
So I Changed How I Use It
Instead of asking for code, I switched to asking questions.
- Is this logic structure okay?
- What could blow up here?
- Why do you think this error is happening?
This approach works much better. Less like a code generator, more like having a junior developer around who you can actually talk to. Of course, they say nonsense sometimes.
Where It Actually Delivers
Reading docs When using a new library, asking it to pull out the key points saves a lot of time. Asking "How do I implement pagination with this library?" is often faster than reading the entire official docs.
Debugging Throw an error at it and it narrows down the likely causes. Sometimes it nails it exactly. Type errors and import issues get resolved almost instantly.
Repetitive work CRUD, type definitions, test drafts — just hand these over. Typing this stuff out yourself is honestly a waste of time.
Clear No-Go Zones
| Area | Reality |
|---|---|
| Latest API versions | Gets it wrong a lot. Especially weak on breaking changes |
| Business logic | Basically can't do it. No context, so naturally |
| Security code | Always verify. Using as-is is risky |
| Legacy code changes | Doesn't know the full flow, touches the wrong things |
These four areas will eventually blow up if you use AI output without checking.
Prompt Patterns That Actually Work
A few patterns that consistently performed well over months of use:
- Paste the full error + relevant code together — throwing just the error message drops accuracy significantly
- "What problems could come up if I implement it this way?" — asking for risks beats asking for code
- "Just tell me what to change, don't rewrite the whole thing" — full rewrites lose existing context
- Specify the version — "React 18", "Next.js 15" — being explicit prevents wrong-version code
Conclusion
Use it to build everything? Not yet. Stop using it entirely? That feels like a bigger loss.
AI for the draft, my judgment on the decisions, verification always — this is the right position based on everything I've tried.
Used well, productivity goes up. Used lazily, technical debt piles up. Everyone's already using it, so if you're going to use it anyway, getting the approach right from the start makes all the difference.
