AI is making me dumb | Hacker News Reader

AI is making me dumb

jpain.io

556 pointsEighth302 comments

I can't relate that much to this. Every time I use AI to write code, I'm constantly fighting a feeling on the back of my neck that I need to look over everything it has done and supplement/alter it with my own code. That ick feeling counteracts the dopamine hit of having a working app after a few minutes of vibe coding, and I don't think that's going anywhere anytime soon.

That said, I have experience. I could absolutely see myself falling into this as a junior or even mid level dev. I'd no doubt not feel that feeling on my neck if it wasn't scarred from code review lashings early in my career by knowledgeable mentors.

Experience is so so valuable right now. We can guide these agents super well, but I do fear for the juniors as you said. I would like to think I'd use the agents to dive deeper and learn faster. It was pretty rough piecing together solutions from Stack Overflow, various irc channels, Reddit, etc. But also, I cheated on my homework in college and didn't really review the answers, so not sure. Though I pursued programming out of interest and not just to complete a degree. Maybe it would have been different. In any case, I'm glad I came into the LLM era with a lot of experience and failures already.

Metrics, profilers, architecture! Use AI to get back to basics! Wanna prove a technique is better? Use AI to make a benchmark! Learn by experimentation! That is my advice to juniors. At the end of the day AI is writing code and there may be 10 different ways to run something. Only one is the fastest in any given use case.

Fastest is usually the wrong metric. But you'd need experience to know that, I suppose...

I think it's just the wrong metric to optimize for _first_. It's not generally a bad metric to keep tabs on though. Make it work, make it right, make it fast? Or something like that.

But the point is that LLMs giving you 10x the potential code output doesn't have to mean 10x the code committed. It can also be "let's look at all three possible implementations in more detail and decide which is really the best fit for our situation, and commit that one."

That's still 2-3x the velocity, but you get a better result because you went deeper on the paths-not-taken when designing.

Yeah I totally agree! I also think people should still be reading as much code as they can. That's always been true imo. It is just hard to keep up with it now because of how much code an LLM can generate for $20/month. I do think we'll move to higher abstractions of course. We won't have to understand code as much as how the systems and components are architected. It would also be nice to use our new efficiency to return to producing truly optimized and fast software.

I don't think "cheating" is the right way to frame it.

A junior has managers pushing them to do more, faster. You review the code but do you really understand it the same as if you struggled through it? Do you ever build the muscle memory of what works and what doesn't?

It is the thought process that builds skills. I've seen some projects trying to be deliberate about learning from the agent as it writes to code - but I'm not sure there is a substitute for struggling and learning by doing.

When the chainsaw fails the juniors, they're going to be adding wood chippers and stump grinders. The seniors are going to be out there chipping artisanal wood blocks with a hatchet. You don't need a lot of history to see who you really need to be worried about.

Its not the internet that needs convincing, its the ones writing the checks

I think this is one of the key takes right now. I too have similar experience.

Which way is it going to go?

i) “Seniors” also get superseded by even more capable models that can do all of the things which currently require experience.

ii) Linguistics become the new higher order abstraction (English is the new high-level programming language) _but_ there are different / orthogonal ways of approaching software development than the way we do things now — which “juniors” become more adept at more quickly.

There's also iii) people realize that if the LLM needs that much babysitting, it doesn't actually add value. So they don't use it very much because it is too limited as a tool.

> Experience is so so valuable right now.

And probably the least valued it has ever been.

> Experience is so so valuable right now.

I think traditional coding experience will be a lot more valuable in 5-10 years, given the apparent inverse relationship between that and LLM usage, and the number of people who seem to already be heavily reliant on LLMs today.

The next killer app on the scale of today's LLMs could be an LLM (or call it whatever) that can un-spaghettify the reams of code that are currently being generated by LLMs.

> after a few minutes of vibe coding

Don't vibe-code, it's a joke someone coined in the moment, that somehow the industry decided shouldn't be a joke, and some people think it's a feasible way of developing stuff, it's not.

Find a better way of working together with agent, where you get the review what's important to be reviewed by a human, and "outsource" the rest, and you'll end up with code and a design that works the way you'd program it yourself, you just get there faster. I probably end up reviewing maybe 90% of the code that the agent writes, but still it's a hell of a lot more pleasant writing/dictating a few prompts over typing tens of thousands of characters and constantly moving between files. Maybe I'm just tired of typing...

There are tasks where it is appropriate to vibe code

Agreed, whenever you're 99% sure you'll throw away the code afterwards.

Internal/personal tooling, marketing automations, etc. tend to afford it without needing to throw it out after. These are also cases where you can simply rewrite later without having to address a mountain of debt.

If you do this work for a wage and are nearly fully alienated from the value of your labor, I understand the distaste for applying it in any circumstance. You'll care more for your personal experience of the work: how informed you appear when reporting on it to your colleagues, how your boss/colleagues will judge you when an issue arises, how much you feel you are learning from the work, how frustrating it feels to return to items at the behest of others, etc. Vibe coding in these circumstances is unpleasant.

I care about building programs that work, do their thing well and are easy to change today and in the future :) I'm not sure where you're extrapolating the rest from, vibe-coding simply isn't for long-lasting software, you need to actually be involved then. Don't get me wrong, most of the code I "produce" today is written by LLMs/agents, but almost none of it is "vibe-coded".

Personal tooling especially, since you want to be able to just do small changes over long periods of time, it's important it makes sense when you come back to it, even if you forgotten all about it since your last change.

Yeah, the problem is that "code you're sure to throw away" includes school coursework.

That's always been one of the problems, though. Writing code for class is much less stressful than writing code that other people will rely on.

I let Claude translate a horribly written vb program writing some xml data into a pdf form. Most of the code I didn't even read until much later, I just checked the end result. The code won't be touched again, and if it will simply be replaced. Some code is foundational and you should put a lot of effort into it, a lot of code isn't though.

Other than that agentic coding has not really been working that well for me at our main codebase though.

I've been thinking of using Kiczales's Systematic Program Design [0]. Write the skeleton. Let the IA fill in the blanks.

[0] https://news.ycombinator.com/item?id=16563160

great point, i've found the htdp/recursion scheme approach works quite well, even when using some smaller local models... i loved taking prof. kiczales course, the materials are publicly available, still: - https://cs110.students.cs.ubc.ca - https://cs110.students.cs.ubc.ca/admin/links.html

I'm curious about how people link ideas and remember them. If you don't mind sharing, what was your process to save and remember this particular post from 2018?

I took the course more than a decade ago on Coursera, this is how I found the HN comment I linked.

Vibe coding is fine. Its just the next step.

Python for example is vibe coding compared to C. You pip install some library and just use it. Wanna modify a class instance variable and not use the proper accessor function? Sure, go right ahead.

The big thing about vibe coding is, as ironic as it sounds, prompt engineering. You can have tons of slop, but if it works, it works. The key defining factor is what constitutes as working. Namely, defining input output contracts, and automatic checks.

I agree with your sentiment. I've been trying to get from plan -> complete with AI and it's been working very well in a sandbox.

I am trying super hard to give the tools to validate everything to AI.

I finish by opening a draft PR and then I go through doing a deep review myself.

If I didn't already have 10+ years experience, it would be hard to learn and not atrophy with easy shortcuts being so available.

You still need people who know stuff in detail and can own the code... for now

Fully agree. I supplement my game development with AI. Anything novel or interesting I want to do, I need to write the code for myself, otherwise I'm in for a world of hurt. But for the drudgery work that is necessary to invest a lot of time in but boring to actually write, I design a clear architecture and ask AI to do the implementation leg-work. And still you have to go back over and make sure it didn't decide to just create something outlandish. A good recent example is Codex trying to recreate from scratch the behaviour already provided by Area2D in a game I'm making with Godot.

If you try and get AI to do anything meaningful, it will be riddled with footguns and bizarre choices. Maybe if you have hundreds of dollars worth of tokens that might not be the case - but for someone who spends $10 a month, it's just not worth the headache.

Besides, for me these are hobby projects and writing code is still fun, I just make AI write the boring parts (good examples: saving and loading, parsing of data files and settings menu functionality) - but I keep it away from anything that needs a humans judgement to create.

I have the same feeling on the back of my neck. I think it’s born from my crippling imposter syndrome, which is maybe a super power now.

In my experience, Claude only knows how to spew code. Every problem you want it to solve, it translates into "more code" rather than "less code". You have to very closely code review everything it does, otherwise your codebase is going to just grow and grow, and asymptotically approach 100% debt.

I code review everything that Claude produces, and I'd estimate about 90-95% of the time, my reaction is WOW it works but too much code dude, let's take 3 hours to handhold you through simplifying it until nothing more can be removed.

Of course it writes a lot of code. It gets paid per token. That's guaranteed future income every additional line of technical debt.

Periodically you can also ask it to review the recent changes and see if there is a risk-free way to streamline them.

You can also tell it to periodically summarize the "lessons learned" from the recent session(s)

Then local models shouldn't suffer from the same problems, but they do. They just aren't trained in the direction of "less code == better long-term maintainability" I'd say, rather than some grand "increased-token-usage" conspiracy.

You can certainly steer them a bit to reduce the issue parent talks about, but they still go into that direction whenever they can, adding stuff on top of stuff, piling hacks/shim on top of other hacks/shims, just like many human developers :)

Training data is the masses of code from everyone.

Restrict that data to just the best of the best, the tersest of the tersest, and we’d see better output. I don’t think people are sharing that kinda stuff (Jane Street’s gems stay locked up), and even if they did my presumption is that it’d be too narrow and demanding for general audiences.

Big hopes for the long future, damned to some degree of mediocrity in the near term mass product.

At some point they’ll introduce “deletion” tokens that cost ten times the regular token price. ;)

>> Of course it writes a lot of code. It gets paid per token.

I don't buy it. I think a much more likely reason it leans towards adding code is because deleting code carries inherent risk: it can break things in major ways or minor ways or very visibly or invisibly. Adding new code, on the other hand, is a lot safer: the only parts that can break are those the AI touched inside its own working context. So it doesn't have to go down rabbit holes and potentially create bigger and bigger messes.

A lot of people seem to think if you give the agent a framework and clear plans that it spews "good" code. I doubt it though.

I haven't used Claude, just Sweep, Copilot and whatever Jetbrains has. But they've definitely deleted code, not just added it. I know, because they have deleted code that I definitely still needed, and I had to reject those changes and start over on the prompt.

Here's what I do

Tell it "Do not change any files yet, just listen." Then we discuss the problem. Then I have it write to a file it's understanding of the change.

I review that carefully. Then I let it implement. I approve each change after manually looking at it. I already know what it should be doing.

Make smaller changes and check each one carefully before and after.

This is a reasonable approach but has nothing to do with what is being pushed on us from all sides.

Same. Luckily I enjoy the process of refactoring and deleting code is nearly arousing, so I get the initial dopamine rush of wow this works, followed by the dopamine rush of "wow now this is cleaner and works so much better". Keeps me in touch with the codebase too.

Pruning code is to software engineers what cancelling plans is to introverts :)

I think I need to work up a Claude skill named marie-kondo, so that when it breathlessly presents its triumphant solution, I can go “yes, but does it spark joy?” And have it go into an aggressive refactor loop with me.

Sounded like fun so had Claude do one up here: https://github.com/fragmede/marie-kondo-ai-skill

Hypothetical future callers, "for extensibility" abstractions, single-use helpers, ceremonial try/except blocks, and options dicts with one key all get culled.

—

But this is never the problem. Claude WILL NOT abstract and WILL NOT use your abstractions. It finds them all “ceremonial” and the idea that you could add something that might seem indirect that actually dramatically reduces the problem space is almost impossible to convey.

You can watch this in action for any API whose design you’re familiar with in a domain you understand well. If you attempt to design the same API with Claude, your will invariably get a mess of flat, insane types and no reuse. I’m talking an array of tuples of maps of set to map type insanity.

What has been helping is a mandatory pass of “Claudisms”, but even then it can only find the problem and never the solution.

It is so frustrating.

I question any dev who doesn't get aroused by deleting code.

I just removed an entire graphql endpoint - 500 lines of front and back-end code. I may need to be hosed down.

Get a room!

Oh my. I may not want to know what selecting all and then pressing Delete would do to you.

`$JOB` recently introduced the `#red-diffs` Slack channel. I just submitted ` +4 / -28,742`. Pretty proud.

