The discourse around AI and coding is exhausting. Either it's replacing all of us next Tuesday, or it's a useless party trick. Both takes are lazy, usually held with great confidence by people who haven't shipped much real code with it.
After shipping a *lot* of real code alongside these tools, here's the honest, unsexy version.
It's a junior, not an oracle
Treat the AI like an eager junior who types at 200 words a second and never gets tired or hungry. Phenomenal at the grunt work — scaffolding, tests, the fourth nearly-identical CRUD endpoint. Genuinely bad at knowing *why* your system is the way it is. It has read a million codebases and lived in none of them. It has no scars.
It can write the code. It can't care about the consequences. That part is still, stubbornly, your job.
What it's genuinely great at
- First drafts — getting from a blank file to something you can react to, which is half the battle.
- Boilerplate & translation — types, tests, config, one language to another, dull-but-necessary glue.
- Rubber-ducking — explain your bug to it out loud and you'll often spot the fix yourself mid-sentence.
- Exploring unfamiliar APIs — without forty browser tabs and a slow descent into Stack Overflow.
What it's quietly dangerous at
It will confidently invent a function that does not exist, with a plausible name and convincing arguments. It will write code that passes the test you described while silently breaking the case you forgot to mention. It doesn't know your latency budget, your one weird legacy constraint, or that this table is secretly load-bearing for three other teams.
// the AI suggested this. looks great. ships in 2 seconds.
const user = await db.users.findUniqueOrThrow({ where: { email } });
// what it didn't know: `email` isn't unique in our legacy table,
// half our users predate that constraint, and this throws in prod
// for exactly the customers most likely to complain loudly.
// confidence is not correctness.Heads up
The failure mode isn't the AI being obviously wrong. It's the AI being *plausibly* wrong — code that looks right, reviews clean if you're skimming, and detonates on the edge case it never knew existed.
How I actually use it
Small, reviewable chunks. I ask for a draft, then read every line like it came from a stranger — because it did. I keep ownership of the architecture and the genuinely hard calls. The speed-up is real and large; the responsibility hasn't moved at all. If it ships under my name, it's mine, full stop.
- 01Describe the change *and the constraints* — not just the feature, but the gotchas.
- 02Get a draft. Read it adversarially: what edge case did it miss?
- 03Keep the parts that are right, rewrite the parts that are merely confident.
- 04Run the tests. Then write the test it didn't think of.
The skill that's quietly becoming valuable
When the AI can produce code faster than you can read it, the bottleneck moves from *writing* to *judgment* — knowing what to build, spotting what's wrong, and deciding what's worth keeping. Code review, system design, and taste were always senior skills. Now they're the *whole* job, and that's a good thing for anyone who enjoyed those parts anyway.
Tip
Best mental upgrade I made: stop asking "is this code correct?" and start asking "what would make this code wrong?" The robot is bad at that question. You're not.
Where it nets out
I ship more, faster, and I spend less of my day on the boring parts. I also read more code than I used to, more carefully, because the generated stuff needs a sharp reviewer. It's a trade I'd take every time — but it is a trade, not a free lunch.
That's the whole trick, and it's weirdly freeing. Let the robot type. You stay the engineer. The job didn't disappear — it just moved up a level, to where it was always more interesting anyway.
Key takeaways
- 01Treat AI like a fast, tireless junior pair — great at drafts, weak on judgment.
- 02It's confidently fallible: review every line and watch for plausible-but-wrong code.
- 03Speed goes up; responsibility doesn't move. If it ships under your name, it's yours.
FAQ
Related reading