From the very start of llms I’ve had nothing but bad experiences with code that was generated for me. Either it’s buggy, it works but I end up losing an evening on some obscure bug, or it’s full of red flags.

My latest hobby project is just in a text editor with markup and that’s it. I’m also done with the augmented assistance in the IDE. I google things I forgot. I constantly read these amazing stories of people vibe-coding some firmware/driver that just works, and honestly I’m starting to question whether I’m reading the posts of some promotional bot.

I've made a wealth of cute things for me and my kids to do (shameless self promotion) https://drawesome.art - multiple people drawing/painting/coloring on the same canvas my kids love this. The architecture took forever for me to get write. Basically server side authoritative state of pixels and blending between two points. How to realistically manage and store it. https://www.catchmemeow.com - random where's waldo-esque game where you find a cat or dog wearing a silly hat I made this for my daughter and me to help the shelter she wants to volunteer at. https://www.cluestep.com - this one is weird I've actually tried to productize it but i made this because I had the HARDEST time helping my oldest with her calculus/algebra II homework. Basically I constantly made her cry. I just wish I could make it not look so "Made with AI"

I think LLM's analogy are prefab with nailguns did for carpentry. It's very complicated to prompt it (at least for me) to try and make it do something novel and net new. It always falls back on node/typescript/fastAPI/python. It's not terrible at using more obscure languages but I have the hardest time describing what I want or thinking without starting something more by hand and then letting it take the wheel and seeing where it drives me.

I should mention too at work I'm practically forced, measured even on the amount of AI I use. The expectation feels like use AI for any and everything. So i'm more worried one day I'll be laid off once I'm found to hit the 'enter' key much anymore. Anyways for me I'd say embrace it, use it and you'll find your output is much higher with the caveat that when a bug occurs it's incredibly hard sometimes to fix if it's with LLM generated code.

I feel somewhat qualified to opine on how humans learn because I've successfully taught my 2x boys[1].

Teaching is difficult. It requires a lot of patience and understanding, and a working mental model of the human brain.

If you have tried, and failed, teaching calculus to your kid, then maybe you don't have a good model of how human brains work.

TBH, it doesn't even have to be correct, it just needs to work; celestial navigation had the wrong model for centuries, but ships still got to where they were going (mostly).

I'm finding that developers claiming to have learned something have often very superficially learned it. If they were tested on what they learned, they'd fail, just like the HS trig students who read the textbook and did no problems fail when they hit the exam.

--------------------------

[1] My youngest, at grade-1, reads at a grade 3 level and can do things like multiple 27 by 4 in his head. That is a result of a structured and scheduled 10m lesson per day since he was 3.5 My oldest was getting 5% in trig/geometry in grade 11 (long story behind that one), and became solidly mid-70% after my tuition.

My son doesn't get upset at all with me he'd just play his mom to get the help to the right answer and didn't have the 'want' to understand a problem he just wanted to move along.

I have another daughter who is autistic. I'm still trying everything I can possibly do to get her past reading at a 2nd grade level. That's another problem I'm trying/struggling to solve.

I wouldn’t call myself a rockstar but I did get a job after a summer internship which I mostly spent touring with the Grateful Dead. At the end of the summer I was in the office and the head of the research division said he hadn’t seen me much(!). I said I’d been thinking and had some ideas on how the group’s research plan was flawed and how to do it better. I then filled his whiteboard with off the cuff ideas.

I spent the next several years with a team implementing the whiteboard.

I like to think things work better these days, AI or no AI

[1] https://blog.nilesh.io/post/llms-and-jobs

The second thing is that using LLMs in a useful way is a skill in itself.

Not really. I don't even bother writing complete sentences as my prompts anymore. Once the LLM has enough context on my current issue, even incomplete sentences or phrases result in the same outcome quality in LLM's responses.

I have to disagree here. People who are really into agentic coding like to say/believe this, but come on, it's not rocket science! You literally ask the agent to do something and it does it, that's it. As long as you use a recent model it will do it really well regardless of how fancy your prompt is. There's no moat here, anyone can do it. Your job will be gone and so will mine.

After a (potentially long) session of investigation and planning _then_ you let it code. Even just being aware of this process is part of the skill involved (then you have to actually get used to doing it effectively).

You soon will. If not next year, then maybe the year after, or the year after that.

Whatever value you are providing will evaporate in a few years.

Are you planning on stopping eating in 3 years?

"No no no, when I said build twitter I meant without the character limit!"

but you will!! you absolutely will!

Exactly, you have to know what to ask, especially on large codebase. I still have to baby sit Astra and opus 5.5 into reusing existing structures/functions, not reinventing the wheels, telling them "yes this might be a legit race condition, but you added 5000 LOC and I'm pretty sure it will never ever be a problem in production given it would require 5 distinct catastrophic failures at once to trigger it, if it ever happens log it in sentry and we'll have a look by then".

Some people are really really bad and won't even think about asking stuff like "run a memory profile and see if we can decrease our footprint", "benchmark the top 3 options for this bug and keep the one that uses the less cpu but still respond under 150ms".

