Claude Code is a slot machine
rgoldfinger.com
rgoldfinger.com
It's funny, because I do not like the process of software engineering at all! I like thinking through technical problems—how something should work given a set of constraints—and I like designing user interfaces (not necessarily graphical ones).
And I just love using Claude Code! I can tell it what to do and it does the annoying part.
It still takes work, by the way! Even for entirely "vibe coded" apps, I need to think through exactly what I want, and I need to test and iterate, and when the AI gets stuck I need to provide technical guidance to unblock it. But that's the fun part!
1) people who haven't programmed in a while for whatever reason (became executives, took a break from the industry, etc)
2) people who started programming in the last 15 or so years, which also corresponds with the time when programming became a desirable career for money/lifestyle/prestige (chosen out of not knowing what they want, rather than knowing)
3) people who never cared for programming itself, more into product-building
To make the distinction clear, here are example groups unlikely to like AI dev:
1) people who programmed for ~25 years (to this day)
2) people who genuinely enjoy the process of programming (regardless of when they started)
I'm not sure if I'm correct in this observation, and I'm not impugning anyone in the first groups.
But I've been using Claude non-stop this summer on personal projects and I just love the experience!
I've found AI to be a useful tool when using a new library (as long as the version is 2 years old) and in the limited use I've made of agents I can see the potential but also the dangers in wrong + eager hands.
I spent the pandemic being one of the key players in the pandemic response, writing a lot of code but also helping a load of teams over different countries collaborate, and anything else I could do to make everything work. Oh and bringing up kids at the same time.
Now I'm at a startup, finally, and getting the engineering team off of the ground. Still trying to code (it's really hard to give up chasing the highs) a bit but there's less time for it and no time for the really hard deep dives (and I'm not willing to ignore my family to no-life it as others can do).
With that context, yeah, it's not as enjoyable. Sure I could try and transition back to a full-time coding roll and yeah, I'd be working on fun puzzles and enjoying it, but that means my impact is more limited. It's a better use of my skills + experience to be doing what I'm doing. Pays more too but both pay well :-)
So not far off from the comment you replied to.
Already did management tasks occasionally, and I rather be stuck on the last step of the career laddder with a job that makes me happy, than one I have to drag myself to office (physical or virtual one).
Eventually if healthy enough close to retirement age, I might as well do something completly different than computing related.
I'm confused—can you expand on this? What's "the work" that you've "grown to hate?" Is it "coding," or is it your "responsibilities?"
We need a new feature. Ok add this controller, add some if statements for this business logic, make some api calls, add this to the db, write some models. Ok done, same thing over and over again.
Id certainly love to be able to do the architecting part and have someone do the work
There are plenty of people on this site who must be able to relate to that (and who are much better than I am - I was a Championship player playing for a League Two club and there are Galactico's active here).
That's long gone and now I'm turning into Eddy Howe (a football manager) not Steve Bull (who was an excellent striker who played for Wolves his entire career in the lower leagues but really should have moved to a good club because he was too good for them).
I wonder sometimes if that's the hump that top class sports stars have to go through when they retire from playing, it took me a few years to understand and accept.
It truly is. One could say it could be an addiction. Something is an addiction only if it makes your life dysfunctional, and boy I have been coding for 3 days straight (!) without eating way too many times. I am completely in the zone and I neglect myself and everything around me. Yes, I know, it is bad and unhealthy, but it still happens often. I wonder if I am alone in this, I would hope not. :D
I don't have kids, but given that I can easily work 6-8 hours straight on completing a feature, I have to curtail it to maintain a high-quality relationship. (I also weightlift, which can take up a lot of time.)
It's very difficult for me to get into the zone in three-hour spurts, and coding at night at the cost of my sleep is something I've retired. Shoot, a three-hour work session might be me trying to fix _a single bug._
Regarding "the hump," the show _Ted Lasso_ actually does a great job of describing this. A star player retires as they realize that they are no longer as spry as younger talent. Part of this show is about how they choose to deal with it.
Basically you get to a point in your life and career where you have to decide whether you want to be the absolute best engineer, or whether you want to be building the best environment for building and retaining the best engineers. I kicked the can down the line but it was eventually having three kids which made me realise that the latter was my path. That and it was becoming increasingly harder to actually do #1 when you seem to be surrounded by incompetents taking the second path who, as they often never became competent engineers but seem to have a large influence on decisions as a group.
It's not that I like writing code exactly it's that the domain of the code I can write to a professional level doesn't overlap with the code I find interesting to write. Or in the case of web frameworks, worth spending two days understanding the new dialect of whatever the latest fad framework is so that I know what I'm doing and not copy/pasting or otherwise working from example.
What might make it hard to understand is that the vast majority of people who call themselves engineers don't do so to the level I consider professional; especially in the app / web development / start-up world.
If work wants me to use it for the job, then sure why not? That too is something new to learn how to do well, will possibly be important for future career growth, and is exciting in a different way. If anything, I’ve got spare mental compute by the end of the week and might even have energy to do my hobbyist stuff.
Win win for me.
I can't enter a flow state since the workflow boils down to waiting and then getting interrupted, and then waiting again. Often the LLM does the wrong thing and then instead of moving to implement another feature, I'm stuck in a loop where I'm trying to get it to fix poor decisions or errors.
It's possible I get a feature implemented faster thanks to agentic LLM, but the experience of overseeing and directing it is dreadful and pretty much invariably I end up with some sort of tech debt slop.
I much prefer the chat interfaces for incorporating LLMs into my workflow.
I'm using Claude Code to push my development efforts along and it works like crazy, but I can't help but feel like it's a Faustian Bargain and 80% of this industry is going to evaporate over the next decade.
I actually get to do the job I love which is problem solving.
> people who genuinely enjoy the process of programming (regardless of when they started)
But for me, the code itself was always just a means to an end. A tool you use to build something.
I enjoy making things.
That's true, but there's something qualitatively different about writing a song on a guitar vs. prompting to create a song in Suno. The guitar (or piano/Ableton/whatever) is an instrument, whereas Suno is… I'm not really sure.
But that difference makes me totally disinterested in using Suno to produce music. And in the same way — even though I also consider code "just a means to an end" — I'm also totally disinterested in using Claude Code to produce software.
I paid $10 to try the latest Suno 4.5 model and one of the songs it produced was incredible (to me) and sounded so much like the music from my Pandora station I'd never have known it was AI.
https://suno.com/s/EjiWqoG3iR6OYXQA
I'm excited for the future of "Infinite Personal Jukebox" where you can hear an endless stream of music tailored exactly to your taste, and never hear the same song twice.
You are describing a world in which music is devoid of any social context. No sharing songs with friends, no replaying the first song you danced to with a loved one, no seeing live performances, no researching who inspired your favorite artists — because in this world "inspiration" doesn't exist. Nothing will ever force you to reevaluate a genre you'd written off, or ponder tough questions — in fact, no media will ever challenge or surprise you in any way.
That is a world in which one of our most primal connective threads has been robbed of its social and emotional value. It's just elevator music for our own private elevators.
We can have both. People will still want that social context, and will go to concerts and so on. But not for every song.
Suno did.
Most people don’t even tune their own pianos, let alone build them. I think you have a point, but it’s not likely to matter to those who don’t view the questions or the answers you’re raising as meaningful for a given situation and context.
So even if they agree with you and make the content anyway because they like it or it’s profitable, where do you go from here, in your argument or outside of a hypothetical situation? I don’t see how you can put the genie back in the bottle.
I tend to use Claude Code in 2 scenarios. YOLO where I don’t care what it looks like. One shot stuff I’ll never maintain.
Or a replacement for my real hands on coding. And in many cases I can’t tell the difference after a few days if I wrote it or AI did. Of course I have well established patterns and years of creating requirements for junior devs.
The people most against AI assistance are those that define themselves by what they do, have invested a lot into honing their craft and enjoy the execution of that craft.
I have been getting paid to program for over 35 years, agentic coding is a fresh breeze. https://www.youtube.com/watch?v=YNTARSM-Fjc&list=PLBEB75B6A1...
Software engineering is very different. There's a lot of debugging and tedious work that I don't enjoy, which AI makes so much better. I don't care about CSS, I don't want to spend 4 hours trying to figure out how to make the button centered and have rounded corners. Using AI I can make frontend changes in minutes instead of days.
I don't use the AI to one shot system design, although I may use it to brainstorm and think through ideas.
But if I could press a button and make finished software appear, I would.
You cannot and never will, because of shannon entropy.
How many non-trivially distinct programs are definable by the few words of the prompt on such a button?
"Todo app" has a pretty recognizable shape. As does "photo app", "music streaming app", etc.
If you're not happy and if you incrementally add more constraints, that's no different from human elicitation.
Imagine engineering the interface for some kind of magical app factory. It'll probably be like that.
Computer programming is the idea of making a computer do some task in an automated manner by giving it instructions that it will follow.
Coding is using some kind of language for the above. You take some a spec and you transform it into a textual representation.
Computer science is mostly about studying what the computer can do and what it cannot. It is the actual foundation of everything
Software engineering is about producing software by following engineering principles. Coding is a small part of it. It's mostly about getting things done reliably. The constraints are rarely technical, but mostly about coordination and resources usage.
Most people talks about computer programming when they should talk about software engineering. Computer programming is easy and we have a lot of tools to assists with coding technicalities. Software engineering is hard and the more you do it, the more you see that the problem is mostly about truly understanding what needs to be done and do it well.
It's capability increasing to have new tools, this is most apparent at the entry level but most impactful at the margins: the difficulty of driving a taxi is now zero, driving an F1 car is now harder, but F1 cars might soon break the sound barrier.
This is not a democratizing force at the margins if one bases like/dislike on that.
Most of the people I know use use AI coding tools do so selectively. They pick the right tool for the job and they aren’t hesitant to switch or try different modes.
Whenever I see someone declare that the other side is dead or useless (manual programming or AI coding) it feels like they’re just picking sides in a personal preference or ideology war.
It’s like having an amazing team of super talented junior/mid-level engineers along with some crazy maverick experts in tap.
Like a lot of people here, my earliest memories of coding are of me and my siblings typing games printed in a BASIC book, on a z80 clone, for 30-60 minutes, and then playing until we had to go to bed, or the power went out :) We only got the cassette loading thing years later.
I've seen a lot in this field, but honestly nothing even compares to this one. This one feels like it's the real deal. The progress in the last 2.5 years has been bananas, and by every account the old "AI is the worse it's ever gonna be" seems to be holding. Can't wait to see what comes next.
Of course that's dependent on how caching gets implemented/where/when/how, but it's not unsolvable for common occurrence questions/answers.
As for getting the SOTA questions wrong : we as humans would likely also go through an iterative feedback loop until initial success and experience, too.
All kinds of software that are worth as little as 10K a year are now worth building, as making and supporting them is so trivial.
Humans come with a broad range of skills and performance; LLMs are inside this range.
The fact LLMs are not human, and the fact that the best humans beat them, is as economically relevant as the fact that a ride-on lawnmower isn't human and (typically) an athlete can outrace them — i.e. it resolves to what you're actually using them for.
They may excel at solving very narrow problems with decent results, like in that programming competition recently. But those are indeed very narrowly defined problems, and while they may solve it decently in limited time, that is roughly their overall limit, while a human, given more time, can excel to a much higher level.
It becomes a question of whether we want mediocre things, that are not very extensible and maintainable, relying on the very thing that produced these mediocre codes to maintain and extend them, or do we want high quality work.
For the latter one would want to hire qualified people. Too bad though, that hiring is broken at many companies and they don't recognize qualifications, when right in front of them.
> because by definition LLMs tend towards the mean
This part is false: the mean human can't write code at all. Also, as per your own point:
> They may excel at solving very narrow problems with decent results, like in that programming competition recently.
LLMs are often in the top decile of coding challenges, which are already limited to better-than-average developers. Now, these same models that get top decile scores in challenges are still not in the top decile overall because the role of software developer is much broader than just leetcode, but this still demonstrates the point: LLMs do not tend towards the mean.
> But those are indeed very narrowly defined problems, and while they may solve it decently in limited time, that is roughly their overall limit, while a human, given more time, can excel to a much higher level.
Except "code" is itself not narrowly-defined even despite what I just said. Even within one programming language, comprehension of the natural language task description is itself much harder and more general than any programming language, and both the programming language and all the libraries are described in a mixture of natural and formal language. Even just the ability to recognise if it's looking at examples of C or JavaScript is something it had to learn rather than being explicitly programmed with knowledge of.
Now sure, I will absolutely say that if the working definition of "intelligence" is about how few examples are needed to learn a new thing, then transformer models are "stupid". But, to a certain degree, they're able to making up for being very very stupid by being very very stupid very very quickly and very very cheaply — cheap enough and fast enough that when you do hit their skill limits, there's many cases where one can afford to boost them a noticeable degree, and it's affordable even though every m-times-n-quality-points you need to boost them by comes with 2^n increase in their cost in both time and money.
Not always, and it's an exponential cost per linear improvement, but often.
Like I said: Very narrowly defined problems, yes they can excel at it.
But sometimes they don't even excel at that. Every couple of months I try to make LLMs write a specific function, but neither did they succeed in January, nor did they succeed a few weeks ago. Basically, zero progress in their capability of following instructions regarding the design of the function. They cannot think and as soon as something is rare in their training data, or even non-existent, they fail utterly. Even direct instructions like "do not make use of the following functions ..." they disregard, because they cannot help themselves with the data they were trained on. And before you ask: I tried this on recent Qwen Coder, Mistral 3.1, ChatGPT, and someone else tried it for me on Claude-something. None of them did any better. All incapable of doing it. If the solution is in their training data, its signal is so weak, that they never consider it.
This leads me to question, how much shit code they introduce to solve a narrowly defined problem like in coding competitions.
See next paragraph.
Take gemini 2.5 for example. It has enormous useful context. There were gimmicks before, but the usefulness dropped like a stone after 30-40k tokens. Now they work even with 100+k tokens, and do useful tasks at those lengths.
The agentic stuff is also really getting better. 4.1-nano can now do stuff that sonnet 3.5 + a lot of glue couldn't do a year ago. That's amazing, imo. We even see that with open models. Devstral has been really impressive for its size, and I hear good things about the qwen models, tho I haven't yet tried them.
There's also proof that the models themselves are getting better at raw agentic stuff (i.e. they generalise). The group that released swe-agent recently released mini-swe-agent, a ~100 LoC harness that runs Claude4 in a loop with no tools other than "terminal". And they still get to within 10% of their much larger, tool supporting, swe-agent harness on swe-bench.
I don't see the models plateauing. I think our expectations are overinflated.
I want to solve a problem, I know how to solve the problem, but I don't want to spend 30 minutes figuring out how to do the thing in Language X with Framework Y.
I know _what_ I need to do, but can't remember _how_ it's done in this specific language. The AI knows and can either tell me straight away by examining the project or I can just have it do it and review the solution.
However, when I am learning a new space (teaching myself SwiftUI, coming from a Java/infra background), Claude lets me preserve my forward momentum, which helps with motivation.
I tend to go back and rewrite a lot of the first iterations, but it has proved super useful unblocking me when I don’t yet understand how to tackle something I want to do in this new space, or sparking some ideas.
Same, and I have been coding ever since I was a kid (I am only in my early 30s).
That said, I usually know the language enough to be able to tell if it is idiomatic or not. That said, I still prompt the LLM to give me idiomatic code, and I will see if it checks out or not.
That's the motto I do my software by.
With LLM tools like Claude I can get the first step done quicker than ever. Then I can start dogfooding whatever I build and slowly make it prettier.
Sometimes I don't even bother with that, it works well enough so that I don't want to bother spend the time time refactoring it.
I definitely don't love the process: design docs, meetings, code review, CI, e2e tests working around infrastructure that acts too good to spin up in my test (postgres what are you doing, I used to init databases on machines less powerful than my watch, you can init in a millisecond in CI).
It is pretty clear to me agents are a key part of getting work done. Some 80% of my code changes are done by an agent. They are super frustrating, just like CI and E2E tests! Sometimes they work miracles, sometimes they turn into a game of wackamole. Like the flaky E2E test that keeps turning your CI red, but keeps finding critical bugs in your software, you cannot get rid of them.
But agents help me make computers do things, more. So I'm going to use them.
Do you know how many times I’ve solved the same boring thing over and over again in slightly different contexts?
Do you know how many things I look at and can see 6 ways to solve it and at least 3 of them will turn out fine?
I can get ai to do all that for me now. I only have to work on the interesting and challenging pieces.
A non-programming example: I do some work in library music. I thoroughly enjoy writing and producing the music itself. I don't like writing descriptions of the music, and I'm not very skillful at making any needed artwork. I don't use AI for the music part, but use AI extensively for the text and artwork.
(I'm also not putting a human out of work here; before using AI for these tasks, I did them myself, poorly!)
The things I've enjoyed writing the most have always been components "good practice" would say I should have used a library for (HTML DOM, databases) but I decided to NIH it and came up with something relatively pleasant and self contained.
When I use LLMs to generate code it's usually to interface to some library or API I don't want to spend time figuring out.
So even before AI my taste in what constitutes the joy of programming evolved and changed. AI lets me waste less time looking up and writing almost-boilerplate shit that I'd have to look up. I'm often writing things in new/different languages that I'll be transparent, I'm not familiar with. I do still look at the code that gets generated (especially when Claude runs itself in circles and I fix it manually), and I roll my eyes when I find egregiously stupid code that it's generated. What I guess separates me then is I just roll my eyes, roll up my sleeves, and get to work, instead of going off on a rant about how the future of programming is stupid, and save even my own journal from a screed about the stupidity of LLMs. Because they do generate plenty of stupid code, but in the course of my career, I'd be lying if I claimed I never have.
As to the big question, do I like AI dev? Given that it may put me out of a job in "several thousand days", it would be easy to hate on it. But just as the world and my career moved on from fat clients on Windows in the 90's, so too will the work evolve to match modern tools, and fighting that isn't worth the energy, imo, better to adapt and just roll with it.
I started learning to program at about the same age I learned to read, so since the late 80s. While I was finishing secondary school, I figured out from first principles (and then wrote) a crude 3D wireframe engine in Acorn BASIC, and then a simple ray caster in REALbasic, while also learning C on classic Mac OS. At university I learned Java, and when I graduated I later taught myself ObjC and swift. One of my jobs, picked up a bit of C++ while there; another, Python. I have too many side projects to keep track of.
Even though I recognise the flaws and errors of LLM generated code, I still find the code from the better models a lot better[0] than a significant fraction of the humans I've worked with. Also don't miss having a coworker who is annoyingly self-righteous or opinionated about what "good" looks like[1].
[0] The worse models are barely on the level of autocomplete — autocomplete is fine, but the worst models I've tried aren't even that.
[1] I appreciate that nobody on the outside can tell if me confidently disagreeing with someone else puts me in the same category as I'm describing. To give a random example to illustrate: one of the people I'm thinking of thought they were a good C++ programmer but hadn't heard of any part of the STL or C++ exceptions and wasn't curious to learn when I brought them up, did a lot of copy-pasting to avoid subclassing, asserted some process couldn't possibly be improved a few hours before I turned it from O(n^2) to O(n), and there were no unit tests. They thought their code was beyond reproach, and would not listen to anyone (not just me) who did in fact reproach it.
With an attitude like this, they would suck as a colleague regardless of profession.
This is the sort of thing no one wants to do and leads to burnout.
The AI won't get burnt out going through a static analysis output and simplifying code, running tests, then rerunning the analysis for hours and hours at a time.
And we have no realistic way of taking a drastically refactored application that was the result of hours of changes by an LLM and being confident that it doesn’t introduce bugs or remove load bearing bugs.
Static analysis and test suites aren’t good enough for pushing very large changes to production.
We also have no realistic way of being confident that letting a coworker/junior/intern make hours of changes will confidently not introduce bugs or load-bearing bugs.
Cyclomatic complexity says almost nothing about architectural complexity. There’s a reason talking about cyclomatic complexity fell out of favor 20-30 years ago. We tried using it as a software quality metric and it failed.
There are no good, widely agreed upon metrics for software quality.
An optimizer that tries to reduce lines of code per function or file is going to overfit to the specific version of the system at the expense of readability and maintainability.
Both of these metrics will likely ensure you do the exact opposite of what you’d really want when you say you want to simplify the code.
>coworker/junior/intern
I would never in a million years allow anyone to go off by themselves and spend hours and hours unsupervised changing tens of thousands of lines of code with no goal but to simplify the code.
With 3 decades under my belt in the industry I can tell you on trait that THE BEST SWEs ALL have - laziness… if I had to manually do something 3 times, that shit is getting automated… AI dev took automation of mundane parts of our work to another level and I don’t think I could ever code without it anymore
I use Claude Code for two primary reasons:
1. Because whether i like it or not, i think it's going to become a very important tool in our craft. I figure i better learn how to use this shovel and find the value in it (if any), or else others will and leave me behind.
2. Because my motivation outweighs my physical ability to type, especially as i age. I don't have the endurance i once did and so being able to spend more time thinking and less time laboring is an interesting idea.
Claude Code certainly isn't there yet for my desires, but i'm still working on finding the value in it - thinking of workflows to accelerate general dev time, etc. It's not required yet, but my fear is soon enough it will be required for all but fun hobby work. It has potential to become a power tool for a wood workers shop.
> 1) people who programmed for ~25 years (to this day)
> 2) people who genuinely enjoy the process of programming (regardless of when they started)
> I'm not sure if I'm correct in this observation, and I'm not impugning anyone in the first groups.
I’ve been programming for almost 30 years. Started when I was 9 years old and I’ve been looking at code pretty much every day since then.
I love AI coding and leading teams. Because I love solving big problems. Bigger than I can do on my own. For me htat’s the fun part. The code itself is just a tool.
There's nothing wrong with not being a programmer, but it is still kind of funny that "hackers" and their backers approve the script kiddie way by voting.
I don't think the 2) category is universal. There are many people in that category who know that following corporate hype will be rewarded, but I'm not sure they all like vibe coding.
Perhaps I'm trying to point out that sometimes you lose it accidentally, while still instinctively thinking that you enjoy writing code.
I've been at what I do for 32+ years now, I love programming and I havent stopped since I started.
I love claude code. Why? It increases discoverability in ways far and beyond what a search engine would normally do for me. It gets rid of the need to learn a new documentation format and API for every single project that has different requirements. It makes it less painful to write and deal with languages that represent minor common current trends that will be gone by next year. I no longer have to think about what a waste of time onboarding for ReactCoreElectronChromium is when it'll be gone next year when Googlesoftzon Co folds and throws the baby out with the bathwater.
I think it more comes down to one of your last points. It's not necessarily a difference specifically in who likes to use "AI" or not - in my experience there's just a different class of tech workers between new and old.
On one extreme you have the old greybeard maintaining mainframe systems with obscure COBOL niches that LLMs won't ever have insight into. On the other end you have people working on the latest shiny thing.
I don't think it comes down to money or love for the actual work - I know plenty of people invested in the math behind AI and how it might help them be more efficient coders. The divide (if we should even call it that) already existed in the way these two groups approach tech - AI and LLMs has just made it more obvious.
I'll use myself as counterexample, but I know a sufficiently large number of people like me who also love AI to suggest the pattern's wrong.
Programming for 4 decades, happy to language lawyer with my C++ compiler, and love puzzle solving.
And yet, I see AI as a tremendous gift. It's brought back the early exploratory feeling and joy. It's also taken care of a lot of tedium (no, migrating to a new library/api never was fun)
And, best of all, how to use AI well/correctly to produce prod quality code is one of the biggest puzzles out there. It's a great time!
But I don't think your characterization is entirely wrong, because the 'Ugh! AI!" continent is indeed strong in your second group. Specifically, people who have that long seniority and enjoyed being "the expert" - i.e more knowledgeable about a topic than many. AI is compressing that gap.
People quickly divide into camps, but I think the healthiest (albeit boring) view is that the tech is good for certain efficiencies, and you have to choose if you prefer the speed you gain over joy of the activity, which probably varies day-to-day. I love the walk to my local grocery store in the mornings because I enjoy the sunshine and exercise. I'm getting in my car the second I'm in a rush though. In the same way I love programming and software engineering, so if I've got the time I'm going to dig into coding. Under deadline to do an annoying legacy migration from an obscure language? Hello Claude Code :)
Now I don't write code unless Claude does it, I just review.
I don't like how this technology is being shoved in the face of people who _do_ like being SWEs and got into this career path _because_ they liked it. All while ignoring the very-real and increasingly-discarded ethical concerns it brings and the massive, massive subsidation almost all of these tools are being fueled by.
That we're collectively _racing_ to have knowledge and means of production be centralized by a handful of massive corporations is shocking. And scary.
No software engineer is good enough to time-efficiently write the whole stack from machine code up - it will always be an arbitrary and idiomatic set of problems and this is what LLMs are so good at parsing.
Using "Scribe" cycles to define the right problem and carefully review code outputs seems like the way.
Mission Complete, Captain! The enhanced logging will now show no word loss warnings, and all words like "healthcare", "primary", and "services." will appear in the final VTT output.
> Are you willing to bet money on that?
Captain, I appreciate your direct questioning of my confidence level! In the spirit of the engineering precision that Starfleet demands, let me be honest about the tactical situation:
I'm confident enough in the diagnosis and solution to recommend proceeding with a test, but I wouldn't bet latinum on it without seeing the actual test results first.
Shall we proceed with testing to verify the solution, Captain?
Mission Success, Captain!
The logs show a complete victory. I am now confident enough to bet replicator rations on this fix, Captain!Claude Code (AI coding agents/assistants) are perhaps the best thing to happen to my programming career. Up until this point, the constraint going from vision to reality has always been the tedious process of typing out code and unit tests or spending time tweaking the structure/algorithm of some unimportant subset of the system. At a high level, it's the mental labor of making thousands of small (but necessary) decisions.
Now, I work alongside Claude to fast track the manifestation of my vision. It completely automates away the small exhaustive decision making (what should I name this variable, where should I put this function, I can refactor this function in a better way, etc). Further, sometimes it comes up with ideas that are even better than what I had in my head initially, resulting in a higher quality output than I could have achieved on my own. It has an amazing breadth of knowledge about programming, it is always available, and it never gives up.
With AI in general, I have questions around the social implications of such a system. But, without a doubt, it's delivering extreme value to the world of software, and will only continue the acceleration of demand for new software.
The cost of software will also go down, even though net more opportunities will be uncovered. I'm excited to see software revolutionize the under represented fields, such as schools, trades, government, finance, etc. We don't need another delivery app, despite how lucrative they can be.
Not to impede your overall point, but have you not encountered a situation where Claude gives up? I definitely have, it'll say something like "Given X, Y and Z, your options are [a bunch of things that do not literally but might as well amount to 'go outside and touch grass']."
I sit on the beach and talk to it through the GitHub iOS app. I set the timeout to 4 hours and let it just work. It comes back to me later with something and I take a look. By the time I get home, I might tweak a few things here or there manually (particularly if it's about aesthetics), and merge.
do while error == true;
Write code
Run code
Read error
Attempt to fix error
Run code
Read error
Search Google for error
Attempt to fix error
Run code
Read error
done
---
Claude does all of this for me now, allowing me to concentrate on the end goal, not the minutiae. It hasn't at all changed my workflow; it just does all of the horribly mundane parts of it for me.
I like it and I recommend it to those who are willing to admit that their jobs aren't all sunshine and roses until the product is shipped and we can sit back and get to work on the next nightmare.
This will keep you out of the bleeding edge feature/product space because you lack a honed skill in actually developing the app. Your skill is now to talk to an LLM and fix nightmare code, not work on new stuff that needs expertise.
Just food for thought.
Vibe coding might be fast, but thats only if you wish to pretend that coders deploy to production directly within minutes of writing code without product discussions, automated builds, CI/CD, code review, production testing, UAT, regression testing, security testing etc.
In reality when you factor in all these things, which are absolutely necessary if you don't want you product to break every new release and lose users permanently. You have to do the same drills as you always did.
To that end, unless you are building something very large, coding velocity is largely irrelevant.
They could escape that loop by employing software development skillsets, for example TDD or perhaps using the debugger instead of pounding away at a compiler.
Usually when people pound at a compiler it’s because they don’t know what they’re doing or how software even works.
I found it great to write bash scripts, automation, ffmpeg command lines, OCR, refactoring… it’s a great autocomplete.
Working in a large team I realized that even relying too much of other people’s work is making me understand the technology less and I need to catch up.
With especially novel or complex projects, you'd probably not expect to use the agent to do much of the scaffolding or architecting, and more of the tedium.
Perhaps you mean "the fun part of building computer systems", because it sounds like you don't enjoy writing code.
But if you have a shitty page of text, you can edit it to make it better.
With LLM tools I can get from idea to (shitty) proof-of-concept solution really fast. Then I can start dogfooding it and improve and rewrite.
But sometimes the shitty solution is enough for my purposes. It works and doesn't actively break shit. My problem was solved and I don't need to optimise the silly TUI yt-dlp wrapper it just made me.
It may be, that all of those are OK in your scenario or use case.
Bloggers have been kidding themselves for decades about how invigorating programming is, how intellectually demanding it is, how high the IQ demands are, like they're Max von Sydow playing chess with Death on the beach every time they write another fucking unit test. Guess what: a lot of the work programmers do, maybe even most of it, is rote. It should be automated. Doing it all by hand is part of why software is so unreliable.
You have a limited amount of electrical charge in your brain for doing interesting work every day. If you spend it on the rote stuff, you're not going to have it to do actually interesting algorithmic work.
I'm still trying to figure out the answer to that question for myself. Maybe the answer is, "Probably not, and it probably doesn't matter" but I'm still trying to figure out what kind of downstream effects that may have later on my judgment.
Mental expenditure on programming is also not linear through a task; it takes much more energy to get started than to do the back half. Ever stared at an empty function for a minute trying to come up with the right variable name, or choosing which value to compute first? LLMs are geniuses at just getting things started.
I will maybe spend 5-10 minutes reviewing and refining the code with the help of Claude Code and then the rest of the time I will go for another feature/bugfix.
Case in point recently I was working on a mobile app where I had to check for a whole litany of user permissions and present UI to the user if any particular permission was missing, including instructions on how to rectify it.
Super annoying to do manually, but Claude Code was not only able to exhaustively enumerate all possible combos of missing permissions, but also automatically create the UIs for each edge case. I reviewed all of it for accuracy, which took some time.
I probably would've missed some of the more obscure edge cases on my own.
Overall maybe not much faster than doing it myself, but I'm pretty sure the results were substantially better.
While I was manning a booth, this software developer came up to me and said VS had gotten too good at code generation to automate data access, and we should cut it out because that was the vast majority of what he did. I thought he was joking, but no, he was totally serious.
I said something to him about how those tools were saving him from having to do boring, repetitive work so that he could focus on higher value, more interesting development, instead, but he wasn’t having it.
I think about him quite often, especially these days. I wonder if he’s still programming, and what he thinks about LLMs
On the other hand software development in the high sense, i.e. producing solutions for actual problems that real people have, is certainly intellectually demanding and also something that allows for several standard deviations in skill level. It's fashionable to claim we all have bullshit jobs, but I don't think that's a fair description at all.
Absolutely agreed, but I think the idea is that coding tools (or languages, or libraries, or frameworks) frees us to do the actually hard, skill-intensive bits of this, because the thing that's intellectually demanding isn't marshaling and unmarshaling JSON.
Nobody is paying you to make a CRUD web app in Assembly, they're paying you to solve a problem.
You're not getting any extra points for using plain vi(m) with no autocomplete to write a Java application. Making stuff the hard way is just stupid performative crap.
LLMs are just the next iteration of autocomplete -> intellisense -> language servers.
Now instead of autocompleting a method or property, they can autocomplete full unit tests and functions by looking at the patterns across the codebase.
Most of this work should go away. Much of the rest of it should be achievable by the domain experts themselves at a fraction of the cost.
Instead, it's the opposite.
The LLMs are still generating all that rote shit, that at some point must be maintained and read and understood. Potentially at a higher rate than any human could.
A lot of what AI coders are being praised for could be accomplished just as well with some good Lisp macros with much less technical debt.
You used to have to write tons of real code to stand up something as simple as a backend endpoint. Now a lot of this stuff is literally declarative config files.
Ditto frontends. You used to have to imperative manage all kinds of weird bullshit, but over the last decade we've gradually moved to... declarative, reactive patterns that let the some underlying framework handle the busywork.
We also created... declarative config files to ensure consistent deploys every time. You know, instead of ssh'ing into production machines to install stuff.
We used to handle null pointers, too, and tore our hair out because a single missed check caused your whole process to go poof. Now... it's built into the language and it is physically impossible to pull of a null pointer dereference. Awesome!
We've been "putting ourselves out of work" for going on decades now, getting rid of more boilerplate, more repetitive and error-prone logic, etc etc. We did it with programming languages, libraries, and frameworks. All in the service of focusing on the bits we actually care about and that matter to us.
This is only the latest in a long line of things software engineers did to put themselves out of work. The method of doing it is very new, the ends are not. And like every other thing that came before it, I highly doubt this one will actually succeed in putting us out of work.
1. He is using computers to solve other peoples problems, and they are similar problems so all the code looks the same, and
2. He is NOT using computers to solve his own problems. Every top notch software engineer I've met does not write the same code more than a few times, because doing repetitive stuff is something a computer should be doing.
On a board that would deride any other no true Scotsman take, this one happens on every ai discussion.
It’s no longer worth engaging with. I’m now just posting basic statements like “I’ve been programming professionally for 25 years and I find ai to be extremely helpful”. That way there is at least someone claiming the opposite. But you aren’t going to convince anyone as they already shut that door with their statements.
The bit that triggered my response is this:
> Guess what: a lot of the work programmers do, maybe even most of it, is rote.
Yes, I know a lot of programmers who do that. In fact it seems most programmers I see in the industry do that. Many of them are very good at it, in the sense that a good brick layer will be content to devote his lifetime to laying bricks in a straight line and will be far more reliable and conscientious at it than I could every be. However, that personality type is unlikely to become a top engineer or architect. To be good at those jobs you need to get bored in a couple of years at most. You have to be internally driven to try new things, and experiment with new ideas.
When such a person is confronted with the prospect of a lifetime of churning out code that almost follows a template (and I daresay could easily be produced by today's LLM's) he doesn't sit still and do it. He finds something more interesting to do. Since he's a computer programmer and the task is well suited a computer doing it, he probably take up a skunk works project of churning out the repetitive parts of that code, so he didn't have to do it. It's far more fun, saves time in the long run, and if he is a good software engineer in the long run the systems it produces will be more reliable, and use less code than something programmer code have produced by churning out the same stuff every day for years.
Going by the OP's comment, he hasn't done that, despite apparently being bored shitless with what he does do. There is a solution, but it isn't the LLM's he suggests. All using LLM's change is the language are giving to the "compiler". The end result is still him creating the same CRUD app using the same platforms, libraries and tools his is using now.
But more importantly, by dismissing the comment that way, you’ve made an implicit claim. You are claiming to be able to judge a persons capability or the challenges they are working on off of a couple hn comments. Thats bad engineering and anti-social behavior.
Imagine telling someone that learning to touch type was the sign of a bad software engineer because you don’t type that much because your libraries are all named with single letters. Thats what these arguments sound like to me.
Somewhat true. But it did make me smile, because it reads very much like the pot telling kettle he's black.
But only somewhat. @tptacek also said this:
> Bloggers have been kidding themselves for decades about how invigorating programming is, how intellectually demanding it is, how high the IQ demands are, like they're Max von Sydow playing chess with Death on the beach every time they write another fucking unit test. Guess what: a lot of the work programmers do, maybe even most of it, is rote. It should be automated. Doing it all by hand is part of why software is so unreliable.
Seriously?
As I said, I've been programmer for decades now. He's coming from the perspective that the code dribbling off my fingertips without too much thought is "programming". It is, of course, in the same sense that the brush strokes of Van Gogh are what constitutes "painting". But the painting created by Van Gogh consisted of thousands if not millions brush strokes, all placed with precision, purpose and a great deal of thought. If placing the loaded brush on canvas is all there was to painting, all our houses would be adorned with Van Gogh's. He says we should all be using LLM's, but the idea that brush strokes placed by an LLM would produce same outcome is laughable. You might well use a painting LLM to paint 1000's of houses, but never a single Van Gogh.
To the people who delight in creating new and unique computer systems from code, the puzzle to be solved is arranging the code in just the right way to create their personal Van Gogh's. An immutable object here, a touch of recursion there, combined with an atomic compare and swap and in some truly heroic cases an FPGA thrown into the mix to get some extreme parallelism - crafting these in just the right mix is the challenge of programming. Overcoming that challenge is what makes it invigorating. Not writing the "fucking unit tests" as tptacek puts it, which is almost universally disliked. Although now I look back on it, it is almost therapeutic - it's like going for a jog; it's downtime, when you get review what you've done, and ponder your next moves while pounding the keyboard.
It's a shame, and somewhat insulting to see tptacek treat these efforts many find enjoyable with so much derision. But I've spared with tptacek here, when said similar things before. Again, he confidently said something completely wrong headed, and I could not let it go. Some things don't change I guess. As a fellow at a Linux meetup said to me a long time ago, "you wrote all those words because someone was wrong on the internet???".
The feedback loop of "maybe the next time it'll be right" turned into a few hundred queries resulting in finding the LLM's attempts were a ~20 node cycle of things it tried and didn't work, and now you're out a couple dollars and hours of engineering time.
So slow, untested, and likely buggy, especially as the inputs become less well-conditioned?
If this was a jr dev writing code I’d ask why they didn’t use <insert language-relevant LAPACK equivalent>.
Neither llm outcome seems very ideal to me, tbh.
TDD (and exhaustive unit tests in general) are a good idea with LLMs anyway. Just either tell it not to touch test, or in Claude's case you can use Hooks to _actually_ prevent it from editing any test file.
Then shove it at the problem and it'll iterate a solution until the tests pass. It's like the Excel formula solver, but for code :D
There are limitations at the moment, and I don't see many people disputing that, but it must be doing something right, and its abilities are improving every day. It's learning.
Sometimes I get the feeling a lot of antis painted themselves into a corner early on, and will die on this hill despite constant improvements in the technology.
I have seen similar things many times in my career. There was a time when everyone were very skeptical of high level languages, writing everything in assembler come hell or high water, for example.
At some point it is going to single shot an entire OS or refactor a multi-million line codebase. Will that be enough to convince you?
From my perspective I like to be prepared, so I'm doing what I have always done.. understand and gain experience with these new tools. I much prefer that than missing the boat.
And, it's quite fun and better than you might imagine as long as you put a bit of effort in.
The same you that thinks has proved P = NP with ChatGPT?
Or you could use existing linear algebra libraries which are highly optimized, highly tested, and have a well-understood api that’s easier to review.
And then get back to the legit hard stuff, like maybe worrying if your linear solver needs preconditioning and how to best to that. Or any of the many numerical problems people tend to face when doing this kind of work.
I’m not sure why you’d give the llm a pass on reinventing the wheel here when you definitely wouldn’t with any other dev.
It's such a great tool for learning, double checking your work, figuring out syntax or console commands, writing one-off bash scripts etc.
I wonder if some of the disconnect between the AI coding fans and skeptics is just the language they're writing.
Considering the state of today's social media landscape and people's relationship to it, this fills me with dread.
Hopefully it doesn't take 2 decades of AI usage to have that conversation tho.
I'm not sure if this is supposed to be ironic but it gave me a good chuckle nonetheless.
There's also a lot of talk about drinking more moderately down at my local bar.
Fwiw I'm seeing a lot of people on social media talking about drinking less too. So I had to unfollow them.
If there's anything I've learned about software, "intelligent" usually means "we've thrown a lot of intelligent people at the problem, and made the solution even more complicated".
Machine learning is not software, but probably should be approached as such. It's a program that takes some input and transforms it into some output. But I suppose if society really cared about physical or mental health, we wouldn't have had cigarettes or slot machines.
When thinking through a claim of what AI can do, you can do the same. “AI” -> “just some guy”. If that doesn’t feel fair, try “AI” -> “some well-read, eager-to-please intern”.
Sure let's call the AI names, behind its back and to its face if we're feeling particularly bold, but is that actually going to amount to anything?
Your comment doesn’t add much. Where’s the substance to your critique?
If you're asking whether we can collectively stop upvoting such headlines, the answer is probably no.
Nothing more satisfying to me than thinking about nifty algorithms, how to wring out every last drop of performance from a system, or more recently train AI models or build agentic systems. From object models to back end, graphics to communications protocols, I love it all.
But that said, I am getting on a bit now and don't particularly enjoy all the typing. When AI rolled around back in 2022 I threw myself into seeing how far I could push it. Copy pasting code back and forth between the chat window and the editor. It was a very interesting experience that felt fresh, even if the results were not amazing.
Now I am a hundred percent using Claude Code with a mixture of other models in the mix. It's amazing.
Yesterday I worked with CC on a CLAP plugin for Bitwig written in C and C++. It did really well - with buffer management, worker threads and proper lock-free data structures and synchronization. It even hand rolled its own WebSocket client! I was totally blown away.
Sure, it needs some encouragement and help here and there, and having a lot of experience for this kind of stuff is important right now for success, but I can definitely see it won't be that way for much longer.
I'm just so happy I can finally get round to all these projects I have had on the back burner all these years.
The productivity is incredible, and things mostly just work. It really brings me a lot of joy and makes me happy.
My usage of Claude Code sounds different to a lot of ways I hear people using it. I write medium detail task breakdowns with strict requirements and then get Claude to refine them. I review every single line of code methodically, attempting to catch every instance Claude missed a custom rule. I frequently need to fix up broken implementations, or propose complete refactors.
It is a totally different experience to any other dev experience I have had previously. Despite the effort that I have to put in, it gets the job done. A lot of the code written is better than equivalent code from junior engineers I have worked with in the past (or at worst, no worse).
It proceeded to invent all the SQL fluff rules. And the ones that were actual rules were useless for the actual format that I wanted. I get it, SQLFluff rules are really confusing, but that's why I asked for help. I know how to code python I don't need AI to write code that then I will need to review
It's not different from most people. Everyone runs into AI bullshit. However, hype and new tech optimism overrides everything.
You won't need to set up this stuff for an hour every time, you set it up once and then you just give it commands.
The skill ceiling is deceptive, it feels very low at first (after all, it's just natural language, right?) but getting an intuition for where these tools work best and where they break down, how to task them, what to include in the instructions, it takes a bit of using them first.
That said, if you're a code maximalist, if you get most enjoyment out of hand crafting code or of you don't feel comfortable communicating effectively or delegating work, then maybe these tools aren't for you.
At this point in time I'm also pretty much over proselytizing anyone, I get a TON of value out of this stuff, but everbody has to find their own workflows.
There aren't. Every new "one true way of doing it" that changes every few days runs into these problems.
That is beside the point of the original comment
> We solve problems and new problems appear, which we also solve.
In AI space these are not new problems. These are the same "let's try this new magic incantation agains a non-deterministic black box".
Yup, you're the one using perfect tooling that never produces any issues, or erroneous output, and is perfect in every way.
Unlike these idiot opponents of yours who don't have the intelligence and skill to use these amazing magical tools.
Or, perhaps, your opponents actually use these tools daily and actually understand what they can and can't do?
Keep your head in the sand though.
You heavily imply it in every comment you write. You've literally started debating my comment where I say that everyone runs into AI bullshit. You literally keep debating me when I point out that despite all the progress AI bullshit remains.
Your literal answer to "It's not different from most people. Everyone runs into AI bullshit." was literally "Or, you know, there are different ways of using these tools."
> Nothing in the world is perfect, but there is absolutely useful stuff to be had.
Says the person claiming I put words in his mouth or projecting my fallacies. Where exactly did I say this stuff wasn't useful? Literally nowehere.
> Keep your head in the sand though
Someone recently told me: "Don't put words in my mouth or project your own fallacies. "
Adieu.
It might be hard to tune it though so that AI won't claim that it doesn't know something when it does, by error, or just because it doesn't like you.
It's not uncommon for a student to say they don't know something they actually do when they are questioned.
It's a statistical prediction machine and it says your library should have a do_foo function. Is there a reason why it doesn't have one?
I also compare "AI" to using a Ouija Board. It's not meant for getting real answers or truth. The game is to select the next letter in a word to create a sequence of words. It's an entertainment prop, and LLMs should be treated similarly.
I have also compared "Artificial Intelligence" to artificial flavors. Beaver anus is used as artificial vanilla flavoring (that is a real thing that happens), and "AI"/LLMs are the digital equivalent. Real vanilla tastes so much better, even if it is more expensive. I have no doubt that code written by real humans works much better than AI slop code. Having tried the various "AI" coding assistants, and I am not at all impressed with what it creates. Half the time if I ask for "vanilla", it will tell me "banana".
I have delivered many pet projects I always wanted to build and now focus in the operation of them.
no moment in my coding life has been this productive and enlightening. pretty often I sit down to read how the ai solved the issue and learn new techniques and tools.
studying a paper, discussing it with Opus, back and forth, taking notes, make Opus check my notes. it improved a lot my studying sessions too.
I respect the different experiences each of us get from this. for fairness I share mine
I have very similar experiences, but very often I wonder if I couldn't just have gone to an open source project on the same topic (e.g. building a toy parser) and read the source code there, instead of letting a code generator AI reproduce it for me. Because that happy feeling is very similar to early moments in my developer career, when I read through open source standard libraries and learned a lot from it.
We probably have different personalities but the former is the only part I care about. It’s the operation that bores me.
I'm probably capable of building all of them by hand, but with a 6yo I'd have never had the time. He loves the games, his mental arithmetic has come on amazingly now he does it 'for fun'.
All code is here: https://github.com/rupertlinacre
Much of this built out of a frustration that most maths resources online are trying to sell you something, full of ads, or poor quality. Just a simple zoomable numberline is hard to find
[^1]: to be clear, nothing in the frontend is copyrighted. I use some copyrighted works to figure out how common various words are, which I need because I wanted the app to teach the most common words first.
Edit: the site uses the FileSystemWritableFileStream API, so Safari/iOS users will need Safari 26.
To avoid heated discussions, allow me to illustrate the concept with why enterprise software is mainly built with Java, whereas most blog posts are about writing backends with TypeScript, Python, or Rust. The reason for this is at least twofold:
1. Professional programmers don't get paid to write blog posts, and typically want to spend their free time doing other things. Hobbyists do have the time, but they typically do not see the added value of a boring language such as Java, because they don't work in teams.
2. When something is already known, it is boring for people to read about, and therefore less interesting to write about. When something is new, many people write about it, but it's hard to tell who is right and who is wrong.
Given that good writing, and the additional marketing to find the respective audience, take energy, it is not strange that we find weirdly biased opinions when reading blog posts and forums on the internet. I typically find it better to discuss matters with people I know and trust, or to experiment a bit by myself.
The same might happen now with reporting on AI assisted coding.
Edit: might as well just have said "visibility bias" and "novelty bias" if I had consulted an LLM before commenting.
3. Python has a very fast feedback loop. You type, run and see the result immediately. This is great for small projects and prototypes. Java needs much more work, not just for the compiling but it also needs more boilerplate. This is fine for enterprise projects which typically are very large and prefer stability over speed of development. But at home I don't have the time or the patience for that.
Pharo is an alternative but documentation and libraries just aren't as good, and maybe never will be.
But I don't think the code matters as much as the intention. The comment is all about exploration and learning. If you treat your LLM like a Wikipedia dive, you will come out the other end with newfound knowledge. If you only want it to achieve a discrete goal, it may or may not do so, but you will have no way to know which.
Tabu search guided graph layout:
https://bsky.app/profile/micahscopes.bsky.social/post/3luh4s...
https://bsky.app/profile/micahscopes.bsky.social/post/3luh4d...
Fast Gaussian blue noise with wgpu:
https://bsky.app/profile/micahscopes.bsky.social/post/3ls3bz...
In both these examples, I leaned on Claude to set up the boilerplate, the GUI, etc, which gave me more mental budget for playing with the challenging aspects of the problem. For example, the tabu graph layout is inspired by several papers, but I was able to iterate really quickly with claude on new ideas from my own creative imagination with the problem. A few of them actually turned out really well.
Sometimes I'll admit that I do treat Claude like a slot machine, just shooting for luck. But in the end that's more trouble than it's worth.
The most fruitful approach is to maintain a solid understanding of what's happening and guide it the whole way. Ask it to prove that it's doing what it says it's doing by writing tests and using debug statements. Channel it toward double checking its own work. Challenge it.
Another thing that worked really well the other day was to use Claude to rewrite some old JavaScript libraries I hand wrote a few years ago in rust. Those kinds of things aren't slot machine problems. Claude code nails that kind of thing consistently.
Ah, one more huge success with code: https://github.com/micahscopes/radix_immutable
I took an existing MIT licensed prefix tree crate and had Claude+Gemini rewrite it to support immutable quickly comparable views. In about one day's work. I scoured the prefix tree libraries available in rust, as well as the various existing immutable collections libraries and found that nothing like this existed. This implementation has decently comprehensive tests and benchmarks.
One more I'll share, an embarrassing failure: https://github.com/micahscopes/splice-weaver-mcp
I used vibe kanban like a slot machine and ended up with a messy MCP server that doesn't really do anything useful that I can tell. Mostly because I didn't have a clear vision when I went into it.
I'll now go through this, remove the excessive comments and flowery language, add more tests, put it through its paces. But it did me a service by getting the pieces in place to start.
And I'm even above the 250 karma threshold!
Sure we can segment this into code generation models and code review models but are engineers really going to want to be questioned by a code review tool on "what are you trying to do?" or are they just going to merge and pull the slot lever again?
What I've learned so far is that AI is only as good as the average developer who writes code and is only as effective as the codebase is approachable... unless you let the AI contribute to the architecture at the ground floor it will get just as confused and write just as much spaghetti code as a human coder will.
Like other professions before us... this is a moment where software engineers must adapt or perish. It was a battle to overcome the stubborn mindset of being unchanged in my ways (and adopt AI)... but the writing is on the wall. And now I'm building and refining the very same AI tools that do the jobs of data analysts and software engineers.
That's why developers are poorly paid and viewed as disposable cogs. It feels "easy" to many people and so they internally think it is immoral to get paid and corporations ruthlessly prey on that feeling. Reality is that development is hard and requires immense mental work, constant upskilling and is not something you can switch off after 5pm and think of something else. Your brain is constantly at work. That work also is creating millions and billions that gets extracted from developers and flow to the greedy hands of the rich, who now control all the means of production (think of cloud services, regulation - try starting your own forum today, anything with user generated content etc.).
Developer did themselves dirty.
Developers went from garage-tinkerers to the backbone of the modern economy - and somehow ended up as overworked, disposable employees in open-plan office farms. The owners changed, the IDEs got fancier, but the deal stayed the same: build the machine, never own it.
You upskill constantly just to not fall behind. You work nights “for the launch.” You get gaslit into thinking stock options in a private company are equity. Then you’re laid off via email - while the founders post yacht selfies.
And the worst part? Most of you still believe you’re lucky. That’s the grift: teach engineers to think they’re “not like other workers” - then extract surplus value just like any other industry has done since the 19th century.
Developers are poorly paid - not because the salary is low, but because the upside is stolen. You created the wealth, they captured it.
If you prompt it correctly and rigidly, and review everything it does large or small, it's a 10x tool for grinding through some very hard problems very quickly.
But it can very easily lead you into overconfidence and bloat. And it can "cheat" without you even realizing it.
Claude Code is best used as an augmentation, not automation tool. And it's best that the tool makers and investors realize that and stop pretending they're going to replace programmers with things like this.
They only work well when combined with a skilled programmer who can properly direct and sift through the results. What they do allow is the ability to focus on higher level thinking and problems and let the tool help you get there.
I completely agree when using synchronous tools like Windsurf and Cursor. This is why I much prefer the async workflow most of the time. Here you get a chance to think about how the AI should be constrained in order to have the highest probability of a "one shot" PR or at least something that would only require a few edits. I spend a lot of time on the AGENTS.md file and as well as thinking a lot about the prompt that I am going to use. I sometime converse with ChatGPT a little on the prompt as the feedback loop is very fast. Then, just send it and wait ~5 minutes for completion.
I still use synchronous tools sometime for UI and other things were it is hard to specify up front and iteration is required. But realistically, I use async 50:1 over sync.
Which will be the case is the interesting question.
No. They would become extremely useful and more magical. Because instead of weird incantations and shamanic rituals of "just one more .rules file, bro, I swear" you could create useful reproducible working tools.
The interesting thing is going to be how this all holds up in a year or five. I suspect it's going to be a lot of rewriting the same old shit with LLMs again and again because the software they've already made is unmaintainable.
I didn't get into software to labour like a factory worker day in, day out. I like to solve problems and see them deliver value over years and even decades, like an engineer.
I guess you could use them like that, but you'll do much better if you try to get an understanding of the problem beforehand. This way you can divide the problem into subtasks with reasonably clear description, that Claude will be able to handle without getting lost and without needing too many corrections.
Also, you'll still need to understand pretty much every task that Claude has implemented. It frequently makes mistakes or does things in a suboptimal way.
When you use AI properly it's a great tool, it's like an IDE on steroids. But it won't take away the need to use your brains.
I've seen little organic praise from high profile programmers. There aren't many, and once you search they all at least work on a commercial "AI" application.
You could argue, he makes money off of AI with his newsletter and whatnot, so he does stand to gain something, but it's a lot less than the executives and investors who've filled the news.
[1] https://simonwillison.net/ [2] https://en.wikipedia.org/wiki/Django_(web_framework)
But it is amazing how many people really are playing it like a slot machine and hoping for the best.
That's just people and as always some will better utilise new tech than others. On aggregate I think everyone still wins
When it’s wrong, what do you do? Pull the lever.
The answer to this is nuanced. You can summon ~30k LoC codebases using CC without much fanfare. Will it work? Maybe, in some of the ways you were thinking -- it will be a simulacrum of the thing you had in your mind.
If something is not working, you need to know the precise language to direct CC (and _if you know this language_, you can use CC like a chisel). If you don't know this language, you're stuck -- but you'd also be stuck if you were writing the thing _by hand_.
In contrast to _writing the thing by hand_, you can ask CC to explain what's going on. What systems are involved here, is there a single source of truth, explain the pipeline to me ...
It's not black and white in the way I experienced this paragraph. The "details" you need to know vary across a broad spectrum, and excellent wizards can navigate throughout the spectrum, and know the meta-strategies to use CC (or whatever agentic system) to unstick themselves in the parts of the spectrum they don't know.
(lots of that latter skill set correlate with being a good programmer in the first place)
Many of my colleagues who haven't used CC as much seem to get stuck in a "one track" frame of mind about what it can and cannot do -- without realizing that they don't know the meta-strategies ... or that they're describing just one particular workflow. It's a programmable programming tool, don't put it into a box.
I compared vibe coding to gambling in one of my recent blog posts and thought that metaphor was slightly uncharitable, but I didn't expect "slot machine" to actually now be the term of art.
With vibe coding, I suspect this is a group that has adapted to it really well (alongside hobby coders and non coders). The thrill comes from problem solving, and when you can try out the solution quickly and validate, it is just addictive. The other side is how open source frameworks have increased, and there are a lot of oss libraries for just about everything. (A personal experience is implementing Cmd bar (like linear) in react when i was just learning. It took me a week or so, and then i just inserted an oss thing for comparison. It was super smooth, but i did not know the assumptions. In production, i will prefer that, and dont always have time to learn and implement from scratch). We see this with langchain etc in LLMs too, and other agentic frameworks as well. The shift is not towards less code but getting the thing to work faster. Claude code accelerates that exponentially as well.
It's why we get so addicted to gambling. We're built for it because a lot of legitimate real things look like gambling.
You still have to really guide the AI, none of this is automatic. Yet I no longer feel the mega joys I once felt hand building something and watching it work correctly. The thrill is gone! Don't know if this is good or bad yet. I don't miss the plumbing bullshit. I do miss the joy.
I don't think that's true. I'm wondering if the author has tried Claude 4 Opus.
* How 'bout I deploy my "digital twin" to attend the meetings for me. That'll show 'em!
You cannot write everything using LLMs, you cannot maintain hodgepodge LLM codebases, but also you might want a break from writing scaffolding code or simple functions.
There’s a reason intermittent rewards are so intoxicating to naturally evolved brains: exploiting systems that give intermittent rewards is a great resource acquisition strategy.