AI has made it easier to produce software before it has made it easier to understand software.
That tension sits at the centre of Andrej Acevski’s reflection on why AI won’t take your career. The piece is not an argument for ignoring AI. It is a reminder that the useful part of engineering still involves reading, questioning, and living with the code after the first version works.
It really won’t. But our tools changed, and reading code matters more now than it ever did.
The Code Still Comes Back
An agent can write a component, refactor a module, or sketch an architecture in minutes. Once that code enters a real system, the origin story stops mattering. Bugs do not care whether a human or a model introduced them. The next engineer still has to trace them.
AI shifts the balance from typing towards reviewing. That is not less technical work. It may be more technical, because someone has to understand the whole shape rather than one function at a time.
Cheap Software, Expensive Consequences
AI makes clones and weekend MVPs cheap. That is great for experimentation, but a working demo is not a durable product. Architecture still has to survive feature requests, migrations, permissions, traffic, and the person who inherits it six months later.
AI can help think through those problems, but it cannot take ownership of the trade-offs. If I let it choose everything, I am not removing responsibility. I am hiding it until the bill arrives.
Reading Is Part of Building
There is a temptation to treat reading code as the slow part that AI finally allows us to skip. I think the opposite is happening. When a tool can generate more code, reading becomes the way we decide what deserves to stay.
That requires more than clever prompts. It requires knowing what good looks like, spotting a bad assumption, and understanding how a change travels through the rest of the system. The model can produce an answer. I still need enough context to judge it.
Keep the Agent in the Loop
I am happy to let AI handle the work nobody wants to repeat: scaffolding, test drafts, routine refactors, documentation, and the occasional heroic copy-and-paste exercise.
Architecture, constraints, and final diffs still need a human set of eyes. The goal is not to keep both hands on the keyboard for moral reasons. It is to keep understanding attached to the result.
The Question That Still Matters
Could another engineer understand this? Could I change it in two years? What happens when the assumptions change?
Those questions sound ordinary. They are also where engineering judgment lives. An agent can generate an answer quickly. It cannot make the answer responsible on my behalf.
The career risk is not only AI replacing people. It is speed replacing comprehension. Someone who ships ten times faster but cannot explain the system has not multiplied their value. They have multiplied the amount of code waiting to surprise them.
Use AI. Let it remove the boring parts. Keep reading, tinkering, breaking things, and learning why they broke. The invoice for a bad abstraction still arrives with a human name on it.