I’ve been diving into AI-assisted coding lately, and it’s already changing the way I work. It doesn’t replace me, it just gets the grunt work out of the way so I can move faster. Way faster.

But that’s got me thinking. If this is where we are already, where’s it all going? Because the more I use these tools, the more it feels like a bunch of the tools we’ve relied on for years - frameworks, helper libraries, even languages themselves - might not be as necessary as we think!

Right now, we use frameworks, packages, and whole programming languages to create structure and readability. They exist to help humans understand and work with code. But what happens when humans aren't the ones reading it anymore?

I can see a point where the AI is so good, we don’t even question its output. We stop needing it to be clean or elegant. We just care that it works. Eventually, it might not even be producing source code at all - just pure binary output. Prompt in, 1s and 0s out.

We’re not there yet, obviously. Trust is still a huge blocker. Nobody wants to ship black-box nonsense to prod unless they're very brave or very stupid (or very inexperienced). But I do think we’re going to start seeing abstraction layers get stripped away, one by one.

Case in point: classnames

For years, I’ve been using the classnames package in React projects. It’s a nice little utility for conditionally applying classes to elements. This sort of thing:

import classNames from 'classnames';

const buttonClass = classNames('btn', {
  'btn-primary': isPrimary,
  'btn-disabled': isDisabled,
});

Handy. Clean. Saves a few keystrokes. Sure it's not many keystrokes but the cognitive load is lower and hey, every little helps, right?

But here’s the thing. Cursor (the AI-assisted IDE I’ve been using) can now do this just as fast:

const buttonClass = [
  'btn',
  isPrimary && 'btn-primary',
  isDisabled && 'btn-disabled',
].filter(Boolean).join(' ');

No imports, no dependencies, and I don’t have to remember how the library works. It’s just JavaScript. Cursor writes it faster than I can type the shorter version. So I’ve stopped using classnames. It doesn’t save me anything anymore.

© Copyright Netflix

That’s a tiny example, but it’s the start of a trend. I’m starting to think twice about installing third-party packages. Do I really need this? Or can the agent just knock out a bespoke version for me on the spot?

I can honestly see myself removing the 'time saver' packages like Lodash, Chokidar and even date-fns and replacing them with prompts like Transform this text to PascalCase, Add a 'watch' function that monitors this code for changes and works cross-platform and Make it so that this date is formatted like: 'DD-MM-YYYY'.

What about frameworks?

Push that thinking further and you start asking the same question about frameworks. Right now, we reach for them because they provide structure, conventions, reusable patterns. But if the assistant understands what we’re building, and can generate all that on demand, do we still need the framework?

Take it all the way to the end and the same goes for programming languages themselves. They’re just structured ways of talking to machines after-all.

Take humans out of the equation and what is the point of that abstraction anymore? Frameworks and languages, hell, even assembly are all just the translation layers for us. AI doesn't need those. If anything it probable will get in the way eventually. It will be the equivalent of making a French person learn English so that they can understand the English translation of the original French.

So where does that leave us?

I’m not saying software engineering is dead - far from it. But I do think the job is changing. The value isn't in typing out actual code anymore. It’s in understanding what needs to be built, guiding the assistant in the right direction, and knowing how to test and refine what comes out the other end. In other words, prompt engineering!

I don’t think code is going to vanish overnight. But I do think we’re going to stop hand-writing a lot of it. And when that happens, some of the abstractions we’ve built our careers around might start to feel a bit pointless.

In the short term, there are a lot of good reasons to continue to use frameworks and packages - security, accessibility and scalability are all often good reasons to reach for an off-the-shelf tool but honestly, how long is that going to be true for?

First classnames, then... who knows?