.gitignore is not enough: how I wiped git history on a public content repo
Adding paths to .gitignore and deleting them in a new commit only removes files from the latest snapshot of your branch. Old commits on GitHub still store…
AI will not replace developers in the foreseeable future. It automates boilerplate and tests, plus first-pass debugging, but someone still has to define the problem and own trade-offs. That same person takes the pager when production breaks. After two years of headlines about the end of programming, our team ran these tools on real deadlines. The job changed. It did not disappear.
What AI actually does well
AI is genuinely good at the repetitive slices of a developer's day: boilerplate endpoints, React components, migrations, plus the obvious test cases everyone skips when rushing.
Boilerplate generation. Need a CRUD endpoint or a database migration? AI writes these in seconds. The kind of work that used to feel like typing with one hand tied behind your back now mostly runs on autopilot.
Explaining unfamiliar code. Paste a tangled function into an LLM and ask what it does. You often get a clearer explanation than the inline comments left behind. And the model will not judge you for not knowing what a monad is.
Writing tests. AI is solid at generating test cases, especially tedious edge cases. It will rarely invent a clever test strategy, yet it cranks out the obvious ones faster than most humans under time pressure.
Debugging assistance. "Why is this returning null?" AI often spots the issue right away. Like having a senior engineer looking over your shoulder, except this one never gets tired and does not mind explaining the same thing three times.
Documentation. AI writes docs that are readable enough to ship. Imperfect, sure, yet still better than the usual alternative: no docs at all.
All of this is real and valuable. None of it replaces a developer who owns outcomes. If agents and chat blur together for you, LLM vs model vs agent maps what actually acts on your code.
Where AI falls apart
The gap between "AI writes code" and "AI replaces developers" is enormous. These tools still struggle with ambiguity and accountability, plus anything that requires reading a room.
It does not understand the problem
AI solves well-defined problems brilliantly. Most of a developer's job is figuring out what the problem actually is.
A product manager says "we need a notification system." What they usually mean: users are missing important updates, but we do not want to spam them. It needs email and push plus in-app delivery, time zones, opt-outs, and a data model that supports analytics later.
AI does not ask those follow-up questions. A developer does.
It cannot make architectural trade-offs
Microservice or a module in the monolith? PostgreSQL or something else? Build in-house or grab a third-party API?
These are business decisions dressed as technical ones. They depend on team size, maintenance budget, risk tolerance, and how much pain you are willing to accept in year three. AI can list pros and cons. It cannot make the call, and it definitely cannot own the consequences when the call was wrong.
It does not negotiate with stakeholders
Half of engineering is communication. Convincing a stakeholder their feature takes three weeks, not three days. Explaining why technical debt matters. Pushing back on a deadline that would force corners you will regret later.
AI does not sit in meetings. It does not read the room. It has no sense of when to compromise and when to dig in.
It cannot be held accountable
When a deployment breaks production at 2 AM, someone has to fix it. When a security vulnerability pops up, someone needs to understand the system well enough to patch it without creating new bugs. When a client is unhappy because a feature does not work as expected, someone has to trace what went wrong and make it right.
AI does not carry a pager. It does not feel the weight of responsibility. That accountability is what separates professionals from tools.
It hallucinates confidently
OpenAI's own guidance warns that models can sound authoritative while being wrong. We see it constantly: code that compiles cleanly and does something subtly incorrect. The kind of bug that slips through review, hits production, and causes headaches three weeks later that nobody can trace back.
A junior developer makes mistakes too, yet they usually signal uncertainty. AI does not. The burden of verification falls entirely on the human. If terms like RAG or embeddings are fuzzy, the AI & LLM glossary explains why "confident wrong" is a model behavior, not a personal failing.
What actually changed
So if AI is not replacing developers, what is it doing?
It raised the floor. Junior developers used to spend their first year writing boilerplate and fixing typos. Now they can jump faster into understanding systems and solving real problems. The entry-level job got more interesting, which also means the bar for "junior" went up.
It multiplied senior developers. A senior engineer who knows how to use AI effectively can do work that used to take two or three people. AI handles the tedious parts; the senior dev focuses on architecture and review, plus the hard decisions that actually matter.
It changed what "skill" means. The most valuable developers are not the fastest typists or the best API memorizers. They articulate problems clearly, evaluate AI output critically, stitch pieces into a coherent system, and catch the subtle bugs models introduce.
It made code cheaper and judgment more expensive. When anyone can generate code, value shifts from writing it to knowing what should be written. Judgment and experience became the scarce resources, not typing speed.
The real threat is not AI
The developers in trouble are not the ones competing with AI. They are the ones who refuse to use it.
A developer who uses AI effectively will outproduce one who does not. AI removes friction so the human can focus on work that requires context and taste, plus real accountability.
The threat is not "AI replaces developers." It is "developers who use AI replace developers who do not." That pattern is already visible. It is the same story as compilers, IDEs, and cloud platforms: the job shifts, the role survives.
What this means for your career
If you are worried about AI taking your job, panic is the wrong response. Adaptation is the useful one.
Learn to use the tools deeply. Understand strengths, failure modes, and blind spots. The developer who treats AI as a black box will stay a step behind the one who knows how prompts, context windows, and tool calls actually work. Anthropic Academy's free courses are a practical place to start if you want structured material instead of random YouTube threads.
Invest in what AI cannot do. System design. Communication. Product thinking. Debugging complex distributed systems. Business context. These skills get more valuable as AI handles routine implementation.
Stop identifying as a code writer. You were never just that. You are a problem solver who uses code as one of many tools. AI is another tool in the box: powerful, yes, still a tool.
Stay curious about what is underneath. You do not need to be an ML researcher. Understanding how LLMs work, what training data implies, and why hallucinations happen makes you better at judging output. That knowledge also helps if your work touches how AI systems cite sources, which is becoming its own specialty for technical writers and developer advocates.
We stopped pretending AI will replace developers for the same reason we stopped pretending compilers would replace assembly programmers, or IDEs would replace people who live in terminal editors, or cloud platforms would replace sysadmins.
Each wave of automation changed the job. None of them eliminated it.
AI is the strongest shift we have seen so far. It is reshaping daily work, raising expectations, and compressing timelines. The core of the job remains deeply human: understand a messy, ambiguous problem and design something that works inside real constraints.
The developers who thrive in the next decade will be the ones who work with AI critically and creatively, with eyes wide open.
That is an upgrade, not a threat.
Filed Under
