People say AI coding kills your skills. I think they said the same thing about Python replacing Assembly

Posted by Alternative_Win_6638@reddit | learnprogramming | View on Reddit | 18 comments

The more comfortable I get with AI-assisted development, the less code I write myself — and I've stopped seeing that as a problem.

There's a common concern that AI coding tools reduce your problem-solving ability because you're not deeply familiar with the code being produced. I used to think about that too. But then I realized we've heard this argument before.

When high-level languages replaced Assembly, developers worried they'd lose touch with "real" code. Then came C, Java, Python — each more abstracted than the last. Then React, which hides enormous amounts of HTML and JavaScript complexity behind components and hooks. Every time, the same concern. Every time, development evolved and got more powerful.

AI is just the next layer in that progression.

What I've noticed is that my role has shifted — I'm no longer writing code, I'm writing specifications. I describe what I want, I define the behavior, I validate the output. The more precise and structured my input, the better the result. Getting skilled at AI-assisted development means getting skilled at thinking clearly and communicating requirements — which is arguably a more valuable engineering skill than syntax fluency.

The developers who struggled when Python replaced C weren't the ones who understood problem-solving. They were the ones whose only skill was writing C.

I think the same filter is happening now.

Curious if others are experiencing this shift — or if you think the concern about AI and skill degradation is legitimate.

[-]

No_Lawyer1947@reddit

You're comparing apples to oranges I would say.

Yes languages like Python abstract C heavily, and libraries like React reduce the amount of DOM manipulation you have to do, but at the end of the day, these are built on top of deterministic outcomes. Same input will generally speaking produce the same output. This is simply not true for LLM's. That is why it's fundamentally a problem to fully rely on the plinko word machine to consistently do things in a uniform way.

I would not say LLM's are the next layer of abstraction, rather it's an abstraction tool. I know it seems pedantic of me to make this distinction, but I do think it makes a huge difference. It's what makes LLM's great and shit at the same time (depending on the situation), it's ability to generate code that cooks or nothing burger code gets determined by the word guesser, and can very often do stuff extremely bad when one-shotting big features. I've tried skill.md maxing, or tool maxing but my best results still come from slowing down the slop cannon, and taking it module by module where I still have oversight of what's getting done.

I also agree syntax fluency ain't the end all be all, but programming patterns also exist for a reason, and I think AI tools often get the syntactical part correct, it's more so structure, foresight, and balancing over/under engineering where I've noticed LLM's get crappier results.

[-]

Alternative_Win_6638@reddit (OP)

A lot of replies are pointing out that AI is non-deterministic — and that's fair. But so was the C compiler compared to Assembly, and we figured out how to work with it.

Yes, AI is less deterministic than C. An F-35 is less predictable than a bicycle too. But we didn't abandon the F-35 — we learned to fly it. The complexity comes with the capability.

There are well-established ways to constrain and guide AI output — structured prompts, requirements-first workflows, validation steps. Master those, and the non-determinism becomes manageable. That's exactly the skill shift I was describing.

Bitter_Excitement242@reddit

There's basically four big players in the "serious" automated code generation business at the moment (soon to be three). Your only means of generating capital is going to be exclusively controlled by a handful of billionaires. Seems like a path to nowhere.

Or I dunno, you could just write software yourself without being fully reliant on a 3rd party's service. It's not that hard. Slower, sure, but speed was never the issue.

Honestly most of the cope I see on these forums is people thinking "yeah but I can write a really good spec" will be enough to keep them in a job. Anyone can do that. It ain't the high barrier you think it is. Pure cope.

Eventually those services will out compete everyone commercially. At which point I hope everyone's got a life jacket because this industry won't be viable for anyone wanting to maintain a dignified living.

When that happens, some of us will still want to be able to make software, even if it's just for the fun of it. I'm not paying a subscription for the "privilege" to do that.

Well I like to code to for the fun of it. But I talk about production code. See my reply to u/No_Lawyer1947

I_Am_Astraeus@reddit

Insane take that people are pushing that AI is this filter for engineers. Like competent engineers "just can't figure it out".

AI means that the lowest engineer can generate slop with false confidence in a way that was previously inaccessible to them.

Using AI isn't a skill, it takes virtually no effort to use. Even this post reads like AI slop. There's no filter there's just groups annoyed that their peers have turned into brainless regurgitation machines.

Ormek_II@reddit

The big difference is that AI is non deterministic to the user.

The other difference is that not others are in control as with every library I use or with a well defined compiler or interpreter, but a guessing machine.

Yes, you need to validate, but you cannot test code as ready for production. Our world has not yet developed the test set that proofs correctness of the code a million monkeys created. Our existing habits circle around a world where everyone tries to the right thing and eventually get understanding.

If the pure validation cycle we learn with AI, the unnecessary trust towards the AI agent is transferred back to human interaction, then the pope is right and humanity will make a big step backwards.

So, for me the question is: Do I want to become the validator? Do I want to no longer understand how things work and just be sure that they do work?

If they stop working (e.g. eventuelly the whole system gets too slow because of complex interaction) no one will be able to take over from AI and fix it. You will Hit the Agent again and again telling it that the system is still to slow, but everyone lacks the knowledge and understanding to take over.

And I think this might be the wrong sub for a philosophical discussion.

ffrkAnonymous@reddit

Then React, which hides enormous amounts of HTML and JavaScript complexity behind components and hooks. Every time, the same concern. Every time, development evolved and got more powerful.

So powerful they had to invent wasm (web assembly).

teerre@reddit

TIL Python replaced assembly

Great stuff

SwordsAndElectrons@reddit

C is still everywhere. Including inside CPython itself.

I'd say that a person with such naive takes should probably not be doing those higher level things either, but I have my doubts that any of this was written by a person.

It certainly has very little to do with learning programming.

Sad-Sheepherder5231@reddit

I see engineering as viewing the problem from the whole perspective while also zooming on each individual component and being able to deconstruct each component into individual building blocks. How does AI help in that regard?

You define from the whole perspective but without understanding each individual component and their building blocks you introduce subtle bugs and security holes unforseen by the generative nature of the model. Yeah, it's faster, but we're seeing where it leads already. Good bye security, good bye stability. Just consume and be consumed.