Year of AI Coding Assistants: A Working Dev’s Audit

Archive note: this is a backdated post, written years later while rebuilding this site. It’s dated to the moment it covers, but the hindsight is real.

Two Decembers ago I banked a prediction: AI in my daily toolchain within a year. Last December I scored it early-and-under. This year the question itself is obsolete — the tooling is ambient — so the annual audit asks something harder: after a full year of AI-saturated development, what actually changed?

What the year actually looked like

The 2024 stack, as lived: inline completion in the editor (the Copilot pattern — accepted, edited, or swatted away dozens of times daily), a frontier chat model as pair and second opinion, o1-class reasoning reserved for the genuinely hard problems, and AI-first editors like Cursor proving that the interface to all this is still unsettled. Plus a local model on my own hardware for anything that shouldn’t leave the building.

The honest ledger

What genuinely changed:

The blank page is extinct. Every migration, test suite, config, or unfamiliar-API integration starts at 60% done. The activation energy of starting — historically my most expensive resource — dropped to near zero. This alone justifies the subscriptions.
Unfamiliar territory shrank. New library, legacy codebase, language I touch twice a year — the exploration tax collapsed. I took on work this year I’d have quoted higher or declined in 2022.
Review became my primary verb. The prediction that the job shifts from writing to specifying-and-verifying didn’t just hold — it accelerated. My value-add concentrated into exactly the things the tools can’t do: knowing what should be built, recognizing when plausible is wrong, and owning the consequences.

What stubbornly didn’t:

The hard parts are untouched. Requirements archaeology, architectural trade-offs under real constraints, the client conversation where the actual problem emerges — the tools are spectators. The bottleneck of my profession was never typing speed, and the year proved it.
Verification debt is real and compounding. Plausible-but-subtly-wrong code at volume is a new category of risk. I caught an AI-suggested race condition in a payment flow this year that would have sailed through a tired Friday review. The discipline — hostile auditor, always — is now the load-bearing skill, and it’s tiring in a way typing never was.
The junior question got worse, not better. Two years of warnings and the industry’s answer remains a shrug. Entry-level postings thinned; the apprenticeship tasks evaporated upward into seniors-with-tools. We are eating the seed corn and calling it productivity.

What I’d tell a dev starting today

The same thing as 2023, now with evidence: fundamentals are more valuable, not less — the tools amplify judgment and amplify cluelessness with equal enthusiasm. Learn to read code ruthlessly, because reading is the job now. And build something real end-to-end without assistance at least once, the way pilots still learn on manual controls.

Prediction bank, December 2024: next year the completion-and-chat era gives way to agents — the round-one toys of 2023 returning with the reasoning models they were missing, scoped and tool-equipped, doing multi-step work for review. The terminal, not the editor, feels like where it lands. If that sounds specific, it’s because the early versions are already in my shell history.

Three years of this column and the through-line holds: the spectacular and the useful keep diverging, and the useful keeps winning quietly. See you in December.