You still need to have a broad understanding of what a computer is and how it works, both are skills, which a lot of dev didn't have anyways, but now they can shit out a looooot more code

So I stand by my assertion that anyone can do this now, it's definitely not a hard to learn/master skill, and people who say it is are naively believing there is a moat around their career.

So people who choose to not use it are not losing out on building any skills- in fact if they are focusing on hand coding and learning and keeping their brain sharp they, in my opinion, will be in a much stronger place than the AI enthusiasts whose brains are rotting.

It's not that simple, you have to remember at the end of the day these things are just doing next token prediction. If you don't give it the proper tokens to attend to, then your outputs won't be satisfactory.

You can get stellar outputs from LLMs, but it really is a function of how well you manage your input tokens.

(the ironic thing is tho, people starting out with just llms will probably never progress to 'good dev' in the first place...)

I imagine there will be value in being able to understand every line of code for a while, because many (most?) things don't seem amenable to long term vibe coding. But how will that knowledge be obtained? Maybe there will be a much smaller pool of devs with the patience to actual learn bespoke software development.

Or, AI will actually get good enough that vibe coding is better in every case than mindful development. I guess the main factor is how long it takes for that to happen.

  > Just a bunch of people who treat the codebase as a black box, pump out slop, and call it a day when the feature works?

  > Or, AI will actually get good enough that vibe coding is better in every case than mindful development. I guess the main factor is how long it takes for that to happen.

Like you I would not vibe code something important, but I think that's primarily because I want to have a deep understanding of a system before I accept responsibility for it. An LLM would still be useful during implementation and likely to increase the quality of the result.

It seems very likely that AIs will become capable enough that they can take complete responsibility for development, deployment and maintenance of the systems we're used to building. Further, it seems likely they'll end up much more capable than humans have been. I think that's an eventuality we need to be prepared for.

A well-utilised AI tool can probably already build a much safer and more robust security/legal/user related system than you or I can, in any given time budget. There's a question around what happens as humans are required less for the "well utilised" part, and who is responsible when humans are not really involved anymore.

As someone who's used more and more software made this way—either for hobby stuff or because I've had to for work—I just don't get it. You don't always get exactly what you ask for, and you often ask for something that is really sub-optimal in many ways.

The problem with waterfall wasn't ever solely "it takes a long time to write the code."

The trouble with this argument is that fundamentally this whole field has no sound theoretical foundation. It has no deterministic rules you can learn that will reliably get good results.

That also means there is no way to prove that what works well today will continue to work well tomorrow. Nor can you be sure that something you've tried and ruled out in the past because it didn't get satisfactory results won't be the new SOP next week. Any experience you gain in the field might be obsolete within hours.

An important consequence of this is that you can't train someone else to use LLM-based tools effectively either. At best you can train them to use specific tools and models that exist today effectively and hope the knowledge remains useful for a significant period of time. Even that assumes you have the knowledge yourself and aren't relying on something that worked well yesterday but could already be out of date after something new was released last night.

This looks like a fundamental problem that can never be fully solved as long as LLMs of the type that are popular today are behind the tools. People forget in all the hype and rapid change that the whole idea of agentic AI tools in mainstream development is barely a year old. We have no idea yet what the long-term consequences of so many people and organisations in the industry all but abandoning traditional programming skills in favour of AI agents will be. There already seems to be a lot of anecdotal evidence about programming skills atrophying, developers burning out, and the quality of the finished product dropping but it's probably too soon to have serious data to analyse or to draw any big conclusions about what is a good way forward from here.

You don’t have to look too far to see where we are going. But you do need to have your eyes open.

As I said - we have no idea yet what the long-term consequences of the recent rapid shift towards AI and agents will be. I prefer to make decisions based on evidence, not hearsay or wishful thinking.

I have been around long enough to see a lot of hype cycles in programming. They were all going to be revolutionary. They were all going to change the nature of programming forever. They were all going to result in dramatic increases to productivity (or other similar claims).

Many of those phases did turn out to have some good - sometimes excellent - ideas. A lot of those have since been widely adopted in the industry. They also had plenty of ideas that didn't really work out. In the end we have improved some areas to a useful degree but none of those phases resulted in orders of magnitude increases in useful productivity or quality.

So far LLMs and agents are looking like a familiar story. They're proving to be useful tools for some types of work. They're now quite good at producing code to the standard of an average developer doing a well understood task - and in many cases that is all you need! But the jury is still out on whether they'll ever be able to replace good programmers or build genuinely innovative products where there aren't lots of examples of good existing implementations to train the models. Those are the parts of the industry where I do most of my own work and I hear much more scepticism about these tools from those developers than in the average online discussion.

No, it's not. As evidence of intelligence atrophy, I offer up this word salad that barely makes any sense as evidence: someone barely able to write a coherent thought can apparently produce working software.

When was the last time you built something meaningful with it? I admit, LLMs do help and save tons of time and effort, yet building noteworthy software still remains a difficult task, with or without LLMs.