It's so beautiful.

At this point, it's worth asking whether lots of relatively straightforward verbose code is actually significantly worse than the least code necessary for the problem. Obviously, architecture matters. What might matter less is verbosity.

The reason we aimed for minimal "accidental complexity" up to now was directly related to the cost/pain of changing and maintaining that code. Hasn't the economics of maintenance and change shifted so much that accidental complexity isn't actually all that expensive/painful?

I think a bit of refactoring, renaming and restructuring has been helpful for maintainability but recently I've been a little less inclined to worry about the easy readability of function bodies and fine implementation details. It still feels wrong but I can't justify the effort anymore.

> Hasn't the economics of maintenance and change shifted so much that accidental complexity isn't actually all that expensive/painful?

I sincerely believe that extensive accidental complexity will ALSO be bad for AI agents. Their quality will diminish as their context windows get filled up with endless amounts of spaghetti and accidental complexity. I feel like we won't fully start feeling those effects for another year or so.

True, yet they have a Moore's Law like growth going for properties like their context windows.. I think the larger problem with letting them be verbose is Occam's razor. The more verbose they are the more variant behavior they will have where any variation that is not strictly necessary is likely to include incorrect behavior.

Attention is an O(n^2) algorithm. Combined with Moore's doubling, it will at best produce linear growth (assuming Moore's law is still remotely close to alive)

I don't think many developers like software bloat or what it has meant for our professional reputation but we would be dishonest if we predicted a future without outcomes where ugly brute force wins given all the constraints. It is not Moore's law that dictates context window that is only an analogy and so far it has been exponential growth that went from well bellow humans to more than a human can deal with in terms of short term tasks.

>Isn't the economics of maintenance and change shifted so much that accidental complexity isn't actually all that expensive/painful?

Not while context windows cause decay and larger bills.

The AI's max cognitive load C is larger than a human's, but if codebase size grows unbounded the minimum context needed for a change will eventually surpass C.

It is also a bad idea to let your codebase become only readable by a machine when we are still in the dark about the role machines and people will take in the future. What if you have to go back to manual dev in a now gargantuan codebase?

I'm been in a community that makes a lot of cognitive training software. There's some core open source projects that were created without LLMs, but new projects are now mostly created by young people vibe-coding from scratch or forking and modifying the existing projects with an LLM.

The answer to your question is really obvious. The high-effort manually coded projects stick around and the low-effort vibe-coded projects are forgotten about quickly. In the end LLM-driven programming is always going to bring you to a dead-end. There's certain things where I can predict that they're going to fail because it's going to involve certain kinds of complexity they can't and will never be able to deal with. The code gets so bad that even if an expert programmer wanted to make changes it either wouldn't be possible or worth it. A lot of the time the vibecoders are so high off the low-effort sense of empowerment that they don't even realize what they made is completely broken.

Well written software has staying power because it can be understood and built upon. Understanding a problem deeply enough to devise an elegant solution even leads to new possibilities and ideas that will never be conceived with a more superficial understanding.

A problem I’ve found is that when you’re adding functionality or refactoring it often leaves unused methods or types behind, at least with multiple devs working on the same codebase.

This unused code gets further modified as time goes on: new functionality is wired in, or it gets further refactored. Usually it’ll still have tests that cover it. It gives the impression of being live code, but it’s not: it’s zombified.

So you get situations where it gets wired up to something and then that something doesn’t work and you wonder why and so you start digging about and you discover it’s because it has been wired into a path that is never executed.

The fog of relatively recent changes sometimes makes it hard to figure out if the code should be unused or if someone just forgot to hook it in as part of a bigger piece of work. Then you find nobody else is really sure either.

So that extra complexity comes at a cost. It can slow you down or trip you up; catch you by surprise.

I don't think people are talking about the least code possible, just not incredibly verbose and inefficient like what you get by default from llms.

For example I have a game I've been working on for a few years, I do stuff like "implement this simple psuedo physics system to make the bot follow the character like so...etc"

After some planning and back and forth.

It returns mostly working code a little odd on some edge case.

But as I've hand coded this thing for years. I could easily look at it. Laugh my ass off, it had multiple classes and around 1k lines of code, all kinds of crazy non performant crap.

The exact thing I needed, I reprogrammed in around 5 lines of very simple code that did exactly what I needed with no edge case weirdness.

Now the vibe coders actually ship that shit. I like to read vibe code games now and again, and there is no possible way those guys are ever shipping a real game, as every single decision is verbose along with the worst performance decisions over and over everywhere.

Sure it can get you some cute little toy projects, but it will absolutely fall apart if you are trying to make real games.

Don't know about saas apps or whatever. Maybe that stuff doesn't matter at all.

With SaaS apps, I've found you either have to hand write a framework for it to use, or put an even greater amount of effort into double-checking and correcting it. Then you can point it at bugs and features, get it to write tests for you, and so on. If the code's too wordy, who cares? Keep the blast radius to self-contained modules and the AI can't mess up too badly. Whenever you abstract something or the work is critical, you need to go back to hand writing everything.

Abstractions are like the structural elements of a house, security is like plumbing or electrical, but individual features are like carpet and paint. When it's working on the superficial stuff, who cares what it gets wrong? Just go rip up the carpet and do it again if you have to.

  > it's worth asking whether lots of relatively straightforward verbose code is actually significantly worse than the least code necessary for the problem.

The question is wrong because reality isn't binary. "We've" never aimed for minimal, except maybe in the very early days or some real edge cases

If you're writing the minimal code you're either writing something very compact/simple[0], or you're wasting too much time and not balancing things.

If you're rewriting everything then you're wasting too much time and introducing too much complexity[1].

You can't write good code by slapping together a bunch of libraries but that doesn't mean you shouldn't use libraries either.

[0] "simple" is an overloaded term. If you're upset by me saying "simple", I'm using the other definition

[1] sed -i [0] "s/simple/complex/g"

> Hasn't the economics of maintenance and change shifted so much that accidental complexity isn't actually all that expensive/painful?

They have, but not in the way you mean.

AI knows nothing about software engineering. AI is a technical debt generator.

You can mitigate this somewhat if you put an actual software engineer at the helm with lots of prompting, but at some point the technical debt accrues enough that neither humans nor AI can fix anything.

As an example, this is what happened to OpenClaw. (And why you suddenly stopped reading hype about it.) OpenAI paid millions for literal trash.

I think this is more a by product of the way these models are architected. “One more token” i usually much more likely than a “STOP”. Knowing when to stop and doing more with less is something also very hard for human developers.

For me what throws me off most of the time is the structure on the mid-level. It usually makes sense in the loc and maybe project level, but on the file and folder level it just loses reference on what it already has or what it does not need to be too verbose about.

> I think this is more a by product of the way these models are architected. “One more token” i usually much more likely than a “STOP”.

That’s not really how it works. An agent wouldn’t get halfway through _any_ implementation and just stop abruptly - it’s not as simple as rolling the dice until you land on “stop”.

It will stop when it believes, for whatever reason, the output has achieved whatever task was laid out. You’re welcome to refine what the definition of that task may be, or you can let it go off.

A particularly pronounced version of this can often be seen by letting 2 agents review and code in a loop. One agent will find some problems with the code, the other agent will address the review by adding more code.

A good human developer might see that the better way to address the review is to backtrack and pick a different approach. The ai agents seem more prone to getting stuck down bad branches of the decision tree.

Try codex.

Hey that’s my exact experience. I started coding the interfaces by hand which helps with the architecture but you still have to say, “don’t add a bunch of helpers and stuff, stick to filling in the stubs.”

Then I only have to spend one hour handholding the clanker to get it perfect. I usually do a lot of manual refactoring as well during that time.

This was a large part of my problem with Claude code, it is far too eager to get to the code writing. Matt Pocock's skills and Codex I have found to work together quite well. You still have to ensure design/architecture is being followed, and review carefully obviously, but Codex by default seems to look for minimal change approach a lot more than Claude does/ever did.

I'm curious how much you have tuned your CLAUDE.md file. You can get very specific and direct about what your expectations/desires are. You can also have another agent do a critical review with your expectations/desires and feed that back.

Just be careful to not put too much in there or it won't have enough attention left over for the tasks.

Look at the doc hub pattern if your {agent}.md file is getting more than ~100 lines.

You can also tell it to specifically focus on removing unnecessary code as a pass, and it does that pretty well.

I do one of these occasionally and it usually finds redundancies and/or inconsistencies to clean up. It's very effective and should be part of any process involving agentic coding.

It really does want to make everything overcomplicated.

I end most of my pre-plan prompts with "KISS - Keep it simple" to keep it mostly under control.

I also keep each file under 1000 lines and do a full scan of code and docs for cruft every 20-30 task cycles.

Been working on the same project for six montha and glad to say there is minimal bloat.

>asymptotically approach 100% debt

What to do if you're just one dev in an org of 50? Who are all pushing more and more code every PR? I'm gonna have to leave aren't I :(

Pretty much, unfortunately. I was recently told at my job that I need to stop being so critical of AI, and encouraged to at least pretend to use it. Never mind that I've pointed out that my disuse is not because of being stuck in my ways, but because it slows me down rather than speeds me up. I guess management wants AI use no matter whether it pays off. It's clear that my options are to embrace the clanker, or find a new job.

  > let's take 3 hours to handhold you through simplifying it until nothing more can be removed.

This is why I'm unconvinced that AI code makes me faster. Sure, I could produce a million lines an hour but are we running a sprint or a marathon? I don't know about you but I can't sprint a marathon.

I think much of the world of software has become incredibly myopic. I get it, it's a lot harder to win a war than it is to win a battle but just usually taking the easy way out is just deferring the costs to your future. Problem is that those costs accrue interest... Personally? I'm lazy and a cheapskate.

When did programmers stop becoming lazy and start becoming lazy? More importantly, why?

> I think much of the world of software has become incredibly myopic. > usually taking the easy way out is just deferring the costs to your future. Problem is that those costs accrue interest.

This sums up my thoughts perfectly lately, that is a great way to put it all.

Programmers have never been any good at measuring or estimating their own productivity, there is no reason to assume that has changed (one could argue theres ample reason to assume the opposite).

Part of the problem as well is that there is some unseen/unnamable "spaghettiness"/"sloppiness"/"whatever" factor, that scales very very poorly. At the beginning it can seem fine, especially when you have some constant speed multiplier like an LLM spitting out code - but the larger exponent of the function that results from this factor being "worse" will eventually outpace that constant multiplier. You will only see it once its too late, or will never see it all because of our myopia as you say.

> Every problem you want it to solve, it translates into "more code" rather than "less code"

Try Deepseek or Xiaomi's Mimo. They produce very lean code.

Multiple rounds of specialized sub agent peer reviews that are prompted to counter this works really well. Once you have the right pipeline in place you should not be needing to do the simplifying yourself very often.

Claude -> specialized sub agents peer review -> specialized sub agents peer review -> repeat as many times as needed

It’s not worth your time until you’ve run through such a pipeline.

> I'm constantly fighting a feeling on the back of my neck that I need to look over everything it has done and supplement/alter it with my own code

Can relate but the only thing I do different is I teach AI how to cleanup after herself in followup prompts, sessions and refining AGENTS.md. Static code quality analysis tools are also really good to keep the agent on its toes.

Reading and writing are related, but separate activities. One's capability to write code can degrade independently of one's ability to review it.

The thing is that you seem to have that luxury to be able to dig more into the problem and scratch that itch.

But the industry is changing around you fast.

If MIT-bred devs were already building crap in faang before, the trend has been getting nothing short of worse across the industry.

Expectations are rising, the field is becoming a rat race of which engineer can output the most mediocre/acceptable/good enough amount of features in the least time as possible.

Let me make this clear: you're in an increasingly rarer bubble where you have a luxury that is disappearing in this industry, plain and simple.

I have the fortune of having stellar devs around me, people that contributed to projects and software you use every day.

They are also outputting magnitude of order more than they ever did, and none of them is getting genuinely better at the craft, but it is what it is.

I've been using it mostly to bat away yak shaving rabbit holes one can get into when working on a large and complex project. I work mostly on platform work, which is generally nebulous in its feedback loop and testing. Relegating AI to refactoring and building tools to help me research keeps me focused on solving the actual main problem I'm trying to solve, reduces context switching. I really don't understand people who use it to bat out their main focus. I simply don't trust it at that level.

