Trending Articles
Trending Topics
Trending
This article is part of our Opinions section, where we invite industry professionals to share their views on the most pressing technology questions of our time.
Enterprise has always had an advantage when it comes to code. They always have more, and more senior programmers, and also the time to throw at problems. However, recent changes may be bringing an end to that.
Like with many other things, it’s generative AI that is proving to be the herald of change. However, it’s not because LLMs can help the unskilled vibecode their way to creating programs, or because coding assistants like Cursor can push the productivity of a dev team up a notch. Instead, AI is shifting the advantage in a much more significant way by making code more open.
The way LLMs work is by hoovering up data and then spitting it back out – there’s some algorithmic magic involved, but the short version covers it quite well. The issue is that LLMs and the people who train them are indiscriminate in where they get their data. Plenty of ink has been spilt on the privacy issues involved, but for coders, this gains an extra dimension.
Not only do AIs get trained on data on the open web, but anything that’s fed into them is fair game. That explains why some software engineers at Samsung got into quite some trouble for pasting proprietary company code into OpenAI’s ChatGPT. This effectively meant that Samsung’s private code was now public property.
It’s happening more and more, too: a lot of coders, even ones on top of their game, are using LLMs for sanity checks. As a result, I’ve seen all kinds of proprietary code pop up when I generate samples, especially on really niche stuff where there isn’t a lot else for the LLM to draw on. This is despite companies outlawing LLM use and restricting employees to using “closed” coding assistants that keep results in-house.
This is a danger for any company creating software. If you’re working hard on creating code, spending money, time, and other resources, having it out in the open like this is very bad. One engineer’s mistake can cost you a lot. Especially large corporations, which can spend millions on creating programs, stand to lose out.
Then again, if there’s a loser, there must be a winner, too. In this case, it’s smaller players who are pretty much getting access to free, high-quality code. Though there’s no way to measure the impact it’s having, my guess is that if the revolution isn’t here already, it’s definitely coming soon.
Imagine having a small shop – maybe even just you – and putting a coding question you’re struggling with into an LLM and out comes this really, really good code. Like, maybe a little too good. You’d be over the moon, and rightly so, as you’ve possibly just had the work of a team of veteran programmers done for you by a single prompt.
If you are a veteran coder, you will probably realise that the above scenario is a little fanciful: LLM code isn’t all that great. However, it does show the way in which LLMs, for good or ill, have the potential to democratize code development, albeit in an unsanctioned way.
If quality code, or at least corporate code, becomes something accessible to all, it could change our industry in a radical way. For example, while startups are usually praised for being a lot more nimble than their corporate counterparts, they often struggle with the sheer output that tech giants have. This distance could narrow, giving upstarts both greater agility and decent code.
Even if the code can’t be copied wholesale – and again, this may very well be the case as LLMs aren’t very good coders – the principles involved in creating it may show through, giving a leg up to novices tackling a particularly thorny issue. This could make it so small teams could make products usually reserved for big ones, like creating an operating system or CRM.
This could be a good thing, as the software behemoths could use a shakeup, but it wouldn’t all be good news, either. If coders get used to adapting others’ code, there is a risk that they may lose some skills of their own or fail to develop them. This would hurt in the long term, as it raises the question of what to do once the authors of the original code retire.
There’s also the issue with what happens when large companies lose the incentive to create large programs: sure, nobody really likes Windows, but what would happen if Microsoft stopped making it? The open source crowd may cheer, but billions rely on this dynasty of programs, and their experience of computing would radically change.
All this is speculation, of course, but one thing is for sure: the way we develop software is about to change, and the Goliaths’ advantage may be wiped out. Let’s see what the Davids can come up with.