Funny, but your comment reminded me of my wife. Circa 2009, she was walking behind my back, she stopped to watch me work without me noticing. I was using Visual Studio (sluggish, temperamental mammoth, not its smaller cousin). She stared at my screen for a few minutes and suddenly exclaimed: "You're not even working, this thing is telling you what to do. I could probably do this shit too..." By "this thing" she obviously meant the intellisense completion that was giving me hints whenever I typed.

Sure, the skill of writing beautiful for loops and recursive binary search tree is basically worthless, but software is written for a purpose. That purpose is not gone. People will keep wanting POS system, accounting system, lawyers, manufacture stuff, personal assistant, etc etc

> Your job will be gone and so will mine.

I mean, that's probably true, but the person you are replying to is talking about the present.

For linting style errors I’m using entr in a separate terminal which is also awesome.

  > You have a previous generation of cars where people just enjoy working on with hand tools, and there’s modern cars where people like to tune with software patches.

I think the analogy with cars is apt, but we should also like at what happened with cars. People are being locked out of fixing them, even for simple jobs that would usually be task that introduces someone to the hobby or career. Fixes like changing your oil or brakes. Remember that the Ford CEO said that cars are "too dangerous" to fix. Probably connected with the other thing they talk about... a $100 bn repair industry that they want a bigger piece of. There's an easy way to do that, John Deer and Apple have clearly shown that it's not hard, even when we get the right to repair. Is it any wonder far fewer people work on their cars these days? Ask the people with electric vehicles... there are people out there, just as there always will be, not the numbers do matter

Weirdly, I think LLMs would be much more useful if everything was open source. No need to hack your microwave to give it a firmware update to the door doesn't lock, just patch. More training for the LLMs and turns what would be a specialized task into one anyone can do if they point the LLM at the code. Plus, people submit patches to the source code, getting companies free work. There is a way everyone can win in this. Sometimes (often) being greedy prevents you from getting a bigger fill

No one uses assistance in the IDE for project like these. They're all using Claude Code (or similar harnesses) and lots of sub-agents. People who haven't seriously tried out SOTA models + their proprietary harnesses just don't know what they're missing out.

After several days, it managed to brick it and unbrick it. The boot loader is still locked.

There is a lot of bullshit out there for sure and I'm still not convinced llms are a net positive for society (even ignoring energy use and hardware inflation) but it's clear that it works in a lot of areas, for example when it comes to reverse engineering it pretty much is black magic, the progress made in ps5 and other consoles emulation is out of this world