> I'm constantly fighting a feeling on the back of my neck that I need to look over everything it has done and supplement/alter it with my own code.

On the flip side, I'm working on stuff FAR more challenging than I would ever be able to do on my own.

My brain is melting because I can barely keep up with learning how to figure out if I'm even doing what I'm trying to do.

AI might be making me a worse coder, but I don't care. If it hasn't "solved" coding now, I'm pretty confident it will long before my career is over. I don't have a job because I can write code - that's a small part of it. I have a job because I can get things to work. Anyone can code things that don't work (especially AI).

AI is certainly making me a far better overall engineer. Instead of spending my time trying to make the compiler happy (or fixing dynamic type errors at runtime), I can spend my time trying to solve substantially harder problems that I would never even dare try without an entire team to back me up (i.e. never).

Coding - imo - is VERY low on the totem pole of engineering skills.

I don't care if the function is pretty. I care if the system is upholding invariants and performing as expected, and there's adequate testing in place to PROVE to me that it ACTUALLY works.

High performance concurrent code has always blurred the line between sorcery and arcana... Go didn't really solve that. Rust/Tokio didn't. Zig didn't. C certainly hasn't.

It might be easier to prove to yourself, if you're the one doing all the writing, but at the end of the day, code is rarely just for you...

You probably should have the same level of proof whether you wrote it yourself and just trust yourself bro, or whether a Chinese Room wrote if for you.

I feel like I'm living in a Brave New World, and - at least for the time being - I'm enjoying it, even if it feels like I'm sprinting as fast as I can and still unable to keep up.

> My brain is melting because I can barely keep up with learning how to figure out if I'm even doing what I'm trying to do.

This is not a good thing. You should understand what your code does. Writing code nobody can understand is not a flex.

> You should understand what your code does.

It is not hard to understand what a line of code does...

It is hard to keep up with solving the problem I'm trying to solve...

What are you working on?

I feel the same way, and yet I would still say I feel AI usage atrophying my thinking skills. I feel less tempted to use it to shortcut whole files, but even just using it to speed up looking up and carefully reading docs, tinkering with a library to understand it when docs are inadequate, working out the tradeoffs for design decisions... These sound less objectionable and more like simplr speedups, but when I _do_ need to do it (because the agent refuses to do it properly) I can feel the friction so much more keenly. Whether that's just me losing the habit of those specific tasks, or a generalised loss of g-factor, I don't know.

Maybe like a certain blurriness to the edges of those task’s schema? Like becoming a manager or reviewing an intern’s work?

I really enjoy having the AI write the spec then I write the code.

Reviewing code is pain, reviewing requirements and giving feedback feels more productive. I have to confront the full shape of the problem and I usually discover a few cans of worms that make me rethink my approach.

Yeah, I'll talk out design with AI in a brainstorming session.

Then I'll usually go and implement at least one piece of that. If I get stuck, I'll ask for some help. Then, once I'm happy with it, I'll ask the AI to review what I came up with. Then typically ask it to stamp the pattern around the codebase. And often to just iterate through writing out unit tests.

So I just did this for getting dense output from interpolants for an ODE integrator that I maintain. I did the work to make Tsit5 work by hand. I asked AI to stamp out the same pattern for DP5 and BS3, because it was just gene splicing those changes into a very similar RK integrator. I can review the diffs and see that it faithfully stamped out the same pattern with two prompts and a couple of minutes.

I'm still maintaining pretty strong contact with the codebase by doing a lot of my own programming, and fighting with the design while I'm writing that first piece of it, but then I use the AI to stamp out the mindlessly repetitive stuff.

That just seemed like the obvious way to me to go about programming with AI rather than pure-vibecoding and never touching anything other than prompts.

Also, you probably run out of tokens a lot faster if you're pure-vibecoding.

Plus you should spend some time debugging your own code. Even if AI could find and fix a bug in a minute or three that would take you 20 minutes, it is generally going to be better for you to burn that 20 minutes on trying to fix it before asking for help.

Of course, unlike another poster in this comment thread, I never cheated in college and spent a lot of time on "academic" side projects that weren't part of any course I was taking.

Once the vibecoders and cheats are done spamming a billion lines of AI generated code into industry, there's probably going to be positions for people who can (with AI assistance) sort out the mess and get production stable again.

Learning from code review lashings is amazing in its effectiveness and minimal blast radius! I'm glad you were able to take that in the easy way.

Scar tissue from production going down and staying down is probably powering those code reviews and I think will be teaching this wave of vibe projects a few hard lessons. I've had to learn a few things the hard way like this and it's as effective as it is painful.

I'm very pro ai-generated-software in the right context. I think being able to vibe out software as needed is awesome and could finally unlock the potential of our computer and data dominated world. I also think we haven't yet learned as a culture where this new thing is different from traditional software and misunderstanding that is where a lot of the pain will be felt.

I'm a very senior dev (32 years exp) but I've got the process nailed down tight enough with .md documents, skills, review agents, etc, that I don't typically have that feeling or any need to do anything extra.

I don't think this makes me dumb though, I've just moved up stack. Rather than caring about assembly language or source code, I'm focused on requirements, architectural decisions, engineering process, and ever more automation.

Every engineer to manager has the same thought but after a few years they can barely code.

Are you the one coding a fix if there's a bug in production? If not, then you do not have the process nailed down.

I'm using a local model. The code gen is never fast beyond the first few context. As the context grows, it slows down. It's basically it's own self limiting process. When it starts doing things, the threshold of lethargy lowers and triggers me to 'do it myself'; especially, I've developed the understanding of knowledge where it starts doing stupid things and that's valuable.

There must be an epistemic problem with just how fast these SOTA models run. I don't think it's just that my local model is dumber, I think it's more that the speed of token gen trains my brain with different expectations. There's no way it'll just generate hundreds of files by itself. When it can via a opencode loop with thought files, letting it run for a day is the only way you get that.

I think this instinct is intrinsic, and comes from really caring about detail and wanting to fully understand it and own it.

That's what drives it, and I don't really think the extrinsic things about the way you learned (while helpful) have that much bearing on it. It comes from you and you should take credit for it.

I think if you were learning today you'd probably find have the same feeling and do just fine because of it.

The code that LLMs produce is just average IMO. I wouldn’t call myself an authority on clean code but I can tell when code is well structured. I prefer my hand written code over Claude or GPT’s every time. I once did an experiment where I generated a spec from a project I’d already written, then had an LLM blindly reimplement it from the spec, and compared code. The LLM’s version looked like vomit.

Agree, however in some cases avg code is good enough, especially when refactoring it is just a little attention and more tokens.

As someone now firmly in the "used to be a developer" part of my career, AI use seems like good old atrophying of the memory muscle of coding. Whether it's because you just don't code anymore at all, or offload that thinking to AI, the effect on you is the same. You start to forget.

Don't have AI do anything you want to stay sharp on.

Yesterday it got completely tangled trying to fix a dependency issue across different platforms in react-native. I had to manually undo Claude codes shit, read the docs and install deps in a certain order to make it work correctly.

I have no idea what a junior/non-tech person would have done. Like I have wrangled with JS dependencies for 10 years so so I very quickly identified Claude was about to create a tangled nightmare.

I'm the same way, which makes sense because for 20 years I've done things by hand, tediously managing every line.

I hired a few fresh grads and they have no problem just going with the default AI output. As long as it works, they are good.

For me, it comes down to the ability to properly test. If the code works, is covered by tests, and its performance is measured for regressions, and the high level design is sound, it's hard to argue with vibing. The problem is almost nobody has such a testing system. They are still hard to find and/or build. So that's what I'm putting my effort into because otherwise I'll have trouble sleeping at night (for good reason)

As a developer, I kind of feel like this all smells like job security.

After using LLMs for a while, I have to admit it's pretty nice, and I like using it. I've been vibecoding a few apps, and it's a good dopamine hit to immediately see your ideas come to life. However, based on my experience, it will bite you if you trust it blindly. Even in my vibecoded projects, it keeps adding "features" without me asking for them. Since they're just pet projects, I don’t really care as long as the end result is what I'm expecting, but I don’t think companies will be as flexible. I also don't think customers would like it if features changed or got added with every new fix or update.

So this could go in a bunch of different directions from here, but to summarize the current situation:

    A lot of companies are heading in this direction.
    Without proper engineering, AI will easily write more code and potentially change the application unintentionally.
    We will have fewer junior engineers entering the market because of fear around AI and reduced hiring.
    AI usage will hit a critical point where it is making massive amounts of changes, and the people "prompting" it might start getting overwhelmed.
    We will end up with more features that people have to keep in their heads. I don’t think we can trust LLMs 100%, and because of that, developers will still need to know exactly what the application does.
    Eventually, there will be a lot of bugs, and developers will complain that we need additional human resources.
    Hiring starts again.

I think, right now, the toughest position is for new developers, and the best position is for people already in the market.

this is pretty much my conclusion. I try very hard to teach my interns the straight and narrow.

While I agree with the general sentiment that decentralized, bespoke solutions will explode, and require some maintenance (which may in-turn result in more hiring), I've seen plenty that still makes me hesitant to fully embrace this idea as likely. I know this is a wall of text, so forgive me while I doom-post my thoughts for a few minutes:

For one thing, the efficiency gains are massive. Bigger than any other tool, for any other price. Our company's main product is a web-app. We've been working on a re-write of our main product over the last few years. In one afternoon, I set up a new project with our desired stack, and was able to vibe-code an MVP of our product that we've been working on in a matter of hours. It wasn't perfect, of course, but I prompted feature after feature in bite-size prompts, each one taking between 5-10 minutes to complete. It looked pretty professional, and by any measure it was certainly "good enough." Given a little more time, I could solo ship and maintain what has taken us a few years to build as a small dev team. Unfortunately, this is more like a cheap "full team-replacement" rather than an efficiency-improving tool

Then there's the non-technical CEO AI hype-train. Our CEO (and the rest of our directors) have fully embraced the Claude suite of agentic tools. They're all regularly spinning up mockups, apps, and toolchains every single day. I can tell they're addicted to it, and they see the gains first-hand. In fact, while it hasn't happened yet, I wouldn't be surprised if the CEO laid off the majority of the dev team and vibe-coded the entire app himself (along with a few experienced devs). For now, they hold the view that "AI is a multiplier, not a replacer!" and in the same sentence will say "if this allows us to go the next few years without hiring again, that's a win!" I was asked point-blank why we couldn't just vibe-code our whole app. I didn't really have an answer. Yeah, there's the nice thoughts like "we wouldn't know how to maintain our app" -- but Claude would do a decent job in a single dev's hands, or "AI will potentially change the application unintentionally and introduce bugs" -- but proper observability, testing, and further prompting could fix those things in minutes to hours.

Frankly, it just doesn't make sense for companies to keep their whole dev team around anymore. No matter how many projects you launch and initiatives you tackle, the backlog will rapidly shrink, while individual dev capacity grows to exorbitant heights. Non-technical CEOs don't care about tech-debt, cognitive debt, poor software design practices, learning to code, keeping devs smart, the joy of problem solving, the art of a good algorithm or architecture; they care about shipping a product that works reasonably well, provides value, is worth paying for, and doing so for the cheapest investment possible. Unfortunately, AI fits THAT bill in nearly every single way.

I'm hoping you're right, and that the sheer volume of software being created now will increase demand. I'm worried, though, that it will never be enough to offset the massive capacity gains we get from AI.

> Yeah, there's the nice thoughts like "we wouldn't know how to maintain our app" -- but Claude would do a decent job in a single dev's hands, or "AI will potentially change the application unintentionally and introduce bugs" -- but proper observability, testing, and further prompting could fix those things in minutes to hours.

I was thinking about that the other day when I was automating a workflow: I hooked up Jira to Claude so that bug reports would automatically get a pull request. Opus 4.7 is pretty good at it. And compared to dev costs it's still quite cheap.

It's nice to not be distracted by simple bugs, but aren't I killing my own job?

> Bigger than any other tool, for any other price.

For as long as the investor money runway has asphalt left.

> was able to vibe-code an MVP of our product that we've been working on in a matter of hours. > Given a little more time, I could solo ship and maintain what has taken us a few years to build as a small dev team.

Sorry but this just sounds fake. Team spending a "few years" rewriting a web app, Claude doing it in a matter of hours. What the hell were you guys doing the last three years.

Yeah, good question. It's certainly not fake, we've been working on this rebuild for the last few years, but maybe Claude's ability was a bit embellished.

