Last year started using AI tools more seriously. Thought it'd be another productivity fad that would fade away. It didn't.
Early 2025
Beginning of 2025 mostly ignored the autocomplete stuff. Partly didn't want another subscription, partly stubborn, and partly didn't want to train myself to just accept whatever suggestions popped up. Tried some local alternatives but they were either way too noisy or just wrong most of the time.
Eventually started using Copilot at work. It was decent for mechanical stuff - renaming fields across files, that kind of thing. Still had to review everything but cut down on the grind.
Then came MCP and started using Copilot more at work, learning about agents, MCPs, LLMs. Built a few toy ones. Interesting for a bit. One boring thing was learning how much prompts matter and how the world now depends on markdown files trying to guide AI agents to do things right. Love markdown so at least we don't have a new language to learn for this.
Agents
Mid-year got access to Claude Code and that changed things. With Copilot was mostly in control, asking for help with side tasks; with an agent this changed. Could ask for more and type less but at the end still have to review code and sometimes it's really bad code.
After so many years feel like my way of programming changed. Before spent time thinking and structuring how to code, trying to avoid clutter and keep the principles learned - KISS, SOLID. Tried many approaches: full TDD with red-green, starting with diagrams or class structures first. Nowadays have a mix that works but with an agent had to rethink this process.
Whenever want to use an agent, usually for boring tasks, need to spend time writing the first prompt. This is one of the main reasons AI sometimes makes programming boring - instead of writing structured code, writing prose hoping the AI gets it. No compiler for prompts, no type checker, just vibes. So many ways a prompt can go wrong.
Example - asked it to add tests and refactor something. It added tests but the wrong kind, just mocks testing that mocks got called, not actual behavior. The refactor added helper functions that looked clean but didn't simplify anything. Ended up deleting most of it and rewriting the tests myself.
This happened multiple times. Agents produce plausible code but not necessarily maintainable code.
Also there's setup fatigue. End up with style guidelines, project docs, how to run tests, commit format, all in markdown for the agent. Like having project notes but weird writing documents to tell a machine how to write code. Then preferences change and now maintaining those docs too. This will always be a work in progress because our way of coding is mutable and we're always improving.
After finishing setup was using agents all the time - small modifications, tests, refactoring, learning. This part is good. The barrier to try new languages, frameworks, OS concepts dropped a lot. Can experiment with stuff that would've sat on the TODO list forever.
October Burnout
Around October everything was AI. Work, commuting, feeds, blogs, conversations. Only escape was my wife - she works in arts and is not the most tech person, and that was honestly a breath of fresh air. Was helping with some AI discovery stuff and got overwhelmed.
Just stopped at some point. No model news, no takes, no comparisons. Focused on other things.
Got into self-hosting during that break and really liked it. Used AI to learn Proxmox faster (already knew Linux but Proxmox has quirks), built some small tools - tracking media, importing recipes to Mealie, random glue scripts. Nothing fancy but satisfying.
During the break saw many developers going from ignoring AI to being excited and starting to do cool stuff with it. And as new models launched at the end of the year they were even better.
This is where AI works well - lowers barrier to experimentation. Can try things that would've been postponed indefinitely. But try to treat it like a study partner, not copy-paste machine. If don't understand what it generated, slow down.
What Works Now
Past the hype. Here's what stuck:
Code reviews - catches mechanical stuff like "this path returns without releasing a resource". Not deep insights but helpful on tired days. Don't want AI writing and AI reviewing but as extra eyes for boring checks? Works.
Learning - when in unfamiliar territory helps get unstuck. Gives starting points and vocabulary to ask better questions.
Test scaffolding - if know what to test, generates decent boilerplate. If let it decide what matters, get useless tests. So write the test cases, it handles setup code.
Scripts - quick one-offs, migrations, boring automation. Usually verbose but beats starting from scratch.
What Bothers Me
Tech debt - great at "make it work", bad at "make it maintainable". Ship code that looks plausible, then six months later debugging abstractions that exist because they sounded good in prose. Can produce code faster means producing debt faster too.
Security - running way more generated code now. More dependencies, more scripts. Containers help but not enough. Simon Willison writes about this - need better local sandboxing.
Garbage code - barrier to shipping basically zero. Idea to deployed code very fast. Sounds great until realize it means garbage everywhere. Not code that breaks immediately - code that barely works, gets merged, then nobody understands why it exists later. More code being written faster doesn't mean better software, sometimes just means more mess to clean up.
Niche areas - really specific domains in math, science, biology are still hard. Think this will improve but needs more data and experts guiding the process. Not an expert here though.
Real time info - AI getting better at searching internet but internet has a lot of bad information. Models present questionable info with confident tone. Now double-check more, especially security stuff or anything that looks too clean.
The prompt problem - when an agent fails it's hard to debug. Don't get a stack trace, get "I interpreted your sentence differently". Sometimes fastest fix is stop prompting and start coding.
The data thing - why moving off GitHub. Microsoft trained Copilot on public repos (mine included, no permission) and now sells it back. Use AI tools but the "take everyone's code, ask later" approach is annoying.
Jobs
Don't know where this goes. Don't want to be "AI supervisor" reviewing diffs all day. Like programming because like solving problems and building systems, not reading generated code.
Feel like jobs will change but don't know to where. Hope it's a place where can still code and not only write prompts and review diffs as most directors and VPs are leaning towards.
Now
Still using AI, trying to be intentional. Reviews, learning, test boilerplate, scripts, everyday tasks - not just basics anymore, using it for more of the day-to-day coding work.
The shift isn't "AI writes my code now". It's using it for more everyday stuff and spending more time reviewing. Balance went from writing most code myself to guiding and reviewing generated code, deciding what to keep, fix, or rewrite. And as models get better at general tasks, find myself relying on it more. Each new release handles more complex stuff and makes fewer obvious mistakes, so the trust increases even if the concerns don't go away.
This post ended up long and there's nothing really new here - just random thoughts about the journey and things read and learned last year. The AI trend will continue this year and the burden to keep updated with the market and environment is real.
For now using AI for boring stuff - test boilerplate, documentation, scripts - and increasingly for everyday coding tasks. The balance shifted. Not writing all the core logic myself anymore, more reviewing what it generates and deciding what's worth keeping. And as models keep getting better at handling general tasks, find myself using it more. Each release handles more complex stuff with fewer mistakes, so reliance increases even if concerns remain.
When writing prompts feels like a chore instead of programming, that's the signal to close the chat and write code.