The problem here is that search engines are trash now. The AI companies are going to have to start running their own (if they haven't already) for their models to use that haven't been nerfed. That might be the next moat against open/local LLMs by cloud LLMs, so the search engines are probably going to get even worse.

I don’t question those posts, but these days, I can code something with vi (nvi) and be ok with nothing other the small motion helpers. These days, whenever I see a project with more than a dozen files, my gut tells me there’s something in there that ought to be a library.

No, it just works after a few iterations.

And you'd know this if you would use AI instead of working in a text editor with markup.

To each their own, and I understand if working by hand is more fun for you.

But in my opinion you guys don't get to make strong claims about the quality of works that make heavy use of AI.

You don't have the experience, and I bet neither does the guy who wrote the article about it being essential to handwrite all the code after planning. The arguments about the environment and sustainability do not seem relevant.

I've thrown a 20 year old .net 4.8 codebase that's a mixture of proprietary sdks and legacy code and LLMs choke. Building some greenfield pieces for the same application works great so far though.

I've also made some plugins for some hobby software with very limited viewing of source code that I'm very happy with.

we have a 6 year old codebase with pretty much everything proprietary and there's no AI that can keep up without having an entire team to create an in-house RAG and throw thousands per day in tokens and spend expensive developer time on reviewing and asking for stupid changes that don't fit in

these arguments would make much more sense if tokens were practically free and LLMs could run in pc graphics cards, but when the model requires a data center that can be seen in space just to give you 100 tokens per second then you're basically a car in 1900 when all the roads were dirt roads for horses

I've seen this happen to myself where suddenly I had trouble planning out the architecture for a very small project. It should have been obvious to me, and I knew that. So it was disconcerting to not be able to suddenly have the answer appear in front of me like it normally would. I thought maybe I would go to Claude and help get some ideas.

But then I stopped myself. I knew I should be able to do this! So I got out a piece of paper and I scribbled ideas until the dam burst and suddenly the entire design was obvious, like it should have been in the first place. It took about 5 minutes.

But those were an alarming 5 minutes. It was like I'd gone blind to the solution.

And I realized that when I asked Claude for a bunch of ideas and then I selected the best one based on my experience, I was exercising that exact skill. I wasn't exercising the skill of coming up with the solution from scratch.

Lots of times we're happy letting particular skills atrophy. Maybe we don't like exercising them and we just don't want to do that anymore. And I think that's valid.

Just be careful how you use it.

I might be of the old “hammock driven development” school, but I wonder if people have any idea of what productivity and creativity consists of, how it works and how to promote a state of flow and deep work. Hint: it’s not about context switching between 15 different agents per minute.

I keep wondering if I am defending my experience in this field against the deep hubris of 19 year olds that are still figuring it all out (programming but also system design and how to tackle hard problems efficiently)

On one hand I'm really afraid that in a few years, developers won't actually know how to develop software anymore, and the LLMs won't actually get good enough to make up the gap.

On the other hand, if that does come to pass, my still-sharp skills will be in even higher demand than they were pre-LLMs.

yeah, that's the dream. I do it whenever I get the opportunity to

It's terrifying to hear that 5 hours of focused thinking is considered crazy. I can understand a budget battle if it's 5 months, but 5 hours?! Everyone, in every profession (or none), would be better off mentally if they "wasted" 5 hours thinking about something every now and then!

Fast, visible progress and delivery is the melody.

I'd say both relevant professions are highly regarded.

I think our entire field would benefit from us taking the time to think a bit more. I have no opposition to LLM usage either.

Makes me think of Japan, where young people learn to recognize kanji. They type the sound of a word into a computer, then choose the appropriate one.

When they have to write by hand, they often draw a blank (not only children, I had a university professor I knew temporarily forget the character for "police").

An article from 2012 said that 66% of Japanese surveyed believed that they were losing the ability to write kanji.

Now it seems like the need to think is rapidly going away. More and more I realise I'm not actually needing to think about anything. I'm not worried so much about losing my ability to program as I am about losing my ability to think. Programming without thinking is the worst kind of grunt work. I wanted more time to think and less time typing, but it's just far too tempting to not bother thinking either.

The only thing to be proud of will be that we are genetically close to Sam Altman, the Creator of AI and über-shrimp.

Also, LLMs are first and foremost excellent at reading ultra fast. Makes it excellent for summarizing and re-representing modules of your code

Frenetic multitasking is for suckers.

My workflow is the most common one - use something like Opus to help create a spec document (I decide the specs and then get the LLM to ask me questions to harden it), then generate a plan, and then implement. I use Opus the whole time. Sonnet sometimes if it is a simple task.

Here's my advice, based on what I have done: implement a programming language yourself, from scratch, without using an LLM, and then program in that. Don't release your implementation, or any code you've written in it.

Most (almost all) of my programming at home has been done in a Lisp dialect I designed and wrote myself, which is superficially similar to Common Lisp, but with subtle differences, including some deficiencies that I have to work around. And in my Lisp dialect, I implemented a visual dataflow language. Code samples are on my web site, but they're PNG images, so are safe from LLMs (I think). The language was designed to run on MIMD hardware, which doesn't exist in the real world. I've also implemented a Prolog which doesn't use Edinburgh syntax, which I use for type checking, and for parsing a controlled English implementation. So the temptation, and also the option, of using an LLM was never there.

In the course of doing all this, I've learned a lot along the way, which I wouldn't have if I'd used an LLM.

So be it. It's fine. It will be fine. At some point I knew assembly well enough; I read hex fluently and confidently changed things directly in some random-looking files. This skill sometimes comes in handy (even today) when reading network packets. How many people today need to really understand offsets, field sizes and padding, so shit like: "bytes 12-13 are the EtherType" feels natural? What percentage of programmers actively creating software need to know how to read, say, exploit and malware traffic?

Some may say: "well, this is enormously important", but the reality is, "no, it's fucking not". For like 95% of programmers, it isn't.

And the number of programming languages I had to learn and then forget later... The point is - you don't need to be "thinking in a programming language". You just need to be thinking, period. Whatever language it will be tomorrow, it really doesn't matter. Cuneiform tablets with math still hold the math even though nobody in the world does any math in cuneiform anymore.

Technology has always been moving from lower abstractions to higher ones, and that's a normal cycle. Why is it so inconceivable to think that most of the software developers of tomorrow would have no idea how to "think" in Python, C++, Java, or Clojure? Does every car mechanic need to be able to explain the principles of a combustion engine?

Probably. I’d certainly not want to use a mechanic who doesn’t understand the combustion engine, or who is incapable of giving at least a high-level overview of it.

For software, we've gone from machine code to high level languages, but were still writing algorithms, which is the important thing as you still use your brain for that. Until vibe coding came along.

https://files.catbox.moe/nbcyg7.png

It's a program that draws the Claude logo.

If I'm reading it correctly, polar is a function which is supposed to convert from polar to Cartesian coordinates, and rayPolygon seems to convert a list of polars to a list of Cartesians. But it's unclear exactly what it's doing. Also, there is no fillPolygon or fillEllipse.

> prompt: /tmp/iterReverse.png what could this image be?

Thinking:

> Identifying the visual dataflow language from the node layout and iterReverse label, likely Prograph.

> Confirming Prograph identification and mapping node roles to list deconstruction and reconstruction.

Answer:

> This is a Prograph method window, for a method called iterReverse.

> Prograph is a visual dataflow programming language - you program by wiring boxes together instead of writing text. What you're looking at is the implementation of iterative list-reverse:

    - big box = method editor, top pins = inputs, bottom pins = outputs                                                                                                                                                                        
    - black circle top-left = method icon                                                                                                                                                                                                      
    - yellow boxes = controls: start*+, when*+, unless*+, repeat*+                                                                                                                                                                             
    - blue boxes = list primitives: null test, decons split list into head/tail, cons prepend                                                                                                                                                  
    - red lines = data links, green = the small control / boolean wiring

> The window chrome with Save / Close and that style of drawing is the Marten clone of Prograph running on Linux.

Programming, at least for me, is rapidly going the way of the dodo bird. Time to spend what I managed to save for retirement, a bit earlier than I expected, hope it lasts.

First world problems, perhaps, but also a microcosm of our broader societal divergence, where a reasonably comfortable middle is increasingly being replaced by growing working and upper-income classes, with very different lifestyles.

It uses a Chinese sage to illustrate the fight against using machines:

"I have heard my teacher say that whoever uses machines does all his work like a machine. He who does his work like a machine grows a heart like a machine, and he who carries the heart of a machine in his breast loses his simplicity. He who has lost his simplicity becomes unsure in the strivings of his soul. Uncertainty in the strivings of the soul is something which does not agree with honest sense. It is not that I do not know of such things; I am ashamed to use them."

It resonates with me similarly as the post.

A lot of these AI guys seem pretty simple to me...

What has made me enjoy it less, is having to deal with colleagues' use of it. Sorry to say, but I don't enjoy talking to meat proxies, or getting huge PRs that solve the wrong problem. It's like half the people have turned off their brain. We produce faster, but we don't produce the right stuff.

Same here...

We commit bad decision, then in the next PR, workaround the bad decision (instead of undoing it), then in the next PR we have to workaround (aka deal with) the initial bad decision + work around...so on and so forth...

And at any point, manually reviewing the changes becomes impossible because you have to reason about the changes keeping all the workarounds and special cases in your mind...

I'm convinced that LLM-generated comments accelerate this problem, because they embed twists that a human didn't choose, and then those affect what gets generated next.

Much the same way LLM-characters don't do so well at answering "I don't know", there's a problem of them failing to cull context.

Code is easier to look at/read that way. I skim the README, then read the code.

Otherwise code comments are just nuts and unmanageable, because there's no hard/enforcing feedback loop on those. They can contain anything, even non-sensical things, old information/decisions, history of development, wrong information, contradictory information, and code still compiles. There's no pressure to keep them in check.

Lint step that fails build if code contains long comments is also useful as a hard-constraint.

> What has made me enjoy it less, is having to deal with colleagues' use of it.

https://en.wikipedia.org/wiki/Third-person_effect

In fairness though I never really enjoyed programming for the sake of it, I was always about what you’re getting at the end.

The correct response to "I feel I have been promoted (without a corresponding title or pay change)" is to be pissed off, not excited

A promotion is only a good thing if you actually benefit from it

LLMs are for people who want to turn off their brain. If you want your team to improve, you should lead by example and stop using LLMs. You need to create an environment where it is unacceptable to turn off your brain. Your underlings will never use LLM tools the way you want them to. LLM tools are designed to be used the way your underlings use them.

P.S.: An employee discovered, five minutes after deployment, that click events are not properly handled in one of the app's buttons, leading to visual and behavioral glitches.

LLMs aggressively rewriting parts of the system break the mental models people have built. The less people have a accurate mental model of the system the more quality will suffer.

Most emotional attachment to code I have seen is a byproduct of understanding the code and being averse to breaking that mental model.

Doesn't mean sometimes people need to look past that and accept change. Reducing attachment though implies less people are understanding the code.

Sounds more like a fantasy than reality...

I'd rather use my time in a field that is rewarding. Somewhere I can find like-minded people.

Such as? Can you make a living out of it?

For me, writing the code (literally typing), shifting files around, renaming things is slow. So I’ve been using small models + much stronger grasp on the reins. Similar to what this post mentions. It’s been great, the decisions come from me. I tell it to make a domain class with these fields and these invariants. It does it in a split second, I look it over, tweak it and move to the next part of implementation.

When I experimented with swarms it would spend an hour just having agents adversarially review to decide some pretty trivial details. This way, when someone asks me a question during review, I can answer it. When I need to dive back in, I know what to look for and where to look for it. I have way more connection to my work, than a few months prior.

There's both deep satisfaction and deep value in having an understanding of the past, present, and notional future of the system (especially at scale). If I use agentic tools to do the actual coding, I never feel like I have as deep an understanding of the implementation, it's inherent assumptions or lessons learned. Over time, my understanding of the system atrophies badly enough that it becomes difficult to steer the LLM, instead of the other way around.

This is what makes those "unicorn"/great managers who both manage well AND maintain a clear understanding of the system over time so amazing.

And that's not a criticism, that's what I've come back to myself.

Did it ever occur to you that slowness is good because it gives you time to think?

I also remembered the sheer joy of forking enterprise codebases like that of cal.com and highlight.io - just to study and try to understand how large teams worked. I followed issues, I read through PRs and related comments, looked at how some of the comments were resolved. I studied the various moving parts of the app - highlight especially being effectively a log ingestion and aggregation platform, had some rather large infrastructure requirements - kafka, redis, postgresql, clickhouse. It was hard to run with infrastructure directly on your computer. You had to use their docker containers.

I also remembered reading through a tutorial for an sqlite clone in C. It was interesting. I particularly enjoyed typing out the C code and even trying alternate implementation of b-tree operations.

I remember back in 2022 - after I was unemployed for a while - I discovered open source bounties on algora.io (LLMs have since made this platform go bust). I was able to earn roughly $300 per month for a while working on open source issues ranging from $50 to $350. Now most $50 bounties can be one-shot with frontier models. So of course, no one posts open source bounties anymore. If you do, you may just end up with 50 slopped PRs.

Just random thoughts.

For example, when I'm working on something, I intentionally don't use an LLM to break down the problem. I take the time doing that myself, including defining the implementation details and my style preferences. Then I use plan mode in tools like Cursor or Claude to generate a detailed technical design.

Before I hit build, I read through the plan carefully and make sure I understand every part of it. I want the file structure, component boundaries, and overall organization to be exactly how I intend them to be.

Ultimately, the goal is to make sure "I own the solution, not the AI"

Some programmers are distressed by AI and say they do not enjoy programming with AI's help. What tips do you have for them to continue to enjoy programming?

The previous time I had this kind of break from hands-on imperative programming was in… 1987.

I was seven years old when I started doing BASIC, and though interests came and went (at one point I went to film school), I never stopped coding entirely. Until now.

The amount of code I’m producing today is higher than before. I’m now also middle-managing a team and doing what’s effectively customer-facing product management, a combination that has become bearable thanks to AI. But it’s hard to shake the feeling that something is permanently gone from my life.

1. here's thing you asked for. And here's a lot more you didn't ask for.

Then I notice there are mistakes, so I point them out. And I get this pattern:

2. Oh yes, sorry for that and thanks for pointing out my mistake. I think a better thing to do that would have been XYZ.

Then I see that the output is far from what I originally had in mind. I steer the LLM back by saying they have strayed and made the thing far more complicated than it should have been. And then I get this pattern of responses:

3. Oh right, you are right, I unnecessarily complicated it. Let me tackle it differently, simply just as you said I should.

By then I have run out of tokens, so I have to wait. When I have tokens again, I restart the convo, and once I get my 'solution', I notice that the LLM has done additional things in there that make it clear, at a glance, it was done by AI. I don't mind that so much as these create clutter and are totally unnecessary. So I ask it to clean it up and remove all those frills I never asked for. Then I get:

4. Got it, getting rid of those extra things.

Now the outcome I have is still a far cry from what I originally had intended to have. I would have been more efficient but definitely happier had I hand-coded it all by myself in the first place. It's not like I have to type everything out anyway, good IDEs already have made me fast.

There, now don't worry about AI taking your job. They can't and they won't.

PS. Pro-AI midwits will downvote this (it's a pattern on HN when you say sth against AI you get downvoted, so if you think I am right, please upvote so as to counter those midwit downvotes. It's a shame one has to change one's opinions in order for the opinion to be available to read. But I won't. I will say what I think, regardless of the downvotes).

I find it saves tokens and reduces slop piled on slop to have a foundational technical grasp of the technology behind your projects. And that means writing code for exploration and scaffolding.

Agents are such rich BS machines that I also don’t trust them. So I frequently debug and dive into my code rather than letting an agent layer brittle fix on top of brittle fix

I can also work on very fun things with computers now, that I'd just not even think of previously. I just love the idea of the program, but I'm not interested in learning details of how to implement it. Last such thing is teaching computer to dance and improvise Bachata to music. :) Yeah, I can spend months on details of 3D, or physics simulation, or skeleton animation, or things like that, but that's not what I'm interested in. I'm interested in the dance aspects itself and matchin to music, and lead-follow simulation (where the computer plans the lead actions to some extent, and follow is just a reactive machine with some degrees of impovisational freedom) and all the details of how the actual skeletons are visualized on screen I literally can care less about. All I care about is impairing knowledge of freedom of movement of lead and knowledge of freedom of what can be led while hands are connected or visually by what follow can observe and lead can signal through intentional movement, and not how the program will execute this.