> What the hell were you guys doing the last three years.

I believe some call it "development hell"? We were working hard every single day, yet poor management, dev turnover, and poorly defined scope led to a constantly broken, constantly refactored system. Too many cooks, and no chef. Our small company is full of inexperienced people, including PMs, who had never taken on a project of this size or scope.

To be more clear on Claude's role: I didn't vibe-code the "final product" we've been aiming for in a few hours. I built a limited feature-set MVP, consisting of a front-end, and a new API on our existing back-end. Claude was able to take our existing models, with a few tweaks I described, and build new controllers and a new front-end for a handful of the features we've been working on migrating over to the new system.

Realistically, I gave it the well-defined soft-ball features. I don't know how it would perform given the more complex features, especially when it would need to integrate with its existing work in an extensible way.

> Eventually, there will be a lot of bugs, and developers will complain that we need additional human resources

I just hope I can last that long.

That is where I'm at too. I agree with other posters that this looks a lot like the outsourcing craze around the turn of the century. Things looked very dire then too (I remember being in high school and being advised by adults that there would be no programming jobs left when I grew up), but it eventually swung back around. The trouble is, "eventually" is cold comfort if you're out of a job today. Anyone working in the tech business should be tightening their belts just in case they are the unlucky ones to be out of a job until the madness blows over.

There are a lot of similarities to the outsourcing boom a decade or two ago. Lots of small/cheap companies saw that they could hire an entire team of devs in another country for less than one US developer and jumped on it with high expectations but low process. Many of them didn't do anything to make it successful. They blindly hired the cheapest option they could find, gave them some vague requirements, and had very little ongoing technical review or oversight.

The process often went the way you're describing. Initial rapid success as prototypes got up and running quickly with the messiest code imaginable. But over time progress slowed more and more as tech debt and poor decisions created an increasingly large drag, eventually resulting in a stalled/dead project.

Maybe this time is different, but a lot of my early work was cleaning up projects that fit this pattern. I hope the new up and coming developers will get the same opportunity.

>As a developer, I kind of feel like this all smells like job security.

Ditto, but as an infra guy, doubly so. People are making infrastructure decisions, they are writing config files, they are writing scripts and hacks and everything with AI. People are vibe networking entire ISPs. I saw one guy showing off how he had replaced his entire monitoring system with Claude. Its going to be good money for people with abstract problem solving skills. I cant imagine all the fun new problems people are vibing up for me right now.

We talk a lot about the risks of AI in schools, but those same risks apply in any learning environment.

I recently started a new job and I find that AI is making it so much harder for me to onboard. I am adjusting to my role much slower than my peers who are using AI less. I am coding in a language I am unfamiliar with, which makes the lure of vibe coding stronger. I am at least skilled enough to recognize when Claude gives me an answer that either makes no sense or is unnecessarily verbose. But the more time I spend asking Claude to write code, the less I feel like I'm developing the skills that the job requires. Plus, when I submit a PR, I lack the necessary confidence in my own work, which just feels bad.

Honestly, another part of this is that I'm asking Claude to search through Slack and docs for answers to questions when I should just ask another person. The AI is feeding my social anxiety, luring me into avoiding human contact that I know will be good for my understanding as well as my general need for social interaction.

That all sounds like I am absolving myself of responsibility, but I think it's important to point out how a given technology is especially addictive for a certain type of person, and traps them in a negative behavioral cycle. If I hold off on relying on AI now, I suspect I can grow in my skills to the point that I can delegate tasks to AI that are rote and easy for me to verify their results. It feels challenging, but it's necessary.

It is the worst time for the apprenticeship system (internship). everyone expect you to ship fast and good with ai, but you can barely have the time to pick up any skills during the fast iteration.

I’ve found the LLMs quite useful for summarising a codebase for me to quickly get a grasp on it.

It’s one of the real use cases I’ve had other than basically vibe coding

I'd suggest going the route of having Claude teach you what you need to know. How do I uppercase this string? What's the best way to tackle this problem? Is there a standard way to do this thing? Then you learn along the way. You don't have to use it as a search engine, just ask it what you need to know in the moment. It will shake it's token chains and give you something that's useful, especially for a beginner in the language. This way you can implement your plan of growing your skills and then starting to delegate to it later.

I've been doing this, and it's a nice balance for me. Having Claude code things when you don't know how to evaluate it's code seems like madness to me, but I guess I'm in the minority on this.

> How do I uppercase this string? What's the best way to tackle this problem? Is there a standard way to do this thing?

I strongly believe that it's better to just take a couple week of slow times and read a good book about the technical matter you're dealing with. Having bite sized answers isn't a good way to be proficient.

No, and if you aren't going through mental effort, your brain isn't learning. It's just being briefly entertained by the information. You need practice and association building to actually build knowledge and skill.

"With coding, I've been using AI entirely for a year or two. I've been entirely prompting and I haven't written a single line of code."

I just can't understand this as a programmer. I use AI a lot as well when I program but I still write a lot of the code by myself just because it is easier to write the code I want, specially if I know what I want, than to make AI understand what kind of implementation I'm thinking of.

Same here, but i think i understand: if you can code for shit, AI makes you feel on par with people that can actually write code. Like, for some it is easier to explain what they want then writing it out as code. For me, it is not.

For my current project I'm coding every day in Java, ruby, and JavaScript. I waste a lot of tokens doing what used to be simple google searches for language differences since I mix up things like the null-safe operator ruby vs jscript or what is the continue/break statement in ruby vs java. I think Claude is probably very disappointed in me that the most complicated thing I use it for is refactoring old Java loops to use more modern streams which can be unwritable for a human off the top of your head.

It doesn’t help that Google has gone to shit though, and what used to be a simple Google search is now an enshittified embedded experience with an AI anyway.

No one's forcing you to use Google. I've found Kagi to be pretty good

> which can be unwritable for a human

Unfortunate, those types of refactorings are my favorite, since they're tightly scoped, easy to verify correctness, and it's like a little puzzle. Bonus points if you write your own collector or use some more obscure parts of the stdlib.

I feel that few will have the privilege to have the time to write code by hand. And let's actually see what we are actually writing, most of the time for me its nothing novel, nothing fancy its the same old create a backend for X, fix some simple bug and stuff that are trivial for a mid-senior programmer. The harder tasks are mostly (again for us) architectural decision over the code and I am even thinking of how we can develop a system where LLM wouldn't derail on feature implementations. Anyway, what I am trying to say is that you writing code by hand may be okay for now but in the future I believe the shareholders and whoever is on top of you will want you to deliver features/fixing bugs FASTER with the help of LLMs and if you can't deliver that you will under perform. So in the end it's not what we want but what the shareholder wants. Of course if you aren't drained by this you can write code by hand in your free time. I don't want to sounds like a doomer but I believe this will be very much a reality sometime soon.

Everyone has the time to write code by hand, because AI doesn't yield real productivity gains.

It was a never a velocity problem though, rapid progress comes mainly from designing better systems and building tight abstractions not by writing using the same primitives faster

That certainly used to be the case.

Do you think that in 2026 maybe rapid progress can also come from using the same primitives faster?

I'm still figuring this out but I'm certainly open to the possibility.

Managing cognitive load was cool before managing context window has become the thing.

Same techniques for both - the right abstractions, the right app architecture choices and layering.

I can't agree more strongly. I've seen folks flail at very high velocity, I've even done it myself. It's a thinking profession, not a typing one. Making the right choices at the right time can save you months or years (or cost you that).

The people that don't value good design will absolutely have a lot more rope from which to hang themselves.

I'm worse at producing code by hand, but feel smarter overall.

I've learned an insane amount in a very short period of time, and have been engaging in much more challenging problems.

Instead of "what's the right syntax for this for loop again?" I'm asking "what's the business critical module in this system and how do I structure the test suite to prove it's working to spec?"

Well, James, forgive me for being so inquisitive; but during the past few weeks, I’ve wondered whether you might be having some second thoughts about the mission.

Nice. HAL, from "A Space Odyssey", right?

From this, can we infer you're not exactly "all in" on coding via LLM Walter?

I, for one, am not. I've gone on the record with my thoughts in prior LLM related comment threads. They will make us dumb.

This sort of thing has cropped up before, and it has always been due to human error.

Hmm, Thanks HAL. :-)

The main thing that was dumbing me down (and burning me out) was having to babysit LLMs on anything except basic tasks if I care about code quality/structure/maintainability.

I love coding, it always felt like Legos for adults. Not that Legos aren't also Legos for adults.

But there's no fighting the fact that we won't be writing 99% of the code anymore so I take pleasure in crafting the specs and requirements clearly, that's where I put the effort.

And then to avoid having to babysit the agents to get them to stick to the plan, I built a super robust external orchestrator that forces multiple review and fix rounds until I get the result I want.

I'll be fully open sourcing that soon also https://engine.build

Computers read my code, so I don't mind upsetting their feelings.

But why would anyone use AI to write documents or articles? Do you really respect your recipients so little that you can't be bothered to share your own thoughts?

I might as well get an AI to call my own mother on mother's day.

I think the specific case of having a long conversation with an agent about what you're trying to achieve and why, and then have it update a README or a skill based on that conversation is a useful thing to do. Captured the context of the conversation without having to essentially write the same thing again.

> Do you really respect your recipients so little that you can't be bothered to share your own thoughts?

> I might as well get an AI to call my own mother on mother's day.

One of the first copilot adverts I saw had a woman using it to write a speech for her daughters graduation, with speaker prompts instructing the woman to look at her daughter at one point in the speech.

Such a personal and important moment in both their lives, I was shocked that they even put it out and thought it was OK.

What next? "Too busy negotiating a critical business deal to attend the birth of your first child? Have copilot attend and email you a summary of it later."

Found the video: https://youtu.be/ebls5x-gb0s?t=224

Hi, I do this at work.

It's not a one-shot prompt. I'm chatting with the agent for a while collecting knowledge and forming a substantive set of documentation or references. This takes a lot of time and effort to collect.

After this, I just get the agent to refine a doc for humans to read. I'm not very good at writing for humans, and it takes me far too much time that I usually give up and move onto other more important things instead. So it benefits everyone that I have vetted a set of documents in my expertise domain and shared them, even if not written by me they contain my ideas.

I’m not using AI to eliminate thinking but to free me from the rote mundane code writing. AI is perfectly competent at writing code once a prototype is implemented.

I do write initial proof of concept crude prototypes (not commented, hardcoded variables, etc), and AI does the productionizing of them. It has really allowed me to command a team of agents instead of keeping track of a bunch of humans of varying work ethic, skill, and ability to maintain high code quality. And often AI is very good at maintaining patterns used in the code base or even keeping them to industry best practices.

When using AI you will no longer be writing so much in programming languages—English or whatever language you talk to the LLM will be the main language.

What even is rote, mundane code?

How much of this rote, mundane code do you honestly have in any given project?

I don't care to build a ledger or build an ETL system. I don't care to spend my time debugging IaC terraform systems. GPT allowed me to focus on the core functionality of my code instead of investing hours of my time on ancillary support systems that are well understood. Terraform is notoriously difficult even for the most skilled among us. It helped me manage and tune my Cloud Tasks queue for processing from the microservice scraping data into the main app.

The cool thing is that I was able to let an agent manage this while I did the human task of steering it to work. Some of this work is novel, yet much of this work includes well-understood software patterns, such as scatter-gather and so on.

I absolutely do not enjoy using JavaScript or TypeScript at all. So it was a huge relief when I was able to get AI to help with UI work on Next.js and React Native/Expo.

I've gotten it to help with a cross-cloud cross-region setup on Terraform with shared secrets on AWS and GCP with GHA workflows for sandbox, staging, and prod promotion deployments. And I have no background as a DevOps guy.

Again, it didn't propose the exact shape of my system design. But chatting with it really allowed me to form the shape. It really is a bicycle for your brain. It helped me look at the tradeoffs of different products (PubSub vs Cloud Tasks, or AWS equivalents).

If there's one thing I learned from engineering and confirmed by my years in software development. It's easy to make something that work, but it's way harder to put guaranties on it. That's why copy-paste from Stack Overflow was a real strategy.

"AI is perfectly competent at writing code once a prototype is implemented" ... perfectly? I mean, it's certainly far from perfect - this is where I spend most of my day, in fixing the imperfections of the code generating robot.

