How AI Coding Tools Changed My Workflow (Honest Take, Not Hype)

I came to AI coding tools as a skeptic. I've been writing software long enough to remember several waves of "this changes everything" that didn't. Two years of daily use later, my honest position lands in neither camp: these tools have genuinely changed my workflow, and almost none of it looks like the demos.

What actually got faster

The boring parts. Boilerplate, test scaffolding, one-off migration scripts, the regex I write four times a year, the SQL window function I always have to look up. Work I already knew how to do and merely had to type — that's where the speedup is real, and it's substantial.

The second real win is unfamiliar territory. A new API, a library I've never used, a legacy corner of a codebase: asking for an explanation and getting a decent first map in thirty seconds has replaced an hour of tab-hopping through docs and Stack Overflow. It's the rubber duck that talks back — and as someone who wrote a whole post about reading other people's code, having a tireless explainer on tap is the feature I'd give up last.

What didn't change at all

Everything that was hard before is still hard. Deciding what to build. Choosing where the boundaries go. Naming things honestly. Debugging the production issue that only happens on Tuesdays. Understanding what the business actually needs versus what the ticket says. The tools generate code; they don't generate judgment.

And the bottleneck quietly moved. I type less and review more — every generated diff is a pull request from a very fast, very confident teammate who has never met your users and will never be on call. The reviewing skills I used to reserve for teammates' PRs now run all day, on my own editor.

AI made the typing cheap. It made the judgment about what to keep more valuable than ever.

The new failure modes

The dangerous output isn't wrong code — it's plausible code. It compiles, it handles the happy path, the tests it wrote for itself pass, and the edge case it silently dropped surfaces three weeks later. Confidence and correctness arrive in the same tone of voice, and nothing in the interface tells you which one you got.

The team-level risk is bigger diffs and thinner understanding. It has never been easier to produce five hundred lines nobody on the team can explain, including the person who prompted them. On my team the rule is simple: if you can't walk someone through the change, it isn't ready for review — same standard as ever, no matter who or what typed it.

How I actually work now

Autocomplete handles the small stuff in the editor. Chat is my sounding board for design options and my first stop in unfamiliar code. Agent-style tools get the well-bounded mechanical work — a rename across a codebase, a repetitive refactor, scaffolding a CRUD screen — where the spec is clear and verification is cheap.

Everything gets read before it gets committed, with the same skepticism I'd give an eager junior's PR. Tests are the contract, written or at least understood by me. And when something matters — auth, payments, data migrations — I slow down to exactly the speed I worked at in 2022.

If you're earlier in your career

The uncomfortable truth: these tools raise the floor, not the ceiling. They make an experienced engineer faster because experience is what filters their output. Skip building that judgment and you're left trusting a very persuasive machine you have no way to check.

So use them — refusing would be as silly as refusing an IDE — but use them to learn, not to skip learning. Ask why, not just what. Rewrite their output by hand sometimes. The fundamentals haven't gotten less important. They've become the only thing that separates you from everyone else with the same subscription.