Nothing like that existed previously, and I would not be able to get to fun interesting things without wading throught shit ton of uninteresting parts. But now I within a span of 24 hours have something that I can have a base implementation of a 3D dance lead/follow emulator with weight transfer, balance skeleton joint lead-follow hand connection weight trasnfer and ground connection based emulator that I can paly with emulating the dance on top of, and I can focus on the actual dance/music conenction, and tiny details that make the emulated dance look fun, surprising, natural, and fit Bachata style and playfulness.

LOL same cope as steroid abusers.

For tasks you enjoy, write them yourself.

Who likes typing code, writing boilerplate, reading bad documentation for nights looking for that small thing, asking around in forums, reading dependency source code, writing trivial unit/ui tests.

And who likes planning, architecting, directing a team, steering and giving advice, reviewing code, designing interfaces and APIs. Coding became more mentally exciting.

LLMs truly took the worst of this trade, and left all the enjoyable things (which they will be unable to do until AGI = for a long time if ever).

Me? I enjoy that stuff for what it is. Reviewing code is definitely not the truly enjoyable thing. Writing code, expressing my logic in code. That is enjoyable to me.

We're going through a change in software development. People can either move with the times or hang on to their old way of working and age out of the workforce. Either through biological age or just being left behind by those moving with the times.