Granted I'm not polishing up a prototype, I'm maintaining, evolving and modernizing a non-trivial 8+ year old product.

It's not perfect, but to give you an example, I needed to create a proxy broker to manage proxies for scraping data. GPT built me a broker to manage my fleet/inventory of proxies and buy bandwidth or new proxies as needed as well as maintain the proxy ledger for proxy health, while I was able to work on the core product.

It helped me with developing a scoring system (for example, I gather slot data for restaurants to see how scarce they are) to rank restaurants (higher score being harder to book) to determine signals of busyness. It also helped me build a backlog system to make snapshots of every restaurant's slot availability on 3 different providers (OpenTable, Tock, Resy).

Maybe I misspoke, I’m not saying the code it wrote is perfect. But the code produced by GPT-5.5 frontier model is easily miles better than a junior developer. But it is very competent. Perfectly competent was maybe more hyperbole, but I still drive the point.

Most of the time is spent making plans and prototype outlines for the llm to work with. Otherwise the whole thing will be a horrible mess. You need elaborately crafted prompts, so you have to have proper understanding of the underlying framework and language otherwise the whole thing will be a horrible mess. I don't even know how could people handle multiple agents, when it usually finishes quite fast. And you can't even do anything between runs, because you are in a constant oh one more minute and it finishes state. And when it finishes you have to evaluate the output. So can't even do deep thinking during "work", because the pattern is similar to social media. Constant attention, almost instant gratification. So your attention span is again and again fucked, properly fucked.

And the problem is, that these plans are obliterated in a few hours and then you have to analyze and iterate on the output to weed out the idiocies.

And handling multiple agent outputs... so continous context switches. Well, good luck with that in the long term.

If you let agents run wild and build whatever, the output is almost surely will be a horrible mess. End of story.

I don't understand how one even uses "AI to write". Writing is the act of taking something that's been burning in my head for a time and emitting it for others. The LLM doesn't know what's in my head and therefore cannot write it...

I use LLMs all day long, but I don't understand why I would use it to write out my thoughts for me?

I'm not the world's best writer by any means, and rather self-critical in general, but even I don't have the compulsion to have an AI rework my thoughts for public consumption. Perhaps for a set of slides or a big README, but not for one-off ideas and communication. In fact, I quite resent when someone sends me some AI generated psuedo-thoughts that are clearly not their own and devoid of the real context.

I have a method of using voice transcription to brain dump my thoughts and ask AI to turn it into something organised and sensible.

Some people are stupid and think that they should be given accolades for all their abilities that are just locked away behind their stupidity. They keep telling us AI is the key to this. This is why I don't trust AI. It's being sold to me by rich idiots who can't understand why art is interesting.

When I work with Claude to plan a feature and then review Claude's implementation, I don't understand the feature as well those I developed without AI assistance. I don't recall details of the feature's behavior as well, even days later. I suspect that this is not surprising to anyone who has studied pedagogy. I've been working on applying some exercises during code review (including self-review of my own AI-assisted code) to improve comprehension and recall (https://bridgekeeper.io/). If this problem resonates with you, I would like to talk.

This looks pretty cool, but doesn't it reduce velocity? If CTOs want more code shipped faster, this might slow things down

Understand you 100% - thats why I force myself to study maths as a "hobby" at a remote university. Its completly useless these days since I will probably never reach a level where I am better than current frontier models - but it sharpens my own mind, just by doing it. I would compare this to the same principle which applies to physical training - its not essentially required these days anymore to be physical active, still its quite helpfull. It would be dumb to not use it - since it is usefull, but its also dumb to see yourself getting dumber and not doing something against it.

Me too! I got interested in category theory and how to express a logical model of "workflows" as a category. Then ai told me workflows are a monoid and not to bother.

I don't feel this way. I have just been tackling more and larger problems, I think? This week one of many things for example is switching a multi-master KV store for tracking views on individual objects to tiered hyperloglogs that periodically merge. I could do this without AI, but it would take me a week instead of a day.

I think, if you're not feeling challenged, you're probably just doing the same work but faster. You should try to tackle harder problems, too!

> I just caught myself about to copy and paste it into Claude to see what it thinks because I'm worried that it doesn't make sense or it reads funny or there's something missing

I unironically believe this is a very good habit. When it comes to writing, instead of starting with AI, finish a chapter by hand first then ask AI to review it strikes the best balance.

> I just caught myself about to copy and paste it into Claude to see what it thinks because I'm worried that it doesn't make sense or it reads funny or there's something missing. That's the self-doubt that it's feeding on and what I need to fight back.

This is where I'm at. I feel like I need AI to review everything.

You may be right in many cases.

But I think the author was commenting on how it felt like a compulsive urge stemming from fear and self-doubt.

It’s a good insight about their frame of mind, and I applaud them for resisting the urge.

You need to do things the hard way by yourself in order to learn.

Reflexively copy + pasting into chatgpt is a good way to become completely dependent on the tool and have your skills atrophy.

It reminds me of people who can hardly drive anywhere without GPS, even if they’ve been living in the same place for years.

Yeah, but in a professional setting, one's work is for someone else to review. We programmers have code review. Even very established authors have editors. I think it's wisdom instead of a weakness to admit your work needs reviews. Of course AI review is the cheaper and sloppier alternative to reviews from human experts, but for a blog post I think AI is the sweetspot.

"My works deserve to be reviewed before being posted to the public" is not a bad mentality. It's not imposter syndrome either. It's just consciousness.

In the context of coding agents, one thing I find surprisingly useful is this - rather than have the code-agent explain to me what it did and why, I have it quiz me Socratic-style: it presents a scenario or problem, and asks me why a certain idea would not work. It forces me put effort into thinking it through, and even if I answer wrong, it avoids giving away the answer and persists in drilling down with further questions, until I eventually arrive at the answer. This type of effortful thinking likely helps both learning and retention. I find the frontier LLMs very good at this type of quizzing. I made this Socratic Quiz as part of my suite of plugins for Claude-Code or Codex:

https://pchalasani.github.io/claude-code-tools/plugins-detai...

I am getting the exact opposite experience. But it is probably because I am in a domain where code/software is a tool, not the product.

I find myself learning exponentially faster and more. For example, I am working with spectroscopy hardware currently (raman, nmr) where I got Claude to write code that interfaces with equipment on a hardware level. Instead of me going through data sheets and writing out a bunch of wrapper code, Claude did it for me.

I am able to progress much faster by using Claude to discuss various techniques, implement them, and test it out. This loop would have probably taken me 5-10x more time previously.

And I am learning so much more about these machines/techniques/data than I would have if I had to expend the mental effort to write menial code just to see a result.

I have more than a decade of experience as a developer. I am glad that we are finally moving towards a world where we can utilize code as a tool rather than constantly trying to think how to make it into a product.

> I am glad that we are finally moving towards a world where we can utilize code as a tool rather than constantly trying to think how to make it into a product.

Maybe that's just you. Code as a tool rather than just a product has always existed.

It is impossible to be made less smart by not manually writing code. If it were possible, you would be stupider every time you go on vacation. Your brain's neuronal connections do not die from talking to a chat bot.

What's actually happened is you took a break from a highly technical skill. Every person on the planet will "forget" some part of that technical skill if they don't use it in a while. But the information is not gone, it's just been de-prioritized for other more pertinent information. The information comes back once you give yourself a refresher.

Before AI, it would be months between me writing a full program in one of several languages. I would forget simple things like how to start a function definition. But I did not really forget, because after a quick glance at an existing function, I remembered all the other possible syntax in the function definition. There's no need to panic, your brain is working normally.

> you would be stupider every time you go on vacation

Are you sure people aren't?

They usually come back smarter, actually.

There's a vast difference between the mental refreshment from a week or two relaxing vs. ceasing all thinking full-time.

> It is impossible to be made less smart by not manually writing code. If it were possible, you would be stupider every time you go on vacation. Your brain's neuronal connections do not die from talking to a chat bot.

What if everytime you went on vacation, 80% of your open work items were magically completed?

Why would you give yourself a refresher? Not you specifically, of course. This thought experiment is about what we would all do in the aggregate.

It is impossible to be made less muscular by not doing work out.

Oh wait, you were serious ? Haha.

Has anyone gone back to doing code katas, code craft like exercises by hand? They help keep me grounded.

Also I feel like it’s fine to let AI write your code. I felt very much like the OP did. A couple of things help keep my sanity. one is that as developers I think our job has evolved to knowing what decision an AI makes is good and which one is bad, this can be code or design – but there is nowhere a developer(or for that matter a knowledge worker) can hide from ai. In this world you will be forced to communicate with them. Partly because as a community we have decided(for better or worst) that AI should bring non trivial amounts of productivity gains to software development.

The other one is something I want to validate which is for those of us who are mediocre at coding, it might be a gift because it would free up some time and thus mind space to consider what we are actually good at.

I use coding agents and LLMs at work where I'm more or less to some degree required to. At home, I write code the old fashioned way. Not katas, etc., necessarily, but I've decided that if we live in a world where code is cheap (or cheaply generated) that I'll hone my Lisp skills. I haven't used a Lisp in a few years and it's brought a lot of the joy of programming back for me, at least at home.

You haven't written a line of code in 2 years and you're confused why its making you feel like you can't code?

To me it really depends on how I'm using it. Sometimes it makes me feel smart, I'm solving problems I wouldn't have been able to solve before, and I'm learning a lot. And sometimes it feels like I've outsourced my thinking and I can just feel myself getting dumber and losing control over the project.

I think it's vital that you keep strict control, and really try to understand what the AI is doing. And especially when you're doing something really complex, even Claude Opus can get lost or lose track of the context, and you need to be paying attention when that happens.

It converts ICs into project managers, by default. I've been wrestling with this issue for a year.

Yeah, I've felt like it has converted my job from "writing software" to "babysitting interns".

There are things that I think are very cool; there are lots of projects that I've sort of wanted to do for the last decade that I have pushed off because they're reasonably high effort and I don't want them that much, so being able to have a pretend intern write it for me has been great.

On the other hand, I do think that using Claude/Codex to do all the coding at work has become a little soul sucking. Now instead of being paid to do fun software work, a lot of my work still boils down to babysitting interns.

When I do get to work on projects that are interesting, it's still fun because I can justify writing TLA+, and using that as a guiding spec for my projects. The problem is that most work really isn't that interesting; a lot of it is glorified SQL queries, or CRUD, or "put thing into Kafka in one place, and take it out in another place". Those jobs can be tedious, but they aren't interesting, and now instead of even getting that, I yell at Codex to do it and I awkwardly sit and wait.

I didn't think I'd miss writing stupid CRUD apps, but here we are.

I'm convinced Claude Code and Codex are not the future. The cap seems to be a 3-500 line file so I just use ChatGPT and/or my own front end to APIs on OpenAI and others including local. Much beyond that it will not do what I want. Too many expert details to get right.

When it was just ChatGPT, I actually really enjoyed it. I still had to do a lot of the work, but I could use ChatGPT to explain arcane logs and help me diagnose errors. It didn't feel like babysitting interns, it felt more like "smarter google".

Codex and Claude have been a bit soul sucking. I feel like I'm doing less of the planning and the like. I acknowledge that most code that makes it into production doesn't have to be amazing, but I would still take some level of pride when I would figure out an interesting optimization, even for a simple CRUD app, and now I am somewhat deprived of that kind of stuff.

Thanks. This was useful. I've been considering the whole approach today and maybe there's a narrower way to use Codex that I haven't tried yet.

I try the compensate for skills atrophy with leetcodes and kata wars, but the plain reality is that real software engineering, the one requiring you to absorb and make a problem intimate is just not there.

The work rhythm has ballooned and as every co worker is now pushing work (generally mediocre but acceptable due to strong codebase fundamentals and them being good engineers) it is increasingly becoming a rat race of who delivers more. Companies don't even need to promote AI productivity because engineers being engineers will engineer the minimum effort required to deliver as much output that makes stakeholders happy.

I am less and less fond of this work.

I'm sure there will be people with different experiences, but I've never worked as much as I did in the last two years, but I'm too burned out. I genuinely feel I've regressed as an engineer and I see the same in my coworkers, some of them contributors to the highest impact OSSs you can think of.

Every day, I'm more and more leaning into changing industry.

I love code and programming and solving product problems. But the job has changed dramatically.

If the pay+comfort ratio wasn't that good I would've done that already.

