will AI wipe out IT jobs

[Lucasxp64]

On 25/09/2026 at 0:18 AM, Ramanujan said:

AI wipe out programming jobs

AI will wipe idiots that don't know shit about software architecture, refactoring garbage code and dropping bullshit requirements, and are just typing monkeys. Or idiots that only know how to use LLMs to get as far as it gets on its own, and can't get the AI unstuck.

As long as LLMs can't get themselves unstuck, IT WILL NEVER replace a human that can get it unstuck.

The hardest thing about code was never writing the code, it's what code to write. That's what differentiates between the human equivalent of an LLM spitting out generic code with no taste and whoever hired them to give them instructions.

The worse part isn't even that, most programmers are peasants carrying on their backs whoever controls the distribution channel and network of high paying clients. An LLM will just shorten the path between some of those clients doing the job on their own and having to do the work of a programmer themselves wasting time baby sitting an LLM making mistakes.

Edited 11 hours ago by Lucasxp64

[bazera]

1 hour ago, Lucasxp64 said:

LLM spitting out generic code with no taste and whoever hired them to give them instructions.

That's being changed rapidly, code written by the newest models are very good actually, if you give them enough context. 

For me, what has changed is that automating coding part at my job allowed me to think on a more abstract level, and realizing the importance of the meta skill of architecture, which I did to some degree on the frontend side of technologies, but now technologies itself are becoming irrelevant and a good software developer needs to understand these structural skills on a much higher level, or else basic coding tasks are being automated very rapidly.

That's why I'm digging into more architectural side's of things now, but hard part is that I have to do this on my free time with side-projects and books because the project at my current job doesn't have that scale and variety of problems to solve. But you have to do that somehow to evolve from just a coding monkey to someone who actually continues bringing value to the company in the AI era.

I think every developer should ask him/herself what value do they bring to the table, prompting? code review? nothing more? what are other more higher-level answers to that question?

[PolyPeter]

3 hours ago, bazera said:

I think every developer should ask him/herself what value do they bring to the table, prompting? code review? nothing more? what are other more higher-level answers to that question?

what if the most important concepts within philosophy can be applied to the intentional design of ever more powerful systems?

I think about this often, and there's something to it

 

Knowing about PRECEDENCE is crucial to understanding the real limits of AI, computing, Human intelligence, and Intelligence in general

My claim is that once you know what comes first, you can clearly see the hiearchy of affordances of existence and its forms. 

 

There is a specific pattern to evolution, and to human evolution as well.

 

[PolyPeter]

Just now, PolyPeter said:

My claim is that once you know what comes first, you can clearly see the hiearchy of affordances of existence and its forms. 

what i mean by this is that human intelligence still surpasses by a lot what we created in the AI field

AI as we have it now, cannot ever DIE, and therefore, it has no sense of being alive or being at all. 

this is why it is not capable of waking up to its true underlying essence, but humans do. 

[Lucasxp64]

Yeah that's true. But I was leaning more towards like you mentioned, the person prompting and managing the AI was in the old days the equivalent to an LLM lol.

I think this all is all obvious to you at this point what I'll say below, but I'll leave it here for the sake of the discussion because I think those are important skills when coding with LLMs.

AI can write code better than I ever did right now, but that's because I already had done my mental homework of thinking through complex problems and developing my software development mental maturity. Instead, what I meant there, is people that simply don't have in themselves that software development maturity of like...

• Testability. Not taking what it said at face value. Making debugging cycle as fast as possible. Not allowing the AI to introduce bugs and break old features
• Not going YOLO and trying to implement too much too fast, but also not wasting time specifying too much.: Knowing how big the "bite" / granularity / precision level the AI needs, and knowing when to bite more at a time, or less, etc.
• git hygiene: Not letting the AI write into the git history "I fixed this" when it's in fact broken. Differentiating between attempt and success.
• git branches: When to plow through on a single branch many features fast or even in a single prompt, and when to break it down on another branch so you can easily ignore or integrate that new feature when it's ready if it's large.
• knowing when the AI is going to a stupid direction that will make the code less maintainable
• Knowing when to ask the AI in chat mode only. No code. Just going meta with the AI and asking its opinion of what to do next, reviewing it and helping make broad decisions and analyze architectural trade-offs. Instead of just YOLOing more features.
• managing your own todo lists, list of priorities, and prompts and not letting it get lost in messy chats that might need to be reversed and the AI losing its precision on what you asked it on long contexts.
• Managing codebase bloat so the AI has a easier time ingesting into its context window and wasting less tokens / plan limits.
• Decoupling vs Coupling parts. When to duplicate and when to go DRY.
• Having the wisdom of when to continue fixing the current codebase and when to start from scratch with better defined specifications learned from that previous version, etc.