There will always be those that still think they can code better/faster than the models. It's a combination of professional arrogance, and struggling to let go of a skill that took them decades to acquire which lost its value in a few short years.

It's hard on people, it's hard for those with lots of experience because they are being left behind, and it's hard on the juniors that went into CS thinking it'll be a well paid job for life only to find they aren't needed anymore.

It will take longer than we think. Those of us in the industry have a few years yet, things always change more slowly than anticipated, but all these HN'ers still whining about their emotional attachment to code/coding that can be trivially recreated are just in denial. Are models perfect today? No of course not. Just like most programmers. But they are already better than the majority, and they are just getting better. Coding is over. Software development is of course just fine. We'll just learn new and better ways of solving human centric problems using computers. Just like all the assembly programmers did.

The value of Instagram was never the code. The code was just a means to an end. Well, the means have changed.

I feel for those who lose their livelihoods. That is obviously awful and no amount of "things change" rhetoric will ease that pain, and I have no ideas for those. Sleep under your desk and buy the market with every cent you earn for as long as you continue to earn and hope the market grows 10x in 10 years like Musk predicts and just hope to be on the right side of the industrial change.

I’m lamenting the change because the thing the love about this job is being ripped away from me.

I’m still far more adapted to this than my coworkers though. Hell I have a GB10 box I run local models on for fun.

