The Upside Is Real
I'll start with the honest part: AI has made me dramatically faster. Boilerplate that used to eat an afternoon now takes minutes. Scaffolding a new service, writing a migration, wiring up a form with validation, drafting tests, exploring an unfamiliar library — all of it compresses.
The bigger shift is not raw speed, it's lower activation energy. Ideas I would have shelved because "it's not worth a weekend" now get built. Prototypes that used to need a team can be validated by one person in a day. For founders and small teams, that is a genuine change in what is possible.
Where It Helps Most
- ·Boilerplate and glue code. CRUD endpoints, config, type definitions, repetitive UI.
- ·Exploration. "Show me three ways to structure this" is cheap now. Comparing approaches before committing is a great use of the tool.
- ·Learning on the job. Asking for an explanation of unfamiliar code, in the context of your own codebase, is a superb tutor.
- ·Tests, docs, and refactors. The chores that get skipped under deadline pressure.
The Downsides Nobody Puts in the Demo
1. Code you don't understand is a loan
Generated code that you merged without really reading it still has to be maintained. When it breaks at 2 a.m., you are debugging a stranger's work — except the stranger is you, and you have no memory of writing it.
2. Skills quietly atrophy
If you never struggle with a problem, you never build the intuition that comes from solving it. I've seen developers who can produce a lot of code but can't explain why it works, or tell when it's wrong. That gap shows up the moment the AI is confidently incorrect.
3. Confident and wrong
Models produce plausible code, including plausible bugs: subtle race conditions, insecure defaults, invented APIs, outdated patterns. Plausible is more dangerous than obviously broken, because it passes a casual review.
4. Bloat and inconsistency
Left unchecked, AI will happily add a new helper instead of reusing the one that exists, pull in a dependency for a three-line task, and style each file slightly differently. The codebase grows faster than anyone's understanding of it.
5. Security and data blind spots
Pasting proprietary code or secrets into tools without thinking, or shipping generated auth and input handling without review, are the kinds of mistakes that turn a productivity win into an incident.
The Rules I Use
1. Read every line before it merges. If I can't explain it, it doesn't ship.
2. Design first, generate second. I decide the architecture, boundaries, and data model. AI fills in the implementation within that shape.
3. Keep tests as the source of truth. Generated code must pass tests I understand, and ideally tests I wrote or reviewed first.
4. Still do the hard parts by hand sometimes. Debugging, reading docs, and designing systems are muscles. Keep them trained.
5. Treat output as a draft from a fast junior. Useful, tireless, and in need of review.
6. Be deliberate about what leaves your machine. Know what your tools send, and never paste secrets.
Closing Thought
AI is a multiplier, and a multiplier applies to whatever you bring. With strong judgment it multiplies your output. With weak judgment it multiplies your mistakes, just faster. Use it heavily, but stay the engineer in the loop.