Writing code once defined software development. Success was measured by how much teams could build and how fast they could ship. That’s changing.
Not because code no longer matters, but because what surrounds it has become just as important. Here’s what that shift looks like in practice, and why it’s an opportunity rather than a threat.
The shift that's already underway
Something has changed in how software gets built, and it happened gradually, then all at once.
For most of the history of software development, the craft was fundamentally about writing code – translating human requirements into machine instructions, line by careful line. The best developers were the ones who could write that code fastest, cleanest and most elegantly. Everything else – strategy, design, architecture – was important, but it lived around the edges of the real work.
That model is evolving. Not disappearing: evolving. And the change is being driven by a shift that analysts at Capgemini recently described as a move from “writing code” to “expressing intent” : a paradigm where developers articulate desired outcomes, and intelligent tools assemble the underlying implementation.
We’ve been building software for 20 years. We’ve watched frameworks come and go, languages rise and fall, entire architectural approaches become obsolete. But what’s happening right now feels different – not a new tool in the toolbox, but a genuine shift in where the real work of software development takes place.
What "expressing intent" means
The phrase sounds abstract, so it’s worth making it concrete.
Traditionally, building a new enterprise application meant weeks of translating business requirements into architecture documents, data models, security frameworks and infrastructure code before a single screen was designed or a single user story was validated. That translation process was necessary, time-consuming, and – if we’re honest – repetitive. The same patterns, assembled from scratch, project after project.
Intent-driven development automates that translation layer. Instead of writing the boilerplate from the ground up, a developer describes what the application needs to do – its purpose, its users, its key workflows – and intelligent tooling assembles the foundational architecture in response.
This is exactly the problem that conn3ctedAI was built to solve. Using natural language inputs, the platform generates structured application models and assembles core components – data models, user roles, security layers, system logic – from a guided conversation. Developers then work with that foundation, refining, extending and building the features that actually deliver business value.
The result isn’t less work. It’s different work – work that starts further up the value chain.
Where writing code still matters most
It’s important to be clear about this: writing code isn’t going away. It remains the fundamental mechanism through which software gets built and the craft that defines great engineering.
What changes is where developers spend their time. The repetitive, infrastructure-level code – the base every project needs but nobody enjoys writing – gets automated. What remains is the code that genuinely requires human judgement: the logic that maps to a specific business problem, the edge cases that don’t fit a standard pattern, the integrations that need careful thought, the features that create real value for real users.
In that sense, the shift isn’t a deskilling of software development. It’s a redistribution of where skilled developers apply their expertise.
The skills that matter now and the ones becoming less important
Not every developer skill is increasing in value at the same pace.
As AI software development tools become better at generating infrastructure and repetitive code, the advantage is shifting away from manual implementation and toward higher-level thinking. Tasks like authentication setup, boilerplate APIs, standard security layers and base data models are increasingly automated.
That doesn’t reduce the value of developers. It changes where their value sits. The developers becoming most valuable now are the ones who can:
- Think in systems, not just features
- Translate business problems into clear technical intent
- Direct and validate AI-generated output
- Recognise weak architecture before it becomes technical debt
- Understand users, workflows and commercial outcomes
AI can assemble software faster than ever. Human expertise still decides whether the software should exist, how it should work, and whether it actually solves the problem.
Where most organisations will get this wrong
The biggest mistake businesses will make over the next few years is assuming AI development is primarily about speed. It isn’t.
Speed is the visible benefit. The real advantage is better allocation of human expertise. Organisations that simply use AI to ship faster without improving governance, architecture or product thinking will create technical debt at a much larger scale.
Many AI-driven software projects will fail not because the technology is weak, but because companies are accelerating broken processes instead of redesigning them.
Three problems are already appearing repeatedly:
Mistaking speed for quality
AI dramatically reduces the time between idea and execution. That creates opportunity – but also risk.
Fast delivery means very little if the architecture is weak, the user experience is poor or the platform becomes difficult to maintain six months later. Bad systems built quickly are still bad systems.
01
Underestimating security
AI-generated code is only as trustworthy as the systems producing it. In enterprise software, security cannot be treated as a final-stage checklist item. It has to exist at the architectural level from the beginning – especially when compliance, integrations and sensitive business data are involved.
That’s why Conn3cted built OWASP security standards directly into conn3ctedAI. Security isn’t an optional enhancement added later.
02
Losing the human judgement layer.
The most overlooked risk in AI-assisted development is the gradual removal of human curiosity and critical thinking from the process.
Great software has never been defined purely by functionality. It’s defined by understanding people – how they work, where friction exists, what creates confusion and what genuinely improves their experience. That layer cannot be automated.
03
What this means for businesses commissioning software
The important question is no longer whether a development partner uses AI. It’s how they use it.
Are they using AI to remove repetitive work and focus more on strategy, UX and business outcomes? Or are they simply trying to ship faster and cheaper?
The difference becomes obvious over time.
AI hasn’t changed our philosophy. It has changed where we spend our time: less on rebuilding foundations, more on solving meaningful problems.
The bottom line
Writing code is evolving. The shift toward intent-driven development is real, and it’s already changing how modern software gets built.
The teams that win in software development in 2026 won’t be the ones writing the most code. They’ll be the ones making the best decisions.
As AI gets better at building software, understanding the problem becomes more valuable than manually assembling the solution.