I found that when I used ChatGPT's web chat, I frequently went back and forth, shuttling its output to an editor or IDE and then coming back to ChatGPT with "oh, now it fails like this: ...". It made me feel like I was the automaton now.
Claude Code was transformative and it made me realize that something very incredibly significant had occurred. Letting the LLM "drive" like this was inevitable. Now I see just exactly how this will transform our industry. I'm a little scared about how it will end for me/us, but excited for now.
I've found that "back and forth" is part of the learning aspect LLM's provide. Even when the LLM provides code snippets, I type them out myself, which I've found forces me to think and understand them - often finding flaws and poor assumptions along the way.
Letting an LLM drive in an agentic flow removes you from the equation. Maybe that's what some want - but I've personally found I end up with something that doesn't feel like I wrote it.
It's correct, you didn't write it. Do you also avoid using frameworks and libraries for desire of feeling like you wrote the program you produced? You must have another reason to not want to use this code.
When you use frameworks or libraries, you are trusting (hoping) the author(s) spent the time to get it right. At a minimum, the framework/library is documented in literal documentation and/or code that's static and can be read and understood by you. Ask an LLM to do a task 3 times, you'll get 3 different outputs - they're non-deterministic.
I catch a lot of nonsensical and inefficient code when I have that "back and forth" described above - particularly when it comes to architectural decisions. An agent producing hundreds or thousands of lines of code, and making architectural decisions all in one-go will mean catching those problems will be vastly more challenging or impossible.
I've also found reviewing LLM generated code to be much more difficult and grueling than reviewing my own or another human's code. It's just a mental/brain drain. I've wasted so many hours wondering if I'm just dumb and missing something or not-understanding some code - only to later realize the LLM was on the fritz. Having little or no previous context to understand the code creates a "standing at the foot of Mt. Everest" feeling constantly, over and over.
>I've also found reviewing LLM generated code to be much more difficult and grueling than reviewing my own or another human's code.
absolute opposite here.
LLMs , for better or worse, generally stick to paradigms if they have the codebase in front of them to read.
This is rarely the case when dealing with an amateur's code.
Amateurs write functional-ish code. TDD-ish tests. If the language they're using supports it types will be spotty or inconsistent. Variable naming schemes will change with the current trend when the author wrote that snippet ; and whatever format they want to use that day will use randomized vocabulary with lots of non-speak like 'value', or 'entry' in ambiguous roles.
LLMs write gibberish all day, BUT will generally abide by style documents fairly well. Humams... don't.
These things evolve as the codebase matures, obviously, but that's because it was polished into something good. LLMs can't reason well and their logic sometimes sucks, but if the AGENTS.md says that all variables shall be cat breeds -- damnit that's what it'll do (to a fault).
but my point : real logic and reasoning problems become easier to spot when you're not correcting stupid things all day. it's essentially always about knowing how to use the model and whatever platform it's jumping from. Don't give it the keys to create the logical foundation of the code, use it to polish brass.
False equivalency. The maintenance and expertise required to run the codebase you’ve generated still falls flatly on you. When you use a library or a framework it normally is domain experts that do that stuff.
I’m so glad we’ve got domain experts to write those tricky things like left-pad for us.
On a more serious note, I do think that the maintenance aspect is a differentiator, and that if it’s something that you end up committing to your codebase then ownership and accountability falls to you. Externally sourced libraries and frameworks ultimately have different owners.
I'm reminded of the recent "vibe coded" OCaml fiasco[1].
In particular, the PR author's response to this question:
> Here's my question: why did the files that you submitted name Mark Shinwell as the author?
> > Beats me. AI decided to do so and I didn't question it.
The same author submitted a similar PR to Julia as well. Both were closed in-part due to the significant maintenance burden these entirely LLM-written PR's would create.
> This humongous amount of code is hard to review, and very lightly tested. (You are only testing that basic functionality works.) Inevitably the code will be full of problems, and we (the maintainers of the compiler) will have to pay the cost of fixing them. But maintaining large pieces of plausible-in-general-but-weird-in-the-details code is a large burden.
Setting aside the significant volume of code being committed at once (13K+ lines in the OCaml example), the maintainers would have to review code even the PR author didn't review - and would likely fall into the same trap many of us have found ourselves in while reviewing LLM-generated code... "Am I an idiot or is this code broken? I must be missing something obvious..." (followed by wasted time and effort).
The PR author even admitted they know little about compilers - making them unqualified to review the LLM-generated code.
Not only that but I find ChatGPT (and LLMs in general) a great partner to discuss my existing ideas with, with the general idea of getting it to challenge me on my decisions and provide ideas that I can shoot down (or make me think "actually...that could work".
I think LLMs are much more effective when you have a good understanding of a field and can work in the above way; their assistance is useful because I don't have time or brainpower to be an _expert_ in many of the fields I'm _knowledgable_ in.
I've been doing this forever, but just a few days ago I tried connecting VS Code to Github Copilot. The experience wasn't entirely unpleasant. I'm still on a familiar IDE and fall back to traditional development patterns whenever I want, while relying on Copilot to make targeted changes that I would find too simple and tedious to manually do.
Try Cursor Composer! It's the most natural transition. Exactly what you're currently doing, but it inserts the code snippets for you from within your IDE.
As someone who's about to quit to go work on their startup, glad to know things are gonna be terrible if everything goes to shit and I need to return to the job market.
I see these reports as statistics. “54% Americans have zero retirement savings” doesn’t mean that I should expect a 50% chance my savings will magically disappear when I retire.
You have to be careful with statistics, and news in general. Remember that your life is your own, with a unique set of circumstances, and think for yourself.
IDK, your average boss is just a dude who has bills to pay and mouths to feed. They don't really care what happens as long as you're not doing something stupid, especially visibly and on their time.
The bold and highlighting all over the place is really annoying. I get why it’s formatted that way but it’s a bit too much information and I find it hard to focus.
> "Here's my CV, but actually all my work will be done by AI".
What AI did you use? Because we want to hire that, not you.
If AI exceeds human capabilities, it won't because it achieved "superintelligence," it will because it caused human abilities to degrade until the AI looks good in comparison.
I'm considering this idea currently because ATM all the Pink Floyd albums on streaming platforms have names describing the image instead of the original artwork (I assume for the WYWH anniversary.) What it reminded me was that we don't own anything they host so I look forward to exploring this as well.
I think there’s more difference than there has been since the 1980s. People really underestimate how far the Tory base (and parliamentary party following closely) have shifted to the right. The willingness of sitting Tory MPs to knowingly lie and dissemble on immigration related issues to create heat is a real break from a past consensus.
Current opinion polls for both are abysmal, but I don't think that civic freedoms are the main reason; the main reason is immigration, which all the previous governments promised to limit and then silently decided not to.
Immigration is sucking support more from the tories than labour. They rode into power based upon a promise to do something about it and then massively increased it.
Labour are recently leaning into being anti immigration because it's one of the few wealthy-donor-friendly policies they can pursue which will potentially gain them votes.
Decided not to, but continued to actively campaign on. It’s created a really weird situation where the actual policy choices are hugely disconnected from the rhetoric and emotion in the debate.
Legal immigration from South Asia dominates illegal immigration by an order of magnitude, but nobody wants to lose seats in Birmingham, so essentially doesn’t figure in the arguments about small numbers of afghans in miserable hotels in Essex.
For the Conservatives it's all about irregular/illegal immigration. Labour are hugely unpopular on that having apparently no idea what to do about it but they also have massive challenges on the economy/cost of living and the state of publicly funded services.
reply