Dominic Williams has thrown a fresh spanner into the works of traditional software development thinking, suggesting that a new wave of self-writing applications will soon eclipse the conventional frameworks we’ve grown so attached to. His point is as clear as it is disruptive—just as the mobile revolution ushered in dedicated operating systems like iOS and Android, this next evolution in technology won’t simply reuse old stacks. It’ll demand new ones, and they won’t be centred around manually written code.
At a glance, this might sound like yet another tech industry prophecy. But Williams’ track record as founder and chief scientist of the DFINITY Foundation, which powers the Internet Computer blockchain, gives his statements more than passing credibility. He’s not forecasting from the sidelines. He’s building right at the centre of it.
The idea that apps could soon write themselves may once have belonged to speculative fiction or AI daydreams. Today, however, that future is looking surprisingly functional. Tools powered by generative AI are already aiding developers in real-world scenarios. GitHub Copilot is writing lines of code. ChatGPT is assembling functional scripts. But this, Williams suggests, is just the prologue. What comes next will be application platforms designed from the ground up for these intelligent, self-composing agents—not simply extensions bolted onto legacy systems.
Traditional IT stacks—built to squeeze maximum performance from human coders and the collective value of network effects—are showing signs of age. They’re solid, yes. But they’re slow, manual, and increasingly out of step with the speed at which automation is advancing. Crafting applications line by line is becoming a bottleneck, not a badge of honour. While legacy systems may have once offered a competitive edge through the sheer brilliance of human coding ability, the balance is tipping in favour of autonomy, iteration, and scale—without human hands in every loop.
It’s a shift that feels as substantial as the leap from desktop software to mobile apps. When smartphones took over, everything had to be rewritten. Desktop-centric operating systems didn’t cut it. New use cases meant new interfaces, new backend demands, new security models. It wasn’t about tweaking Windows or macOS—it was about starting from scratch. Williams believes the rise of self-writing apps demands something just as radical.
And yet, there’s still a stubborn clinging to old habits. Many developers today are retrofitting AI assistance into workflows built for hand-coded precision. They’re using tomorrow’s tools on yesterday’s foundations. That’s a short-term fix. What Williams proposes is a structural rethink.
What does this look like in practice? Think platforms that prioritise machine learning from the outset—where the user experience is shaped by data models that evolve in real time, where front and back ends are both designed to be interpreted, not manually constructed, and where deployment doesn’t require weeks of testing but minutes of autonomous stress simulations. These systems won’t ask “What can the coder do?” but rather “What can the system learn to do?”
The implications are wide-ranging. On one side, you’ve got gains in speed, scale, and accessibility. Startups could launch fully functional apps without hiring full-stack dev teams. Small organisations could automate tasks currently requiring complex IT infrastructures. Large-scale systems could adapt more rapidly to user behaviour, environmental inputs, or security threats—because the intelligence sits at the platform level, not just in the code.
On the other side, there are plenty of open questions. What happens to the culture of coding when code becomes optional? Will we see a creative boom, where people previously locked out of software development find themselves building meaningful tools? Or will the abstraction of development push us further away from understanding how our software really works? There’s risk in handing over the reins to systems that teach themselves. But there’s risk in being left behind too.
Williams’ remarks aren’t just about future tech—they’re about how we choose to build it. If we take self-writing apps seriously, then building for them shouldn’t mean reconfiguring current frameworks. It should mean crafting entirely new environments. Environments that don’t force AI into a human-shaped box but instead support machine-native processes from the start.
He’s not the only one thinking this way, of course. Across the tech landscape, conversations are heating up around agentic systems, no-code platforms, and AI-first development. The Internet Computer itself is pushing boundaries on this front, with decentralised applications that can update themselves, scale with minimal human intervention, and respond to events across chains and services. Williams’ emphasis is that this isn’t an edge case anymore—it’s the main event.
Much like mobile forced a rethink of UI, input methods, and service design, the rise of intelligent, self-generating apps could demand an architectural shake-up. We’re likely to see a rise in domain-specific platforms: purpose-built environments where self-writing agents flourish without the constraints of decades-old coding assumptions. These stacks won’t simply be leaner—they’ll be alien to anyone trained in conventional software engineering.
It might feel like a leap too far for some. There’s a strong emotional attachment to the art of coding, the satisfaction of control, the elegance of algorithms crafted by hand. But then again, every major shift in technology has faced this kind of resistance. Typewriters gave way to word processors. Hand-drawn animation made room for CGI. And yes, manual coding may soon share that fate—less because it’s obsolete, more because it’s inefficient in a world where software can build itself.
Williams’ comments also strike at something more philosophical: the idea that we’re at the end of a particular kind of craft and the beginning of a new type of creation. It’s not about discarding knowledge. It’s about transforming it—leveraging that experience to design the tools that replace it.
That doesn’t mean coders will vanish. Their roles may shift from writing logic to designing frameworks, from debugging syntax to training models. The challenge will be in reorienting education, hiring, and team structures to fit this new paradigm. The same goes for product design, where assumptions about timelines, iterations, and launch cycles will need rewriting.
Of course, for all the theory, the proof will come in execution. Are these new stacks coming soon? Are they already quietly forming in labs and startups? The answer’s likely yes. And once they arrive, there won’t be much room for hesitation.
The move to self-writing applications, if it gains traction, could level the playing field. It could make software more democratic, reduce barriers to entry, and challenge the monopoly of tech giants who’ve built empires on legacy knowledge. But it could also raise questions about reliability, security, and authorship. If the app wrote itself, who’s liable when it breaks? If the system evolved a feature on its own, who owns the IP?
These aren’t just technical puzzles. They’re legal, ethical, and social ones. And the sooner the industry starts building for this future, rather than dragging yesterday’s infrastructure into it, the better equipped we’ll be to answer them.
Williams’ challenge is clear: don’t retrofit, reimagine. If apps are going to write themselves, give them a proper place to live—not a half-empty garage full of dusty tools. And for those still clutching the old ways: it might be time to let the machines take the wheel.
Because if history has taught us anything, it’s that when the stack changes, everything else changes too. And this next stack isn’t for us. It’s for them.