It's hard to give up to 6/7k+ net per month in southern Mediterranean. I'm way better off financially than most US devs making even more, there's no comparison.

Perhaps my ego is preventing me from becoming too addicted to LLMs. It's not that I think the tools are incapable. Rather, LLMs are probably far more capable than me in nearly every programming metric that matters.

However, if I were to release a solution that I 'vibe-coded' into the wild, then I would feel quite a bit of shame if someone figured out that I used an LLM to write the entire thing. I know it may come off as a bit silly, but it is a feeling I cannot seem to shake. A feeling that prevents me from wanting to adopting the technology in full force because... Well, I did not truly create the software if AI did all the work. Sure, the software might have been my idea, but that does not bring me much fulfillment.

I know programming is just a means to an end, but I feel like I have put in a lot of hard work over the past decade and a half just to barely scratch the surface of mediocrity. I was attracted to this field because I saw a sense of beauty in computer science (and programming). It felt like one of the few remaining options for a creative job that was spared from the cutthroat nature of the a career in the arts.

Like the Samurai class during the early industrialization of Japan, maybe it's time for me to lay down my sword too.

I'm a data analyst and a bit of a data engineer,which comes with the territory. I maintain some unholy pipelines that I wrote a few years back and they were due for refactoring for a long time. I do the AI-fueled refactoring in the most basic way - paste the code, ask for suggestions, implement the ones that are sensible, ask for clarifications whenever something's new to me. The last part is absolute gold. I've learned so much with the help of AI that I think the more I use it the less I need it, rinse and repeat.

I'm at the other spectrum of what the author feels. I feel smarter and more capable with AI, and I'm actually surprised how helpful it is in my workflow. I still write code by hand but I know way more than I would without it.

Granted, I'm the "accidental programmer in a team that's completely non technical" and AI is simply a senior I'd never have otherwise. YMMV but I think if you use the tool as a more expressive Google search it can be a great companion.

Pure vibe coding is not far from "let's outsource everything", it's just a bit cheaper and more available.

> YMMV but I think if you use the tool as a more expressive Google search it can be a great companion.

I get the most mileage out of this as well. It's the middle ground option. Everyone's either saying AI is useless, or saying how it's so good that writing code is an obsolete task already. Personally, I'm learning a ton with AI as a research tool, and implementing my code by hand with that knowledge. It also naturally solves the "you can't review 20,000 lines of code a day to even properly understand that it's correct" problem as a side effect too. But I am still building things much faster.

I've reserved a time span next month to learn TypeScript. I don't intend to rule out AI entirely during that process. My plan is to read a book from cover to cover, and then write code. I am pretty sure I heard of this method from Mitchell Hashimoto on some podcast. I am exited and scared at the same time, because like OP I've spent a lot of time prompt-coding.

I believe your words should be your own. I refuse to let ai strip my words of their idiosyncrasy. I refuse to put my words into a machine that robs them of their humanity. They are mine, they are me. Working with a human editor is an act of love and creation. Working with an AI editor is an act of mediocrity and sacrificed originality.

The day AI platforms suffer a massive and prolonged outage, it’ll trigger absolute panic and chaos. In many ways we are sacrificing a part of our creativity and independent thinking, but the reality is there’s hardly any alternative now. In a world moving this fast, choosing not to adapt often means getting left behind.

Nah. "the internet" or "the power grid" sure, but "AI" being down for an extended period of time would mostly just cause the stock market to shit the bed and trickle down effects from that, but not any actual loss in productivity. We did a lot of things 3 years ago believe it or not, and we'd just go back to working like that after some adjustments. (To be fair, I literally have "Don't Panic" inked on my arm, so I may just be inclined not to panic...)

I work for one of the largest companies on the planet doing work with a budget in the millions (meaning I am a nobody, but also not "nobody") and I don't touch AI personally. There is a group of very rich people who want to get much richer and see humanity as the thing hindering that dream who keep telling us that "if we don't train their new pet how to replace us, we'll be replaced" but I'm going to go ahead and say that AI is a thing, and probably relevant, but like in the way crypto is, not in the way the internet is. Does that make sense?

It's a scam for oligarchs. I'm saying AI is a scam for oligarchs and has very limited use cases and we're already starting to bump up against edges. Also a lot of people REALLY hate it, and that headwind didn't exist for things like "the internet" (you just had a large percentage of the population who initially didn't care, this is active animosity).

You could say something similar about the internet really, and the worst we get is some AWS or Cloudflare outage, no? People joke about various services being down but it's nothing too ridiculous, and unlikely to impact every provider simultaneously.

Please stop pushing the "getting left behind" fear. Prompting is not a skill, there is nowhere it's going that it can leave anyone behind. The "skill" of prompting is 100% dependent on one's skill programming, and in a day the skilled programmer will be able to surpass the guy that's been vibecoding for a decade.

I've seen a lot of people hop into prompting with no trouble, and people who have been using it for years that get bad results. Ultimately, prompting skill is just downstream of technical communication skill. It's probably a good way to practice, if you pay close attention to what you forgot to specify, and what the model got wrong.

Programming is the ultimate exercise in technical communication, even if we remove the aspect of communicating about the software to other programmers or non-programmers. It's not just communicating to the machine. The architecture, organization, whitespace, naming, it's all about technical communication.

I have been telling people lately that I feel like I'm losing my mind. And I'm not even someone who has leaned into AI coding that much either; I've just tried to learn the tools since Claude got "good". But my inherent laziness, which was always flattered as something that makes me a good programmer, has made me unable to use the tools with the required discipline. The result is that I have not thought deeply about the software I write for around 3 months. Every additional week that goes by without me doing a refactor or serious feature addition saps my confidence. I know I can still code. But I feel worried that I can't. Today I am refactoring a 4k LOC AI-written rust codebase. I don't know rust, but I will finally learn it today. And I can already tell the end result will be 50% the size and immeasurably more coherent.

The lack of refactoring when using AI tools is definitely a concern. I've only ever seen lines of code go up.

Since I've never touched AI except for google search results I feel like I'm in a sci-fi show like Pluribus

Those sessions which stayed together had something in common: singularity of concern. 1 session = 1 feature, 1 bug, 1 migration. As soon as you have a session covering several subsystems, the diff becomes too large to read properly, and proper reading is the only thing keeping the mental model up-to-date.

Also useful: writing the constraint before the session, not after the failure. "The auth state should be checked on the route level rather than the component" becomes quite clear once you see an agent applying the same rule in three slightly different ways in two files. Writing down the constraint beforehand allows you to detect the violation; rubber-stamping achieves nothing.

What really multiplies in value is not prompting but understanding your own system enough to prompt the agent properly.

> before computer science was a profession, it was physicists and mathematicians and academics who programmed. Professionals. The professionalism has faded away as demand for software developers skyrocketed.

This is revisionist nonsense.

Programmers used to be cowboys, by and large, outside a handful of critical domains. Systematic use of code review, automated tests, source control and so on are relatively new.

What was different is an entire program could fit in one person's head. The stack of abstractions wasn't nearly as deep, necessarily, since you couldn't afford the cost in memory and CPU.

That delivered a different kind of intellectual control, a kind that is exceedingly rare nowadays outside hobby projects.

When it comes to writing I only use AI for writing technical documentation or basic page copy, never for anything that is purely writing or for communication like a blog post, or a paper, or an email, or a letter, or a book, or even marketing copy.

Basically only use it for anything I wouldn’t otherwise have the time to write but isn’t important to be written by me.

I actually can’t fathom using it for writing as a principle, to me it’s just a keyboard extension for code generation, never a replacement for the written word that should be in my voice and fully a stream coming from my mind that I should have full editorial awareness and memory of.

Now that I think about it I’m a snob in this regard, I turn my nose up at people that use AI to write things that are purely written, in my mind using it for writing is defeating the purpose of writing!

You are doing this to yourself.

I have a nice balance of using AI at work as a C#/TS developer which allows me to get stuff done and working on personal projects at home using AI purely for ideas when I'm stuck or not able to figure something out myself.

I personally think it can be a great tool for learning but it's so easy to fall into the trap of getting AI to do everything for you.

I've also used it for personal projects like a Chip8 emulator I wrote in C where I'd managed to run a few basic games and ran out of steam. Used AI to help me implement the rest.

I find that a good way to battle this is to realize its not either the dev or the AI that should be coding at a given time. People needs to transform their workflow so the codes alongside themselves.

I am try to be coding at all times on complex issues while I am offloading a boring, non architecture, boiler plate heavye etc. task to it in the background in a git worktree.

I ask it to work in small iterations and commit every step of the way. After my coding session is done I can go back and review it's code.

I think you're right and that's probably my mistake. I should be using it as a companion rather than an independent agent. I think enhanced auto complete or function level work is probably appropriate. However what I've been doing is having it build a full application from scratch, to the point where it's impossible to review.

I agree 100% with this article.

You need to spend time on coding without agents and writing without AI as practice if nothing else.

You should not get complacent in offloading all detail oriented work to agents.

It doesn’t have to be this way. You can use AI in ways that don’t rot your brain. You can delegate easy tasks to the AI to save time, while saving the harder tasks for yourself. Or you can treat it more as a mentor / tutor and have it explain why it made certain decisions.

I find that AI fails at things that are truly creative. I have been thoroughly unimpressed with ideas it has had or things it’s written for me. There’s still a lot of room for human creativity.

> You can delegate easy tasks to the AI to save time, while saving the harder tasks for yourself.

This sounds a lot like "You can skip the fundamentals of basketball and just focus on dunking!"

Well, the "easy" tasks people are delegating are still leading to atrophy. Stuff like having it take over your writing. Now you feel you cannot write without this crutch. I've seen stuff pitched like AI that makes your slide decks for you. That to me is dangerous because creating the slide deck in a coherent way is imo a very valuable way to understand your project and keep on track with the story you are trying to tell about the work. I think a lot of what we think is easy or even boring has a lot of value in building up our understanding.

It baffles me a bit that people are working so hard to replace themselves with AI. It's such a high bar for the AI to hit, and takes the creativity away from the human.

I have a pet theory that perhaps the optimal way to use AI will be more like an "exoskeleton" that turns you into a super-human programmer. Something that plugs the deficiencies of the human programmer, rather than replacing you entirely.

I wouldn't keep the "hardest" tasks. I'd keep the important ones. It's often the same, but there are differences. And I'd argue that the important ones are the ones that you most want to retain the ability to do yourself anyhow.

Relatable! Or at least making me feel dumb (at times). Things that help me feel smarter are

* actually writing more on my own - created a personal blog just to get myself to write more

* upleveling my thinking - think more about problems and framing

* leverage my experience - guide (or sometimes force) the AI assistant to leverage my experience to avoid problems

* learning new things - rather than let AI just replace things I can do, I use AI to help me learn new things/technology faster than I would have pre-AI

> learning new things

I wonder lately, doesn't that all new knowledge push out the old knowledge? As in new things replace old things we know. I don't know any studies on this but do we have infinite capacity for knowledge?

What about retaining it? I catch myself asking AI wondering about random things that pop into my head, reading it, maybe using that knowledge once and later no longer remembering what it was. Maybe if you use that knowledge in practice from the get go but projects get so complicated sometimes it seems like there is not enough space in my brain for things AI is learning me.

New knowledge doesn't necessarily push out old knowledge, and we probably don't have infinite capacity for knowledge. That being said, at least in my experience, the time when new pushes out old is when old is less useful than new.

Retaining (again just speaking for myself) requires actually using / applying the knowledge at some point within some timeframe of learning it. Otherwise yeah it fades to the point of disappearing over time.

Knowledge memory doesn't really work that way, it is more like that it is constantly fading unless re-imprinted by use and learning new things is just imprinting new knowledge on top. The new knowledge will form connections with the old knowledge which will help keep some of it from fading, but not all.

Another way of looking at what you said is that the practicing the new knowledge takes the place of practicing the old knowledge. So it isn't the knowledge that is replaced, but the learning (imprinting).

A counterpoint:

Working in /plan mode bouncing ideas back and forth with the AI, me catching its wrong assumptions, it filling in knowledge gaps with a clear explanation when needed, is very intellectually stimulating and I think is making me a better engineer. The key for me has been to be socratic with the AI, think through everything it is proposing carefully, and don't get hypnotized by its confidence, perfectly structured arguments, etc.

I only really use GH CoPilot and while it’s really damn good at predicting what I’ll do next, I find it really makes me lazier. It’s like using GPS - it’s much faster, easier, accurate, and reliable than not using it, but I have found I don’t remember routes like I used to, as if that part of my brain just stopped working. If we don’t use a skill, our brains seem to want to almost immediately reclaim those resources for something else.

We'll just move to a higher level of abstraction; thinking will be like efficiently coding in assembly, no longer necessary in today's world.

I've been thinking a lot about the new primitives and paradigms we'll see.

Care to share some of these thoughts?

1. we will be thinking at the level of systems like services and DB's and forget about inconsequential things like methods, classes, variables

2. we will think of verification loop more - tasks will be chosen that have more ability to be easily verified

3. the concept of the difference between "generation" and "verification" will be more mainstream [1]

4. spec driven development will become more common

5. scenario testing will become mainstream

i have few more predictions like these.

[1] I wrote a blog post on this explaining why I keep this generation vs verification difference in many parts of life https://simianwords.bearblog.dev/the-generation-vs-verificat...

> 2. we will think of verification loop more - tasks will be chosen that have more ability to be easily verified

> 4. spec driven development will become more common

I do believe both of these, recently someone created an rar open source alternative for all its version using LLM agents because of that specs and in some sense verification/easy debug (or compile time) aspect.

On the other hand, I was making a GUI application (a rough scratchpad app) in Odin and there were so many bugs that I had to explain it and even then it was like lottery or just about unpredictable would be the better word as it would fix one thing and break another or just not fix it.

At the end of the day for GUI apps, it just doesn't have any way of testing them that greatly perhaps. There are many GUI things which I feel like LLM's are still underwhelming in, especially if you wish to create a GUI in say any niche language.

It can do that but the workflow is so bad that it might just not be worth it. i do wonder if GUI development becomes the one thing that AI can't do and their software development jobs are safe.

I was just scrolling upwork randomly and I saw tons of flutter & wordpress jobs.

I've had pretty good luck with using playwright mcp to test web front ends. I think LLMs can totally test GUIs. Either via vision and computer control or via reading the GUI node tree (e.g. DOM) used by whatever you built the GUI with.

A higher level of abstraction that doesn't require thinking? Did you mean to write thinking here?

Reads like great satire to me.

Welcome to Costco. I love you.

Higher levels of abstraction require more complex levels of thinking. Why do you think it won't?

The entire point of abstraction layers is that they require less thinking most of the time (and, usually as a tradeoff, more thinking a minority of the time).

The point of abstractions are to do more work because the lower levels are done kinda in the background with less energy

Like GC langauges help me do more productive work by hiding useless info about memory

I'm not sure I agree with this at all.

I don't think I think less when writing Clojure or Rust than I would writing raw assembly code, I just broaden the scope of my projects to fill up my thinking capacity.

Putting info into a spreadsheet is a higher level of abstraction that doesn't require thinking. There are many concrete representations like that. LLMs don't use them much. This is a lack.

Can you point a LLM at a body of code, and tell it "give me a concise UML chart of what this does"? I'm not advocating humans writing UML, but some representation like that may be useful to AIs. Except that they don't really do graphs very well. We may need a specification language intended to be read and written by AIs, readable by humans but seldom written by them. Going directly from natural language specifications to code causes the LLM blithering problem to generate too much code.

I’m not sure you and the parent are talking about the same thing.

I think they were making a joke about us getting dumber that I am confused about the premise of.

You seem to be suggesting we are going to fill spreadsheets (which claude already does pretty well) and that spatial reasoning is an insurmountable problem instead of just something that doesn’t emerge naturally from training on text/code corpi.

People say this constantly, but it's a qualitatively different jump from all previous abstraction layers. Previously, the part of your brain you had to use, and the way you had to think, changed from old layer X to new layer Y, but they were still very similar qualitatively. A person who was good at and enjoyed layer X either naturally was good at and enjoyed layer Y, or they could achieve both of those things after a little time. But with LLMs, the jump is much more lateral.

To do the thing I hate and use an analogy: It's not like asking a furniture maker to start using power tools; it's like asking a furniture maker to start telling a robot to make the furniture, in English. Yes, the people who were already good at furniture-making will have an advantage in how to direct the robot - but the salient point is that it's a recipe for misery for many people.

Hmm. I use AI to write almost all my code, and I feel that the "part of the brain" I use is mostly the same. Pre-AI I spent a lot of time thinking about code architecture, schemas, APIs, etc. Post-AI I spend a lot of time thinking about essentially the exact same thing. Yea, there are some things that I used to think about that I don't now - the fiddly bits, like why my parentheses weren't balanced or what field I was missing that was causing a 3rd-party API to fail. But the work feels more similar than different.

You should've turned the sarcasm detector on.

Ha ha ha... actually in the last 20-30 years most people learnt programming in assembly no for the sake of building programs in assembly - it was tought so you can have a grasp of microprocessor architecture. Instructions, interrupts,registers and all that. It means being fully aware of your environment. Without this knowledge of our environment, not only in our jobs, but also generally in life, what are we? Not more than wild animals surviving on instincts and an occasional burst of conciousness. Well, no thanks - I don't want to be an Eloi.

> ...like efficiently coding in assembly, no longer necessary in today's world.

Assembly is a stretch (albeit a few applications still need it), but otherwise that sentiment (and people who actually believe it) speaks a lot to me about what makes today's PCs slower, more latent, and less enjoyable to use than the machines of the past. Today's world sucks.

"That's the self-doubt that it's feeding on and what I need to fight back."

Yes -- now let's talk about the correct form of fighting back.

It is not "I don't want to feel self-doubt so I will suppress that feeling."

It is, "The self-doubt is valuable -- it's pushing me to improve."

The AI is never going to be able to say what you really mean. But it may inspire you to push harder to improve your ability to do that.

I reckon you're right. The self-doubt is a signal and I can use it a tool.

Is it tho? I get paid more these days to write less code. Is it dumb to be paid more/do more, have more oversight and deal less with the minutia?

Im still concerned enough about the specifics to show concern about background refresh tokens silently failing in OAuth in a mission critical real-time system.

Im not coding it, but im still thinking it. That's the important part, ain't it? Is it dumb or just clever delegation?

Me personally if I had the money to get out of dev I would just not fun anymore if you HAVE to use AI to code instead of doing it yourself. That's the name of the game, velocity.

I like making things myself, I have self-navigating robotics projects I do on my own time, but I'm not gonna use an AI to do it for me, the joy I get is figuring it out myself.

I will use AI if I'm stuck on something or need a specific algo written that I've spent enough time on and couldn't figure out.

I just query about whether were talking about "dumb" or "fun". Agree with the latter but question the former.

No, not really. You know what to think about because you were trained to by coding through the problem by hand. If you stop doing that, you stop learning the specifics of whatever problem domain you work with.

Sure, that's why we probably shouldn't start with vibe coding. Or otherwise at least learn formal methods to test against assumptions and doubly triply check vibe coded output.

Your thinking is based on your experience with code that’s why you do the thinking and not your customers and managers.

You lose some ideas of thinking if AI does all the coding unless you study that code. But that’s still different to creating the code yourself.

Same with authors or songwriters. Their brain is used to create stories and songs that‘s why it’s easier for them to come up with ideas.

If you are just a reader or listener your brain doesn’t get wired in the same way.

AI is a lesser problem for already experienced developers, because they just lose some abilities but new developers will never get those abilities in the first place, which will limit their thinking especially for edge cases that need creativity

> Is it tho? I get paid more these days to write less code. Is it dumb to be paid more/do more, have more oversight and deal less with the minutia?

I do think that what people are being paid might get adjusted to whatever is happening.

Firstly off-shores, then now Tech companies have convenient response to lay off people and they genuinely believe that companies can be 5-10x shorter with AI and 90% of code will be written by AI.

They then push it on engineers and some adopt, some don't. It becomes a goodhart's law and people just start spending tokens to look good too and just spearhead using AI because hey 1) the corporate is recommending you to do this and then 2) the points you talked about.

