Developers Never Owned Their Code, AI Just Made That Obvious

When generative AI tools started producing code at scale, questions emerged around developer agency, control, and ownership. Who owns the code when a chatbot generates it? Did developers previously own the code? Is there a change in the narrative with generative AI in the scene?

Developers were never truly in control of their code to begin with, believes Attila Vago, staff engineer at Prezi. “Truth be told, we’ve all been writing abandonware for many years,” Vago wrote in his recent Medium blog post. 

“We just needed AI to make it acutely obvious to everyone who hadn’t realised that yet.”

Vago’s view may be divisive, but it is hardly unconsidered. “All the A/B tests you ran over the last year, 80% of those are dead code,” he wrote. “Your GitHub account is practically a dusty museum nobody wants to visit anymore.”

Ben Hosking, a Dynamics 365/power platform solution architect at Kainos, echoed the sentiment. “Developers never owned the code in the first place,” he told AIM. 

Before AI, he noted, much of the work was already drawn from existing examples online, forums, or other projects. “The majority of developers don’t take pride in the code they are writing, they just try to write it as quickly as possible because that is what the projects want.”

Code, By Nature, Never Lasted

In the blog post titled Abandonware Is The New Software, Vago argues that disposability has always been baked into software development. AI didn’t create this dynamic — it simply revealed it. “That code you wrote 20 years ago in JavaScript? It still works thanks to browsers… but does anyone still use it?”

The shift toward AI-generated code just made an implicit truth explicit: “Even if we take the trend of rebuilding everything every four years, it’s pretty obvious, few software engineers truly build with posterity in mind,” he wrote.

Hosking extended this line of thinking to accountability. For him, responsibility has always been collective rather than individual. 

“In terms of accountability and responsibility, this is down to the whole development team, not the developer who wrote the code. Code should be peer reviewed, so the responsibility should be spread,” he explained. Applications, he added, go through multiple layers of testing before they are ever deployed, which further dilutes the notion of individual ownership.

When asked by AIM whether long-term maintainability still matters, Vago said, “Engineers may insist on long-term maintainability, but only because right now they’re the ones having to labour through that work. When AI does the work, it becomes less of a concern.”

That raises questions about the still-common instinct to “future-proof” code. For Vago, the concept is often misguided. He clarified in the blog that future-proofing is primarily a business consideration. It involves assessing potential scenarios for code execution and determining the ease or difficulty of future modifications, rather than being a purely philosophical challenge.

“Many of the famous programming principles originate from a time when Waterfall was king, continuous delivery was an exotic concept, and MVPs did not exist as your software was shipped on a floppy, CD, DVD”, he said.

Notably, the Waterfall model in software programming is a linear approach to software development.

The Morale Problem AI Can’t Solve

With disposability no longer deniable, something else is breaking down too: morale. 

“Right now, it’s creating chaos because even within teams you will have conflicting levels of openness to AI, and with that the aspect of code ownership becomes nebulous and increasingly difficult to define,” Vago told AIM.

In environments where team members can generate an entire component in a few prompts, others still prefer to write code line by line. The result is a fundamental mismatch, not only in workflows but in how engineers relate to their work. Ownership, once tied to authorship and accountability, becomes harder to trace when multiple people and bots have touched the same function.

Hosking’s view adds another dimension: that many developers never saw themselves as owners in the first place. “Personally I don’t think developers believe they own code because they are paid to create it. Often it’s someone else who has to maintain it, whilst the developers go onto a new project,” he said. 

For him, the focus has long been on speed and delivery, not craftsmanship. “A lot of developers don’t know good practices of code because they slow you down in the creation. The majority of developers are assessed on speed of creation, not quality.”

Vago views this as an extension of a trend that predates AI. In his blog, he wrote, “If you have ever coded an A/B test, you already know the drill: ‘It’s GEFN (good enough for now) because we’re deleting most of this 2–3 weeks later anyway.’”

Add in automated reviews from tools like CodeRabbit and instant end-to-end test generation via Playwright, and the rituals that once gave engineers pride in their code are slipping away.

“I wouldn’t blindly apply them all just yet,” he says of AI-powered PR suggestions, “but you have got to admit, many of those are spot on, and the code change is a single click away.”

Vago doesn’t mourn the loss. He sees it as clarity: “Whether you agree or not, it’s irrelevant. Whether you like it or not, it’s also irrelevant. It’s a reality that has snuck up on many software engineers.”

What Survives AI-Era Development?

What then is worth preserving, if not code ownership or craftsmanship? Vago believes that simplicity still matters. 

“KISS (Keep It Simple, Stupid) being the only software development principle that still makes sense in the age of AI,” he wrote in the blog. That’s partly because simplicity is what enables change — something AI is accelerating, not preventing.

At the same time, he does not find AI-generated code bad: “Ultimately, good, as it’s essentially a very smart autocomplete, but it only works well in the hands of capable engineers.” 

He believes the issue stems from junior developers attempting to bypass fundamental programming education, believing AI-generated code will resolve all their challenges. “In 10–20 years, it will be difficult to find engineers who actually know what they’re doing,” he concluded.

The post Developers Never Owned Their Code, AI Just Made That Obvious appeared first on Analytics India Magazine.

Generated by RSStT. The copyright belongs to the original author.

Source