AI coding tools went from party trick to daily driver fast. Copilot finishes the code you were about to type, ChatGPT untangles the error message you didn't want to read. Work that used to eat a day now fits before lunch, and honestly, we're not going back.
The trick is knowing what to hand over. Boilerplate, config files, regex, first drafts of documentation: all perfect AI work. Paste a crusty Apache rewrite rule in and ask for the nginx equivalent, and it comes back correct, commented, in about four seconds. That's fifteen minutes of squinting at documentation gone. Same story for PowerShell one-liners, docker-compose files, systemd units, test scaffolding, and the regex we all pretend we can write from memory.
Copilot earns its keep differently. It sits in the editor and autocompletes the tedious half of whatever you're already typing: the error handling, the parameter validation, the third nearly-identical case in a switch statement. At ten US dollars a month it pays for itself somewhere in the first hour. Used this way the tools feel less like a replacement and more like a very fast junior who never gets tired of the boring tickets. For a small team like ours, that's hours back every single week.
It's not just code, either. Summarising release notes before an upgrade, turning a wall of log output into a plain-English theory of what broke, drafting the first version of a client-facing explanation: all of it is faster with a model in the loop, and none of it was anyone's favourite job.
What stays human: architecture, business logic, and anything that touches production. Not because the models can't produce plausible answers there, but because plausible is exactly the problem. We've watched ChatGPT invent PowerShell cmdlets that have never existed, cite nginx directives from some parallel universe, and produce a regex that handled the example beautifully and quietly failed on real data. None of it looked wrong. It compiled, it read well, and it was nonsense.
So the house rule is simple: AI output gets reviewed like a pull request from a stranger who types very fast. If you couldn't have written it yourself, slower, you're not qualified to accept it. That's also why we don't worry much about the "will it replace developers" question. The skill that matters now is smelling when the answer is off, and you only develop that nose by having done the work the hard way first.
The landscape is moving quickly enough that this paragraph will age like milk, but as of right now: GPT-4 is still what we reach for on genuinely gnarly problems. Anthropic shipped Claude 3 this month and it's remarkably good with long documents, the kind of thing where you paste in an entire config file and ask what's wrong with it. And local models have gone from science project to quietly useful. A quantised Mistral 7B running through Ollama on a spare GPU handles most quick questions fine, costs nothing per query, and never phones home, which matters for anything we'd rather not send to someone else's cloud. Client data stays in the building, full stop, so having a capable model that runs inside the building too is genuinely handy.
The pricing works out kinder than you'd expect. A Copilot seat and a ChatGPT subscription together cost less per month than a single billable hour, and they give back a lot more than an hour. For once the maths on a new tool isn't even close.
A few habits that separate getting garbage from getting gold. Give the model the same context you'd give a colleague: the actual error message pasted verbatim, the relevant chunk of config, what you already tried. "My server is broken" gets you a horoscope, while the full stack trace gets you a diagnosis. Ask for small pieces rather than whole systems, because a forty-line function you can review beats a four-hundred-line module you'll skim. When the answer smells off, say so and push back, since the second attempt with your correction in the conversation is usually much better than the first. And keep a running note of what each tool is actually good at, because they have personalities: one writes better shell scripts, another explains concepts more clearly, and you learn the map by using them.
The one place we'd pump the brakes: don't paste anything into a cloud model that you wouldn't put in an email to a stranger. Credentials and keys obviously, but client code and internal configs deserve a think too. That's half the appeal of the local models, and the other half is that they still work when the API is having a bad day.
Our honest take: treat them as assistants, not oracles. They're confidently wrong just often enough to keep you paying attention, and the developers getting the most out of them are the ones who can spot it. These tools will keep transforming how we build. Where that ends up, nobody really knows yet, but we're curious enough to find out.