Six shifts are changing how developers build, deploy, and maintain the systems that people rely on. Below, I describe each of them and say what it means for the people who write code. Developers face a shift of this kind in every decade, although the shifts now come faster. The tools of 2023 would look unfamiliar to a developer from 2013, while new approaches can now appear faster than a team can evaluate them.
A brief history of how we got here
To see where software development is going, you need to know where it has been. These are the major turning points:
- 1940s-1950s (Machine Age): Programming meant writing machine-level instructions by hand. Every program was a bespoke piece of work that few people could do.
- 1960s-1970s (Structured Programming): With languages such as Fortran and COBOL, programmers gained higher-level abstractions, with which they could express complex logic without managing raw hardware operations. Productivity jumped by orders of magnitude as a result.
- 1980s-1990s (Object-Oriented Programming): With OOP languages such as C++ and Java, programmers could build reusable, composable blocks, which meant that teams could share and extend one another's code.
- Late 1990s-2010s (The Internet Era): Developers who built for the web needed new tools, so JavaScript, Python, and PHP became dominant as interactive, data-driven applications moved off the desktop and into the browser.
- 2010s-Present (Cloud and Mobile-First): Developers began writing software for smartphones, while companies moved their infrastructure from their own hardware to on-demand cloud services. AI and machine learning also moved from research labs into production codebases.
With each transition, more people could build software, and they could build more with it. Below are six projections for the next wave of that expansion.
Six projections for the next decade
- 1
Developers can solve more problems with quantum computing
Classical computers process information in bits, each of which represents a 0 or a 1, while quantum computers use qubits. A qubit can exist in multiple states at once, which physicists call superposition. Because of superposition, a quantum machine can solve certain categories of problem, such as cryptography, molecular simulation, and optimisation, exponentially faster than any classical system.
Quantum computing means new programming models for software developers, which you can already try in languages such as Q# from Microsoft and frameworks such as IBM's Qiskit. Google's quantum supremacy milestone is a demonstration that these machines can outperform classical supercomputers on specific tasks.
The transition is still at an early stage, because quantum hardware remains fragile, expensive, and limited in the number of stable qubits that it can maintain. However, developers who start learning quantum concepts now will be better placed as the technology matures and as hybrid classical-quantum architectures become more common.
- 2
Developers build software differently with AI and machine learning
AI is becoming part of the development process itself. Developers can already use code generation tools such as GitHub Copilot and large language models such as GPT-4 to write boilerplate, propose fixes, and generate tests, so that a developer can focus on architecture and product decisions.
On the product side, ML models power recommendation engines, fraud detection systems, natural language interfaces, and autonomous agents, while with managed services and open-source frameworks such as TensorFlow and PyTorch, teams can train and deploy those models more easily.
For developers, knowing how to integrate, fine-tune, and evaluate an ML model is becoming a core skill, which means that a team that treats AI literacy as optional will fall behind within the next few years.
- 3
More people can build software on no-code and low-code platforms
On platforms such as Airtable and Mendix, people with no programming background can build working applications through visual interfaces and drag-and-drop components, so more people can turn an idea into software.
Professional developers still have work to do, although the kind of work changes. People can build straightforward applications and internal workflows well with no-code tools, but they still need a developer for custom integrations, performance-sensitive systems, and complex business rules. Demand for developers who can build what nobody can build on a no-code platform, and who can extend the platform past its limits, will grow alongside adoption.
Professional developers gain from this trend, because when business teams can build their own dashboards and simple tools, engineering teams can spend their time on the harder problems where deeper technical judgement matters.
- 4
Cybersecurity becomes a development discipline
Any connected system is a target for attackers, whose breaches keep growing more frequent and more sophisticated. The industry's response is to shift security left, which means building security into the development lifecycle from the first commit onwards.
Under DevSecOps, a team builds automated vulnerability scanning, dependency auditing, and compliance checks into its , where tools such as Snyk, Dependabot, and OWASP ZAP work alongside the unit tests to catch an issue before the team releases the code to production.
Security is now a shared practice that every developer contributes to, which is why developers who understand threat modelling, secure coding patterns, and infrastructure hardening will be in growing demand.
- 5
Toolmakers improve remote and collaborative development tools
When teams went remote during 2020 and 2021, companies had to rethink how their developers collaborate on code. With tools such as VS Code Live Share, developers can pair-program in real time across time zones, while with cloud-based development environments such as Google Cloud Workstations and GitHub Codespaces, they can spin up fully configured environments in minutes.
Asynchronous workflows, strong documentation, and are becoming essential for a distributed team. With those practices, a team can be more resilient, open to talent from anywhere, and less dependent on everyone being in one office.
Teams also change their architecture for remote work, since a system that a remote team designs tends to be more modular, better documented, and more observable. A team gains from those qualities in any codebase, wherever it is based.
- 6
Developers architect applications differently with serverless computing and microservices
On serverless platforms such as AWS Lambda and Google Cloud Functions, developers can deploy individual functions without managing servers, scaling, or infrastructure. Once you write and deploy a function, the platform handles everything else, including scaling it to zero when nobody is using it.
When a team combines serverless computing with a microservices architecture, it can build an application as a collection of small, independently deployable units. Each unit can scale on its own traffic pattern, which means that the application uses its resources more efficiently and that the team pays less at scale.
The trade-off is operational complexity, because to debug a distributed system, manage communication between services, and keep dozens of functions observable, a team needs skills beyond those for a single monolithic application. A developer who understands both approaches, and who can judge when each one fits, will be well placed for the architectural choices ahead.
Key takeaways
- With quantum computing, AI/ML, and serverless architectures, developers can build more, and build it in new ways.
- More people can create software on no-code platforms, while companies still need developers for the problems that nobody can solve on those platforms.
- Security is becoming a discipline that every developer shares.
- Teams collaborate differently when they work remotely, while toolmakers are still catching up with the change.
- Across all six trends, adaptability matters more than any single technology skill, which means that the developers who thrive will be the ones who keep learning.
Throughout the history of software development, the developers who stay curious do better than the ones who stay certain. With the six technologies above, developers will find opportunities that do not exist yet, while some skills that seem essential today will fall out of use. Developers who keep learning and who build a broad understanding of the emerging tools will shape what comes next.