The AI bill blows up (Cloudflare spends 5 million $ per month probably more in AI bills iirc) and with all of these, the company fires people off.

The amount of software engineers laid off all then try to create another AI tool (...using AI) or try to overcompete when the job market is at one of its all time low. Combine this with the overall trillion dollar and more of US stock market which is attached to the AI bubble.

I do think that you are paying a price in all of this, I feel like job insecurity is at an all time high, people are just scared of losing jobs from my understanding within this career. Some are closer to retirement than others but that's about it.

I think that nobody is that happy to be honest, the software engineer is worried about his job, the CEO is worried about being replaced or his product replaced by AI, the AI company is worried about how it would be profitable in first place, the investors are worried if they got into a bubble, the government is worried about all these people and other so distractions (think UFO files for example) and wars are happening and its successfully diverting our attention from real issues.

I don't know but I think that we are all paying a price and I say this as I sometimes feel the most over-empowered by AI, (like young guy in his teens) but I just feel like we lost something more critical along the way. We lost some senses of our humanity and peace as we are embedding this technology and just have people who are only thinking about it 24/7. I have to be honest but I do sometimes feel like I would've fared off okay without the AI thing too and I don't care about my personal gains so much sometimes but I do think that the world would've probably been net positive if AI's plateaued or were never created.

I think it's all about the perspective on AI as well, cause in my case, whenever I use AI, I tend to look for more ways of improving what was delivered by AI. Most of the time I just write a draft of the context of what I want to see then feed it to AI and check whether it didn't sound right and tbh,

That approach is making me either lazy/efficient cause I use it to my work

it’s crazy, we’re at a point where I commit code I haven’t seen, reviewed by another AI, followed up to by another AI and it’s just kind of scary.

This thing will explode in our faces sooner or later. Also makes me feel like an imposter rather than an engineer.

Maybe that’s actually what I have become.

This is such an american who reads the atlantic without scuritny and gets manpiulated vibe

Most people who say this didn't/can't happen to them, are the worst cases...

> With coding, I've been using AI entirely for a year or two. I've been entirely prompting and I haven't written a single line of code. I have mostly forgotten how to code

I've been using AI coding tools a lot lately, though I'm always in the loop. I write most of the important code by hand, but I like to send Claude Code or Codex off to try to come up with a solution in parallel to compare.

Having reviewed so much of my hand-written code side by side with AI-written alternatives, I am still amazed that anyone admits to letting AI write all of their code. Either you're working on much simpler problems than I am, or you don't really care about anything other than making the tests go green and waiting for bug reports to come back so you can feed them back into the LLM again.

Some times the coding tools come back with better ideas than I came up with. Some times my idea is much better. Most often with medium to high complexity problems, if the AI comes up with a working solution it has enough problems that an attentive human reviewer would have rejected it at best. At worst, it creates a mess of spaghetti code with maintenance time bombs ticking away. And that's for one change. I can't imagine what a codebase would look like if you completely deferred to AI tools to do everything.

This quote is even weirder because they claim to have been doing this for two years! Two years ago, coding tools were much worse than they are today. Using AI to write all of your code 2 years ago would have been a weird choice.

When I read posts like this I don't know what to think. Is this real? Or is it exaggerated for effect?

I also roll my eyes a little bit at the idea that not writing code for 1-2 years means you forget how to code. I've been back and forth between 100% management and 100% IC in my career. While there is a warm-up time to get back into coding, you should not completely forget how to code after such a short time. The only reason this person feels like they've forgotten how to code is that they've made a choice not to code for 2 years and, apparently, they don't feel like making any effort to change this. For someone who claims to love writing code, I don't get it. Something doesn't make sense about this writing.

When I wrote this I overlooked the fact that I was in management for years before, which is possibly the actual real reason I forgot how to code. I've probably also been avoiding coding by hand. That was a choice. When I went back into IC, I probably didn't feel good enough for the seniority level that I was at and rather than working to improve myself, I used AI.

Thanks for your comments. I didn't realise until I read this.

I was talking to some friends about this over drinks the other day. I feel it has the same effects as any drug (or behavior) that triggers dopamine. If I can get a dopamine hit for lower effort AI in 10 minutes, and maybe a tiny bit better of a hit doing it myself after a day, why would my brain go for anything but AI? Especially when my DIY muscles are a bit atrophied.

