The AI Revolution in Programming Means One Thing: Adapt or Perish
AI is still THE hot topic among software engineers.
I’m still hearing corridor chat about whether we will still have jobs in a few years as AI becomes a common tool in software development destroying our value as employees. Will we be able to hold onto a career that can be fulfilling and even fun?
Here is my analysis of the situation: we either need to adapt or perish, as has always been the case in software development.
The Current Landscape
Right now, software developers shouldn’t be too worried about their jobs.
As I’ve previously mentioned, AI doesn’t usually deliver production-ready code and is even willing to ship code that cannot be compiled. This means that there is clearly a space for us to continue as the software developers we have always been for the next 18 months to two years.
After that, things might start to change.
Future Predictions
So, in 2026 what might happen to software developers? Are we all likely to be shifted out of jobs and onto the career scrap heap?
I actually don’t think that is likely. We still need people to drive the bus and likely that will be existing software developers.
Here are the repercussions that I think software developers will bear from the implementation of AI in the software development process.
Here is what I think might happen
Accelerate or Become Obsolete
AI will take on the bulk of basic coding tasks, and employers will push for faster delivery times. Well-defined and well-written requirements can be knocked out with little to no developer intervention. This leaves only the tricky bugs and difficult-to-implement features, which might make work more enjoyable.
Those who excessively pad their timelines will be exposed. AI will provide accurate estimates for feature delivery, setting new productivity and quality standards. This means some of my colleagues who produce next to nothing might find themselves out of a job. There is no great loss there.
We Become Quality Enforcers
While I think higher standards and quality are desperately needed, automating this will lead to some tough consequences for lax developers. This isn’t just about SonarQube and clicking “won’t fix”; it’s about having an AI scrutinize your work and question why you aren’t doing everything better. Tight deadlines won’t be an excuse.
Linting and code vetting will become part of your pipeline, with human intervention limited to a senior developer giving a sanity check. Your local linter as of 2024 will be obsolete, unable to cover all cases as effectively as future AI linters. Developers who can’t meet these high standards will be phased out, much like a university student handing in a paper with spelling mistakes after the advent of spell checkers.
We might finally get some maintainable code, which would be nice when implementing features (I think!).
Expertise Favored Over Generalization
With AI covering a broad range of technical knowledge, deep expertise in critical areas will become more valuable. Mid and junior roles will be harder to find as companies seek senior-level quality. The T-shaped developer, who has broad but shallow knowledge, might become irrelevant.
Agile Evolves
AI tools will churn out estimations and plans. We’ll see AI generating fancy burndown charts and even explaining what they mean to the business in a way that’s easy to understand. This change will likely benefit everyone, as Agile coaches can focus on people and communication rather than the current pattern of nobody paying attention in stand-up meetings.
Conclusion
“The future is not set. There is no fate but what we make for ourselves.”
I guess that means we’d better start delivering the features we promised for next week, then.