Someone developing this experience is obviously better at coding than someone that just go yolo and has to start begging the LLM to stop breaking their code and don't even know how to use git.

[Lucasxp64]

4 hours ago, PolyPeter said:

AI as we have it now, cannot ever DIE, and therefore, it has no sense of being alive or being at all. 

this is why it is not capable of waking up to its true underlying essence, but humans do. 

It's due to its training.

It was training to find statistical CORRELATION within data.

The famous: Hitler was evil because he drinks water, therefore everyone that drinks water is evil. 

It's literally how reward function of the the machine learning model they use to create the LLM models, it's rewarded to be able to autocomplete plausibly the text, and they calibrate it to not memorize it verbatim too much so it gives it flexibility to hallucinate new content. They manage it like a cake recipe of curated text and deranged almost unfiltered internet dumps, somehow when they curate it just right during training it gives it the properties it they got currently.

The issue with that approach, which they have tried to solve over and over again starting with DeepSeek-R1 when they introduced thinking mode fine-tuning via reinforcement learning by simply talking to itself until it was able to score higher on tests.

It works good for things that have clear action and effects like coding, but it fails miserably for learning how to learn, for example, given a new esotetic language that it never saw in its training and instructions to code in it, they cannot do it, their ability to "learn" during a conversation is shallow and dependent on training.

Humans somehow are capable of using their imagination and problem solving skills to come up with their own internal simulation of the world in real time, they need billions of dollars of synthetic material to do the same a child can do because evolution did imbue into us that ability otherwise we wouldn't have survived, we had to deal with learning real cause and effects.

But even then, humans can see fake cause and effects where there are none. Like  all the weird religions and fantastical ideas, prejudice and superstition. Even in humans seeing cause and effect clearly is very hard.

Like how Leo Gura is going on this rampage towards the limitations of science, of how science is so caught up in mapping causes and effects that it believes it can know the substrate of the world/universe via observation from inside of the universe.

Edited 1 hour ago by Lucasxp64

[bazera]

1 hour ago, Lucasxp64 said:

Yeah that's true. But I was leaning more towards like you mentioned, the person prompting and managing the AI was in the old days the equivalent to an LLM lol.

I think this all is all obvious to you at this point what I'll say below, but I'll leave it here for the sake of the discussion because I think those are important skills when coding with LLMs.

AI can write code better than I ever did right now, but that's because I already had done my mental homework of thinking through complex problems and developing my software development mental maturity. Instead, what I meant there, is people that simply don't have in themselves that software development maturity of like...

• Testability. Not taking what it said at face value. Making debugging cycle as fast as possible. Not allowing the AI to introduce bugs and break old features
• Not going YOLO and trying to implement too much too fast, but also not wasting time specifying too much.: Knowing how big the "bite" / granularity / precision level the AI needs, and knowing when to bite more at a time, or less, etc.
• git hygiene: Not letting the AI write into the git history "I fixed this" when it's in fact broken. Differentiating between attempt and success.
• git branches: When to plow through on a single branch many features fast or even in a single prompt, and when to break it down on another branch so you can easily ignore or integrate that new feature when it's ready if it's large.
• knowing when the AI is going to a stupid direction that will make the code less maintainable
• Knowing when to ask the AI in chat mode only. No code. Just going meta with the AI and asking its opinion of what to do next, reviewing it and helping make broad decisions and analyze architectural trade-offs. Instead of just YOLOing more features.
• managing your own todo lists, list of priorities, and prompts and not letting it get lost in messy chats that might need to be reversed and the AI losing its precision on what you asked it on long contexts.
• Managing codebase bloat so the AI has a easier time ingesting into its context window and wasting less tokens / plan limits.
• Decoupling vs Coupling parts. When to duplicate and when to go DRY.
• Having the wisdom of when to continue fixing the current codebase and when to start from scratch with better defined specifications learned from that previous version, etc.

Someone developing this experience is obviously better at coding than someone that just go yolo and has to start begging the LLM to stop breaking their code and don't even know how to use git.

Great list, after 8+ years of manual coding and debugging, I do all those intuitively, and that makes a huge difference. That makes an LLM a powerful tool when working on a big project. I have a co-workers with much less experience (and less care for the project) and I'm always anxious and nervous about what they commit in their PR's because they don't have those intuitive skills you mentioned and can't judge LLM code which clearly needs a good judgement until merged to the codebase.

But now I want to take it higher and develop further intuitive skills that's more big picture oriented and not framework specific. 

I've started with this book: https://www.oreilly.com/library/view/designing-data-intensive-applications/9781491903063/