And of course the hedonic treadmill (if that's even valid any more, IDK) has reset the baseline so that anything less than the quick gratification feels like nothing. It makes the stuff I used to absolutely love feel like more of a chore compared to just cranking out features with code only an AI can love.

I'm curious whenever I hear takes with your perspective.

Entering the workforce happens at an age where people have built (some more rudimentary than others) a level of understanding and self control regarding delayed gratification and Type II fun.

Did you have the kind of life where you were never really challenged to build that skillset, or is the mental stimulation so strong for you when you use AI that it overcomes executive function?

> Did you have the kind of life where you were never really challenged to build that skillset,

Do you really think phrasing a question like this will ever induce a productive response?

I guess I could have phrased it better, but at some point I'm asking about weak self control vs if the drug is that strong. The life experience thing was meant as laying down a facesaving reason that it's OK to say your willpower sucks. You just weren't forced to cultivate it. Plenty of reasons that can happen in life.

I think it's pretty normal to be able to reflect on the difference in life skills between myself and those I see in others. There are things I've struggled with throughout adulthood because through some happenstance I was able to avoid the class of challenge as a child.

I didn't learn how to study until my 20s. I didn't have will-power over eating and exercise until my body changed around 30 and I suddenly got fat, then I talked with friends that teased me for being less skilled at something than a teenage version of themselves.

What's the saying: someone who's never smoked doesn't have to learn how to quit smoking?

I understand what you're asking and why, but the phrasing reads very dismissively and that's what I was asking about. Generally a friendly tone will get you a lot further.

I have ADHD and have done quite a bit of reading and study on it, so I'm pretty familiar with how dopamine and dopamine disorders work. I've also been in the workforce as a software engineer long enough to have done some really hard things. So my life and career have both been plenty challenging lol.

And I'm not alone here. Like I said, I was discussing this with a bunch of friends who are also quite senior and accomplished in their engineering careers, and the sentiment was familiar for us all.

Ask AI how to make you smarter and use some discernment on if the suggestions would accomplish the goal or look up human-written articles on how to use AI to enhance intelligence

The GPS analogy in here is exactly right. I still know how to drive, but I genuinely cannot navigate my own city without it anymore. I didn't notice it happening.

I'm 15 and learned to code with AI from the start. I genuinely don't know if I know how to program or if I just know how to talk to something that does.

It's simple to find out. Add Claude /etc/hosts and see how long you persist.

Then you didn't learn to code. Maybe you learned to prompt at most.

I enjoy using and orchestrating agents a lot to build software, but have never really had the desire to replace my writing with LLMs. I don't write a whole whole lot, so maybe I just don't have enough writing to do to make it appealing, but my emails, blog posts, comments, whatever are the last thing I want to automate. Not only because it's less personal, but because I'm so tired of reading AI cruft myself. So much more text in tickets than there needs to be, for example.

And how are people forgetting to code by using LLMs? Do they just mean they forgot the syntax of a particular language? Or forgot how to architect features or how the development lifecycle works?

I've mostly used LLMs to build more complex things that would have been a lot to manage previously, or to build something completely new and learn how it works. I feel like I've only become a better engineer (and programmer too) because of LLMs.

Firstly I salute the author for saying these things. I mean we know the feeling of criticizing AI and certainly I criticize it a lot too, but when it comes to personal matters or how I am using AI, there are somethings I shy away from saying online and I wonder other people might feel the same way too.

So for example, once AI deleted my project, I was able to recover it but I lost version control through series of mistakes and IMO I lost a good version. (I think after abandoning that project and coming back, I was able to accomplish it)

Another example which is the one which is biting me the most is that I wanted to create a copy.sh/v86 based thing where you are able to edit the .img files of distros and save them all within the browser. I was able to run v86 custom way but I wasn't able to mount or have a proper way for making it work.

And now although I mean this is just an optional project and I just thought hey it would be fun to edit .img files in browser but now it feels like I get disappointed.

I think that disappointment is in both say a frustration of thing not working and secondly, just realizing that I might be dropping this idea altogether. Now I must admit that this is a field that I have absolutely no expertise at all in, but still, it feels disappointing to me and I kept thinking about it for sometime now.

I wonder how many people just feel that if AI is unable to make their project, to then either get frustrated/disappointed and even a salt of panic. I think its just wrong for how damn much we are relying on LLM's at this point. It feels like the whole economy is just doing what I am doing but with billions of dollars.

Another thing that I feel like is that both young and elderly people are really much like the same in vibe-coding. (Yes specs can help but LLM's are still autocorrect on steroids), I feel like we are both forsaking the junior developers and also forsaking the expertise created by senior developers as we replace it with these LLM's

I definitely double guess everything I do without it. The doubt creeps in fastest on the stuff I used to do without thinking.

I feel your pain.

Today I'm forcing myself to learn SwiftUI and type each character with my hands, there is a part of me asking "Why are you wasting your time instead of prompting it and getting the UI you want in minutes?". Well, even I use AI I must know the domain I'm operating in to create good products instead of useless slop. Even though I've been coding for 20 years now, I still need to be humble to grown in anything new. I can vibecode full apps but I'm not gonna pretend that my experience isn't playing a massive role in guiding the models.

Don't let AI take away your joy for building stuff, it's totally fine not being "productive" and taking your time. Just force yourself to have, at least, 2 AI days off every week.

I’m still the same smart person when using AI. What the author probably means is their memory of syntax is fading. Bothered?

Yesterday I needed to email my landlord about the roof and immediately used chatgpt. This is gonna be it for everything

AI use and low confidence are correlated with lower ownership and deferment of critical thinking skills.

Based on the MIT and MSFT studies.

Slightly different take here. I'm not coding less, I'm just coding the harness instead of the product. Most of my time goes into AGENTS.md, hooks, sub-agents, verification loops to keep the agent from going off. https://openai.com/index/harness-engineering/ describes pretty much what I do all day now.

you are suffering from point 4 as mentioned by the OP here https://personalaisafety.com/p/youre-not-getting-smarter-you...

"4. When the answer feels done, you stop thinking"

Chaos is what it is. Chaos often grants immediate power but corrupts and destroys the more it is used.

What a bizarre article. He laments the use of AI and then hopes that it might cause a flood of programmers.

Not a flood but a reduction.

It's literally changing your brain when you don't use it like you used to. So, yeah. It is.

AI is keeping me on my toes. Many people in my org are experiencing the Dunning-Kruger effect after being armed with AI and are making such new and spectacular messes that I've had no other choice but to ratchet up governance controls. Improving documentation didn't help. The few people who read it complain to me when it is contradicted by AI.

Reflecting on the comments, I did this to myself. I should have titled this "I used AI to make me dumb".

I've heard this before with the Internet

I feel lucky cause I started dumb. Unintentional level-up!

I would argue the last 20 years of app development is what made people dumb.

During the "don't make me think" era of software design, if you wanted to make software you got really good at identifying the use case and using design thinking to optimize the paths to goal. You could make a business around a very narrow set of flows. The only thinking a user had to do was pick The App for That. They never had to think about how they want to approach their task, which is a skill in itself.

AI isn't like that. There's a million ways to use it. That's a big part of what makes it cool, but it requires the user to thoughtfully approach their workflows. Not everyone is used to doing that.

Ai has been the best learning tool I have every used and it's not even close. I've learned more in the past year than I have in the past 5.

Yeah it really depends on how it is used

There are two kinds of learning: Reading and doing (and you need both). AI has been great for the reading half of learning, but has harmed the doing half of learning due to efficiency demands. We can still "do" in private, but no longer in our day-to-day.

How did you measure your learning?

using AI to red-team your thoughts and assumptions is the fastest way to get smart since the dawn of time

It is making me feel less dumb when I use it to get Linux admin things done because 1) it gets it wrong and I have to help it and 2) even though I would have gotten frustrated and given up without AI it shows me that Linux has gotten way out of hand for administration. Wheels have been reinvented and conventions have been changed for no good reason, or because of https://xkcd.com/927/

before I ask AI to write anything, I prepare a plan, I was very positively surprised when noticed Plan mode in Codex recently. It make me feel that maybe others doing the same and that's why they added it. Anyway, I start with plan, then ask AI to do just one step.

If coding a new feature, I do one step and check the code, doing git diff, reading changes, or just asking Codex, to show me changes.

If writing an article, I ask for only one paragraph. I read paragraph and if it is ok, I accept it, if it doesn't show off my thoughts I work on one paragraph.

If doing data analysis with AI, I do one step of analysis and ask AI to display intermediate results so I can see if all is going in good direction and there are no hallucinations, additionally I have follow-up prompts for AI to do results verification. If all looks good, then I continue to the next step.

I don't like situation when I ask AI to do all code changes, or all article, or all data analysis in one pass with one prompt. It is simply impossible to check if AI is correct and results are not satisfactory. You can easily see this when asking AI to write a deep article with one prompt - you clearly see that it doesn't reflect your thoughts.

Maybe step-by-step is the approach to use AI and not feel dumber.

> AI is making me dumb

We'll have AGI not because AI is getting smarter, but because we are getting dumber.

Missed opportunity to name article “AI make me dumb dumb”

Use AI to fix that cert

The cert is fine according to my browser.

Fair seems it was my vpn

As far as the topic on hand, I work with someone whenever you ask them a question they say "AI says..." I'm not a big fan of that.

If you have checked your AI would have said is not the cert

Possible?

AI would have to know I have a VPN active

We need to separate our emotions from these things. I understand why people don't like AI, or are fearful of it, but we need to have good faith arguments about it. Not this. These articles are just cope.

AI is not making anyone dumb. It lacks the volition and agency to do any such thing. People are making themselves dumb by choosing to, and how to, use AI.

Can a programmer who has no personal feelings of attachment to slop, make it all the way to production and maintained?

My company has 3 AI on every pull request now. They behave as follows:

1. a general coding AI: Completely broken. Should auto-comment, but never does anymore. Stopped a while back, nobody seems to know why.

2. another general AI: You have to at-chat it. It reacts to the message with <eyes emoji>, but never actually posts a comment?

3. a security bot. Comments, when it thinks there's a problem, in the most obtuse way possible. "SAST findings". But the findings are behind a link, and none of us devs are given access.

I could lean on and press the various people shoving AI down my gullet to like … look at this, and the actual lived experience of devs trying to derive productivity from this mess? But IDK what's in it for me, really.

Even Claude, when it worked, would comment in the most sociopathic manner possible: an English prose description of the problem, attached to an utterly unrelated line of code. Part of that is probably Github, who does let you attach comments to arbitrary lines of code in a review, only the blesséd lines can have comments. Literally none of our AI can format their complaint with a freaking suggested change (i.e., the Github feature, no, instead I get English prose).

Honestly for all I know we failed to pay the bill or something inane, but it would be nice if the AI could format an error message, or something.

I ran Qwen 14b distillation of Deepseek locally once and created a console app and recoiled in horror at how powerful those things are. The problem is that humans are not designed for default deny mental processing, and so I am not optimistic about long range effects since the hallucination aspect can never be eliminated. No one is going to check everything for errors. A single error in some spreadsheet formula or code somewhere can have catastrophic consequences for years compared to what could have been. I see the transition from expert systems to language models to be a travesty foisted upon mankind. Pushing efforts to drive such language model outputs into data wrangling and analysis is especially heinous because that affects humans' very lives and ability to thrive or survive, or even face criminal consequences.

Aggressively red-teaming your own work with LLMs is a good habit to get into. Prompts like “I’ve been told me to find the flaws in this argument/presentation/code file/etc.”. Doesn’t save any time, but is pretty educational, as long as you go back and forth a lot. It can fall into a style disagreement loop between two equivalent code blocks as it will try to find something wrong if instructed to do so, which is interesting.

If you don’t do this constantly, LLMS can certainly lead you right down the Dunning-Kruger path (though that’s a big oversimplification of a whole collection of psychological features from idee fixe to narcissism to fear of failure/criticism). If you really work at getting the LLM into the proper state it will happily rip your work apart in a rather cruel and indifferent manner, like an unsympathetic corporate gatekeeper who relishes exposing your flaws in a public setting. Debate club is another tactic that’s a bit less harsh, you have the LLM flip back and forth between defense and prosecution of your work.

I think this should be the default setting, but it doesn’t encourage engagement, the average customer will think the LLM is a mean jerk if it starts off like that.

also, chatting with AI makes me impatient and delusional.

It's just exposing the dumb

God damn this nail gun is making me lazy, its like I don't have to swing the hammer any more...

Most people, given a nail gun, cant build a house, thats where the skill is...

Im not someone whose validation came from the lines of code, but from the resulting working system.

Reply on news.ycombinator.com