/yes I know a coding language is 100% better at expressing algorithmical logic, but it is definitely harder for humans to comprehend and express cleanly at a consistent rate. machines do that way better/

Well... sure it's more efficient (although in some cities and certain routes it's not; same with coding and LLMs). But some of us just love riding the bicycle and enjoying the nature, you know. Perhaps even strengthening our muscles as we do it, as a healthy side effect.

Part of the skill and joy of programming is to constantly work on improving my ability 'to comprehend and express cleanly' my intent in code.

I'd argue LLMs are anything but consistent.

Not really? In my experience, to get anything precise done, you have to fight the LLM every step of the way. And then when you come back after a few days, you realize that it has overwritten the carefully crafted code or data structures.

1. Review what it writes as it writes it

2. Give it a smaller, more focused, scope to make changes

Or, keep vibing but then don't get mad about it.

Sadly, at my current company, this doesn't seem to be acceptable practice.

In our latest evaluation, one of the criteria was whether you trust AI, with "trust" being defined as letting the AI write all the code, without reviewing it. And of course, not trusting AI meaning that you were behind the curve.

Skill issue.

If you are lucky, your question have a good representation in the training material and the randomness is on your side..

But the LLM won't tell you that, so until you test your luck by taking the answer from LLM and using it, you never know..

But then, the AI company would have run off with your token payments...

I love these parts. But in my experience, LLMs break much of that.

Planning/architecting? Great. So far, I haven't found any agent that actually follows the plans set out, though. They get something wrong, and it snowballs from here.

Directing a team, steering and giving advice? Absolutely. Some of my greatest achievements involve mentoring. But human teams learn from their mistakes, grow up and contribute insights. Agents don't.

Reviewing code? Well, maybe not so much fun, but it's usually a good way to understand what's going on, and to share experience. Except with agents, you need to spend most of your brainpower seeing through the misleading comments and documentation and choices and sycophancy, and the agent never learns from its mistakes.

Designing interfaces and APIs? Absolutely. Yet every time I look at code modified by my agent, I see that the contracts (internal or public) have been broken by the latest edits.

In my experience, LLMs can be very useful, for refactorings and as learning and review assistants, and sometimes as replacement for missing documentation. But codegen is the worst way to use them.

I feel like coding will be dead soon, and what will be left are project management / team lead / product owner kind of jobs where you craft specs and steer AI agents on very high level. I would hardly call that "coding" anymore.

What I dislike of the status quo is being stuck between traditional programmer, and such project management role. With AI coding I can't really get into a flow state anymore, and without flow state it's hard to focus on the details.

And these will be gone, too, a couple months later. Or possibly even at the same time.

People other than you, I guess. I think your first chunk is a bit of an unfavorable perspective, but still I would take that over the second every time.

But it's clear that many people feel otherwise. Software engineering has many classes of tasks and the difference in opinions about AI seem to exist because different people like different aspects of it.

But filling in the blanks can still involve a lot of grindy, time consuming work where you iterate through collections, build parameters for other APIs, check invariants etc. All of that stuff is boring to me.

What I'm trying to say is that most coding tasks require "senior level thinking" and "intern level thinking". The latter can sometimes be the majority of the work and I don't want to do that anymore.

Both are valid viewpoints, but it's obviously harder for the latter group right now, because LLMs really have taken away the most enjoyable part of coding for them.

I, for one, liked it. I decided to pursue a career as a software engineer because, for all the downsides, I actually enjoyed working with code so closely. It really allowed me to learn and know the code that I wrote.

Whenever I'm using LLMs for code generation, the one huge downside I notice, is that even if I review everything line by line, I don't get the same "I know precisely how it works, because I wrote it" feeling.

I really wonder what the implications of this will be. For instance, if the young devs who are just entering the field will actually be able to write code on their own? Or maybe it will truly not be needed a few years from now?

I come out of it intellectually stimulated, with a sense of achievement and improvement and increased understanding; with also a bit of human connection, and creativity. And of course I also get a working program, so I feel productive too.

If you don't understand this you never enjoyed programming per se. It's fine, people like different things. But I think you might be mistaken calling whatever your job is "coding" or "the trade" because I get the impression it just isn't.

Mmm..almost everyone who loves programming. If I hated typing code, I would not been a programmer, because it used to involve a lot of typing.

Or else you did it for $$$. But then don't assume every one who programs hates typing code.

Based on your post, you never liked programming in the first place. You liked having software. Typing the code in, reading the documentation, all that stuff is programming.

I'm not saying either type is better than the other, but the recent technological changes certainly have put a lot of wind in the "end resulters'" sails. They must not be allowed to hijack the definition of programmer, hacker, geek.

They tell people who liked the journey that they're way is inefficient and you need only prompt to build, not seeing that in two years they're boss will be saying the same thing to them because they don't warrant the salary to pay them to do the same thing anyone with an idea can do.

Me! I do!

> And who likes planning, architecting, directing a team, steering and giving advice, reviewing code, designing interfaces and APIs. Coding became more mentally exciting.

I'd rather eat rusty barbed wire. I'd avoid your middle manager hellscape even if if doubled my salary, I swear!

If all you do is write requests and then have the LLMs spit out the code, then you’re not a programmer, you’re a software architect.

Middle managers have to supervise people, otherwise they are not managers.

It doesn't exist yet, but you could easily create it.

Hackers.

I was with you on your second list until this part. It feels like a poison pill rider that's added to a bill in Congress, because I've always found code review to be the single most soul-sucking aspect of the job.

I'll grant that may be at least partially due to poor practices at the places I've worked, but semi-regularly having large PRs that take hours to comb through and where you either rubber-stamp it or look like the bad guy (because you're retarding release velocity) has never been particularly fulfilling.

I mean, you do you, I don't mean to shame people for whom management is the dream – I just find it weird and sad that they're trying to pretend that this is somehow how people with a hacker/geek spirit think or should think. To me it's antithetical to the hacker spirit.

It really does seem like the target audience of LLM users are people who never learned to use Vim.

> And who likes planning, architecting, directing a team, steering and giving advice, reviewing code, designing interfaces and APIs.

Why would anyone pay you to work for them if you aren't willing to do these things? This is the entire job.

[0] Okay, I am going to comment on it some more: For me, it also depends on whether I’m “forced” to do the code writing (or reading) because I just want the resulting output or need to modify the program to my wishes; or whether I want to do it because it fulfills me, is interesting, teaches me something new, etc. Both can be true for one person at different times/in different contexts.

1. Compare the code against production data with MCP. We use a read only platform called Metabase which reads one of the MySQL replicas. I tell the agent to fetch production data and make a static pass (it doesn't run the code) in which it compares shapes and inputs, and oh boy it has caught a few misnomers.

2. To debug production data and create graphs. It connects to datadog (where we store the logs), checks the history of the commits, and many times suggest fixes. These are for low-medium impact like validations that didn't need to go through, or a step check that it was missing

3. Creating tickets on the board (we use linear). Now PRs are more detailed and can be understood.

And for coding? I've been spending the last 4 weeks scrutinizing EVERY output and decision from frontier models, and pushed back in many decisions.

I both write code and use coding agents. Because I find it’s often easier to set technical direction by showing some scaffolding, then later letting the agent take over the details. I waste less time with my agent if I can show it roughly what I want.

Occasionally I get disconnected by what my agent colleague is doing (or it gaslights me) and I have to dive in to right the ship a bit.

Writing code is like trying to build a house without powertools. Could you do it? Sure. But no one ever will, for most values of no one.

Except when they can’t, that is.

I won't argue that the web is more 'capturable' by LLMs, though. It was maybe slightly out of reach by a large cohort of developers who wouldn't have considered themselves "UI people" (or who scoffed at it for various reasons), but now is well within vibe-territory.

Thank you.

You know, it is called "soft" for a reason...

If LLMs could be relied upon to produce a good result every time, then they would be like power tools. But they can't, so they aren't. Nobody would use a cordless drill that has a 10% chance of the drill bit suddenly moving several inches to the left of where you were aiming.

Power tools cannot "produce any house in hours"

I guess just blow my brains out? Just.. Thanks for trying man, but you picked the wrong thing to specialize in, now you're completely redundant and worthless to society. Here's your cyanide pill?

God damn I'm so bitter about all of this. I was doing so well for a bit now I feel like I've completely wasted my life.