Post

At the risk of starting the flame war to end all flame wars... Modern LLMs (GPT-5.1, Claude 4.5, Gemini 3) produce excellent code and can be a significant productivity boost to software engineers who take the time to learn how to effectively apply them - especially if used with coding agent tools

74 reposts770 likes

Using agent tools and learning them has been so much fun! Here's a personal tool I started 3 weeks ago and deployed last night: github.com/psumiya/option-insights I coupled Spec Driven Dev w/ Vibing for specific tasks using #Kiro + Claude 4.5. Sessions paired with Grimm episodes post-bedtime.

github.comGitHub - psumiya/option-insights: Your personal options trading insights dashboard.Your personal options trading insights dashboard. Contribute to psumiya/option-insights development by creating an account on GitHub.

Quick prompting and incomplete planning has almost always been the underlying issue when I see these things fail. Sonnet 4.5 alone is good enough for 90% of coding requirements, IMO. The last 10% requires a top model like Opus 4.5 + careful, knowledgeable human expert + multi-step planning.

I want it on record that I went viral defending you

conputer dipshit@davidcrespo.bsky.social

this is a bluesky bubble opinion. 800M+ people use chatgpt every week. I hate Facebook and Instagram and I wish they didn’t exist, but 3B and 2B people use them every month, respectively. it’s very hard to picture a mass or even a niche left backlash against them

Yeah that was a bold move of you! I actually wanted to quote it and write my thoughts but she's a huge account and it feels like being a trans person that finds utility in LLMs makes you a class traitor or something.

The Claude Max subscriptions are incredible value. I’m currently on Droids 200$ plan, I am unsure how far into the month I’ll get before I run out; but I reckon I’ll get quite far!

I am surprised people still try to deny this. in a few niche fields/applications it can be not great (as karpathy has mentioned; he likes it for web apps, not so much building language models) but overall it is obviously a huge productivity boost for most programmers willing to use it properly

Take a look at the quote tweets on this one - though that crowd have likely blocked me by now so they probably won't see this bsky.app/profile/simo... Here's my vibe coded quote tweet display tool for that post tools.simonwillison.net/bluesky-quot...

tools.simonwillison.netBluesky Quote Finder
Simon Willison@simonwillison.net

I think that may be the core division here: if you are an author or an artist the cons of generative AI very likely outweigh the pros for you If you are a software developer the opposite is true

Dunno man recently worked with a guy who gave this the old college try, senior US SWE with career in NASDAQ listed tech, went nuclear with big prompts and design docs etc, python code for a simple CLI, resulting code quality was really not so good.

Recently = 4 months ago btw. I think it can be very useful for some "quantity over quality" tasks, e.g. I need to parse these 26 different formats of stuff or scrape these 50 different websites, whete you can basically give it a template a battery of tests and let it ride

on a small scale, yes, they generally produce good code, but the more agent tools you use, the further you lean towards vibe coding, which still produces terrible code *bases*. the architecture is generally quite bad and they tend to redundantly reimplement the same thing in many different ways

People have been cutting-and-pasting sample code into their own for decades. AI agentic (vibe) coding makes this process a bit more efficient. Many program to create novel, unique capabilities and I wouldn't trust hand-me-down code with that.

You can get novel code from LLMs if you treat them as typing assistants and spell out to them exactly what they should write At that point it's like pair programming with a colleague who is much faster at typing than you and has imperfectly memorized more of the library documentation

I just started playing with PyCharm and noticed it guessing and suggesting code. Trying to find out why people are losing their shit over Python. I'm thinking it's really the libraries rather than the language per se.

You'll find that copyright & IP issues are an unexpectedly major obstacle to general corporate adoption, as content generated by LLMs can't be copyrighted, while inventions created by LLMs can't be patented. To be sure, the law will change, but it hasn't yet.

I feel like the most useful part of vibe coding with LLMs/agents is using them to craft small bespoke tools that can help your productivity in general. (like, format all this data, click all these buttons, etc.) It reduces side wild goose chases and saves a lot of time

I’m seeing decent code maybe 70-80% of time if a sufficiently detailed spec is written & the output is carefully checked - there are often subtle bugs and lack of coverage in the test suite. So it’s hard to move quickly as each step has to be vetted - you can’t just iterate on each LLM output.

This only works well for experienced devs who can spot the 20-30% of defective outputs that the models produce. There’s also substantial difference between code quality in different languages. It’s best at greenfield python. Ask it to convert C into Java & the results are much less obviously good.

Thanks for doing this, Simon. And kudos on helping to maintain a civilized conversation around this. I had opus 4.5 generate an svg based dancing turkey the night of TG - thought about your pelican on a bike eval as I was doing that

I had a problem where an LLM helped me port some R code to C++ (i dont know C++) and got a 15x speedup. I was super careful about reviewing and comprehending the code. that experience, like, makes the benefits pretty undeniable to me.

I still haven't worked out how to get LLMs to avoid adding increasingly more complexity to projects. The projects I tend to want them to work on are like multi threaded C++ projects, so maybe I should just stick to getting them to write little python tools to make my life simpler.

Tooting my corporate horn here, but I’ve found it helpful to use Sonar’s complexity analysis to keep the LLM in check.

I don't have any relevant expertise with multi-threaded C++, I would be surprised to hear they're much less effective at that The most important trick I know is making sure they have a test suite they can run - most of my Claude Code sessions start with me saying "first run the tests like this:"

My experience is that they're quite shit for c++. Test cannot really confirm that you don't get UB in all circumstances due to threading issues so it's difficult to confirm it hasn't created you something that only definitely works for the test cases

Simon Willison@simonwillison.net

DeepSeek-Math-V2 means we now have an open weights (Apache 2) model that can achieve gold medal performance on this year's International Mathematical Olympiad - previously proprietary models from OpenAI and Google DeepMind had achieved that 689GB from Hugging Face! simonwillison.net/2025/Nov/27/...

I asked Google (no quotes): "how good is ai at writing c++ multithread code". Google's reply included limitations like this: "Multithreaded programming [involves]... issues like data races, deadlocks, and race conditions. AI models may struggle to identify and prevent these subtle bugs..."

In theory, I can envision a "code-understanding" system that could prevent race conditions (which are notoriously hard for humans to see). But I'm skeptical we'll see that delivered, in reliable form, any time soon.

I can see how 100000000 working react programs on GitHub can guide LLMs to generate another one, but maintaining all the highly implicit invariants in something like RocksDB when adding an enhancement ? Different worlds.

Hard same! The current gen of LLMs still can't do much abstract reasoning about hidden side effects that aren't concretely obvious in the contract or API spec. Reasoning about race conditions is *hard*, even for the best humans.

How has it gone when you ask the agents to analyze code and find ways to simplify it? I tend to agree they're too fast to just write code and add complexity. I've had a little success at asking them to simplify, but don't feel like I have a large enough sample set yet to make an inference

it works well in specific in my experience and it seems to be getting better in the general, though it's hard to separate user skill, model capacity, and framework improvements in that (my first vibecodes were over-complex trash, but that was probably my fault as much or more than claude's)

I was hoping this thread wouldn't end with another tiny vibe coded tool I'm starting to see the results of people being encouraged to use LLMs, being given complex tickets in established projects, with tech where they clearly don't know how to tell good code/design from bad, and it's not pretty

and finally, you reject the possibility of other ways to fulfill the same "productivity" you mention, because you simply haven't defined "productivity", and you don't know or understand the field of tooling that others have worked in for decades

It was also meant as commentary on how absurd it is that saying "LLMs are good at writing code" really does have the potential to kick off a huge flamewar in November of 2025

I’ve had some moderate success with agentic loops in solo projects, but have a lot more failure in Real Work Projects™️ with lots of contributors and history and tons of hidden context Still useful for sketching solutions or asking questions of the codebase! But far short of a lot of the hype

That's an interesting point. I'm in a 4 person company so, by default, we tend to work in silos so all of my experience (which is good) has been in single-person projects

do you have any advice for people who have just started learning programming and don’t have much experience in software engineering? on one hand, i feel worried that i will become irrelevant if i don’t keep up with the times and ↓

i know that i should learn to apply AI to boost my productivity and employability. on the other hand, as someone who’s very inexperienced, i’m worried that using AI when i’m still at a stage of learning and exploration will render me over-reliant on AI.

i'll echo other advice here: ai is more useful for exploration when you're just beginning ask questions about existing codebases and have it lead you to the evidence be ready to disagree with it socratic dialogue (aka "just asking questions") goes a long way to making sure it's not full of shit

Don't apply AI to boost productivity. Treat it as a learning resource: an infinitely patient buddy willing to explain everything, sometimes getting it wrong. Don't ask for solutions. Ask for options & rationale. Think through what it's saying, challenge it if sounds fishy, drill down. Be curious!

As someone probably in between yourself and the OP, I'd say use it as a learning tool. Treat it as a paired programmer and ask questions. If you don't know what you're doing and blindly let AI run wild, you'll not recognise if it's going off track, or potentially doing something extremely flawed.

It's been so long since I was a beginner that I can't really give credible advice here My guess is that the very fact that you're worried about this puts you in a great position to solve it yourself through thoughtful application of the technology (I use it as a learning tool myself all the time)

its kinda bonkers how many old ideas for software artworks have suddenly become frameworks and mockups of usable software ideas that exceeded my knowledge/skills and could never justify paying someone else to build are becoming real like an automated mark lombardi network narrative generator

The Bluesky dogma is always the same things: - I read it ate all the water and pooped fire (and this is probably true about xAI) - Understanding a topic requires knowing it to the atom. If you use it then it makes you more dumberer - Elon Musk pays me to make you avoid legitimate tech developments

Yup, the graybeards' rage is peak ... decades debugging assembly by candlelight, and now it's 'hey Claude, fix this segfault?' followed by a smug 'works on my machine.' For my semi-serious roast of the whole vibe-coding debate circus: andreklein.net/vibe-coding-...

andreklein.netVibe Coding Is Just Copy-Pasting From StackOverflow With Extra Steps (and a Better UI)Not so long ago, when you hit a weird bug, the ritual was always the same: Google the error message → pray to the old gods → land on a...

Inclined to agree, however, although one certainly *can* argue about this, it’s pretty low stakes. There’s little to be gained from persuading someone that they’re wrong (in either direction.)

Something I genuinely worry about is software developers who fall into the immovably anti-AI camp in a way that is detrimental to their career, when their decision making was strongly informed by belief that it's not actually useful to their craft

I'm absolutely fine with developers knowingly opting out of AI assistance for ethical reasons - and being willing to accept any career implications that might have as the price of staying true to their principles. I admire that! But I want them to have accurate information

I’ve been using cursor for quite awhile and I’m easily 10x productive with it. Just swapped to Claude code and I’m interested in all the advice you might have

Purely as information without any intention of negativity: a substantial portion of software we use daily has code written by an LLM if it's software or a website that's been updated in the past 6 months. Including Bluesky, phone apps, probably the next OS update, insurance and finance companies.

Yep, people know this - there is already a number of "a machine which turns [headline about X% of Microsoft/Amazon code written by AI] into [fatal, hardware-bricking errors]" memes. The idea this adoption is an organic phenomenon everywhere itself contradicts data. pivot-to-ai.com/2025/07/25/1...

pivot-to-ai.com16% of employees pretend to use AI at work to please their bossTech recruiters Howdy surveyed 1,047 full-time professionals who say they use AI. 30% of survey subjects said they were managers. [Howdy] 75% of subjects were expected to use AI at work. 22% felt p…

I was very skeptical of their utility for coding beyond the "fancier autocomplete' provided by early copilot. But the last 9 months or so I challenged myself to be an informed hater and earnestly started using LLMs/agents for more tasks

I have to admit I was wrong. They are useful for coding, and can be a real productivity booster. There's definitely an intuition you need to gain to know when/how to utilise them. I think that initial learning phase sours people. It definitely did for me

This week I built 3 prototypes for a feature, which add 2 new capabilities to a complex system, touching numerous parts of 1m+ LOC repo. Each time I tried a different architecture, improving on the last. I estimate each would have taken > week without an LLM. But I did all 3 in a week!

The initial learning phase was also a whole lot worse just 12 months ago - it took a lot more effort to get useful, productive results out of them prior to the coding agents that could actively execute and fix bugs in their own code

Yeah I had tried a few times. And had very mixed success even in self contained tasks. Now I've managed to wrangle it for valuable product work, versus say the odd bash script or custom ESLint rule (they are valuable too! But they're just ancillary tasks)

the question is more, what do you learn when you use the LLMs ? Sure you boost your short term productivity, but what about long term understanding and productivity ? Personally I need to understand very well the basic to be able to build on top of it.

No issue with using LLMs/AI like this - it's a great code writer and coding fault finder. Also to produce indices and find information across vast sources. Doesn't make it right to take and use copyrighted content for commercial gain without paying for it.

This is a problem because of the old adage: "Debugging is twice as hard as writing the code in the first place." Complex solutions have a much higher maintenance cost which will limit your ability to support the code base. AI just supercharges the ability to generate tech-debt if... you allow it.

claude definitely follows the "make it work, then make it work well" aesthetic you just have to be ready to do the second part, instead of accepting "it's alive" as the stopping point which is true of most code i write too, so it wasn't a real hard transition once i recognized it

only some of, though, because i worked crappy web dev the first half of my career unlike the nephew of the owner of the tv station, i can ask an llm to fix its hideous mistakes and it will, often the first time that nephew i essentially had to follow around with a pooper-scooper (and i quit asap)

what's amazing is the amount of compute power it took to do a simple text transformation.. we will look back on this era of coding and realize how much waste that all the various layers of abstraction are adding to the environment

Yeah, they are missing a trick there I always ask for my artifacts as HTML with inline JavaScript and no React because then I can copy and paste them out and host them elsewhere really easily

Bluesky is generally very much anti-AI. My observation is that comes from the high percentage of folks we engage with who are writers, digital creators, etc. I think your take is correct.

Saying Bluesky is anti-something is like saying Times Square and Tiananmen Square and Tahrir Square are against something. Bluesky contains multitudes, none of which should be taken seriously just on the basis of numbers.

It is still a completely non-controversial opinion which 90% of the people who actually write software and have tried them know The bsky anti-AI brigade is a loud, vocal minority who are primarily artist-adjacent, and are simply not thinking about code generation at all, nor do they care about that

people who write software find them incredibly useful and aren’t worried it’s taking their jobs (interestingly) and some of us are all “you’re prying this out of my cold dead hands, i’m never going back “

A sensible humanities professional should recognise the huge potential of AI and should accept the expert opinion of coders who say it’s hugely powerful. A sensible tech professional should not tell philosophers and artists that an AI is self-conscious and capable of sublime artistic genius.

I'd say it's controversial because posts like this don't explicitly mention the flip-side – that people will be using them without knowing how to affectively apply them, and that is dangerous. I'd guess that you're very aware of these risks but don't feel the need to mention it. Which is fine, ofc

But AI cautious people see so many posts like this, it's easy to get the impression nobody is aware of the harm that AI dev tools are likely to do given mass adoption. So some people shout about it at every opportunity.

I very much agree, but it leaves out all the important details: 1. What does significantly mean in this case. So far the only studies I have been able to find says at most 20%. 2. What are we willing to sacrifice for that productivity boost?

that's broadly fair, yeah, though I wouldn't always apply it for example, for a project I needed to add a feature to make an image have a bouncing DVD logo effect. I simply don't know all the right math to write for that. before LLMs I would've copied something from stackoverflow

We use an “airgapped” system at our startup. I (TPM) vibecode new features instead of writing a spec, and our devs then refactor it (also with agent assistance) into something we can ship. Still an enormous productivity boost; but we assume that vibecode output is more POC grade than prod-grade.

That looks like a very intermediary state of the world. At some point I expect we will just commit the prompt + hash of model, whose output has been proven to work by downstream validation, and only look at the "intermediary assembly" in unusual cases.

Like it's not common to commit the assembly files produced by the C compiler. We commit the .c files – which AI-native engineers endearingly call "Kernighan prompts" – and then look at the assembly only in rare special cases.

Ok I mean it's pretty easy to say this, but rarely can someone actually explain every layer of dependencies underneath the code they CAN explain. Comprehension is always shared across people for complex work.

True, but they're mostly not responsible for those layers. It's basically the same as before LLMs, right? My PR must be human-understood at the usual levels... but it may be mostly LLM written. ...it is quite the quirk, how modern sw dev is a very high % of code review.

That's true, I may be able to reason my way through Python libraries I'm using but once you get down to the cPython interpreter I'm mostly out of my comfort zone, and once you get to the operating system calls or hardware I'm completely lost

As someone in a leadership role in our software engineering organization, this is actually the sticking point for me: there are often perceived or actual (in our case mostly just perceived) incentives to SHIP FAST in ways that very directly undermine the commitment to understanding generated code.

In my experience, how well the tools work is also (a) very context-dependent, not only in the sense of “how much of this is in the distribution?” but also “what kind of work am I doing?” and (b) depends on how comfortable you are with the totally unsurprising tendency to regress toward the mean.

Good point - yeah, I do disagree slightly there I'm OK with code you couldn't have written without AI assistance provided you completely understand it and can explain how it DOES work

And, they’re different in ways that really impact who’s “allowed” to submit code in different situations. I can explain a lot of code that I can’t write, and I can learn what written code is doing far easier than I can learn to write it.

Which is so scary for new grads / college students in CS You need to know what’s going on to be able to use it. We can’t offload thinking, but we can automate a lot of the tedious parts now!

Yeah. I don't know of a tactful way to say this, but we're solidly in "they're undeniably good at some very useful things" territory. I totally understand that some don't want to use them for principled reasons, but it's silly to say they're useless.

I built a badass customer service AI agent app solo and it took me 4 months (admittedly I underestimated by about 2 months) with Claude. Learned so much about where it worked and where it didn’t. From the chat widget to a home grown code generated Zod to pydantic socketio RPC. Easily 10x.

The "excellence" still depends on whether the language is in the training distribution. It's pretty competent at Python and JS. Less so in Clojure. Or HashiCorp Language. Even so I agree that it's still a productivity boost across most languages.

Yes! They can do amazing things, but you cannot use them naïvely (note dieresis) and expect anything good. If you can provide them with invariants, ways to test those invariants, and understand how, eg, context windows impact state management, they're awesome.

You probably get a lot of crap On Here but I enjoy your posts and get a lot out of your work so if you can stomach it, please keep doing what you’re doing.

It's how you can constrain their possibility space, and inject your own judgement into the otherwise mechanical loop. I find them really liberating, honestly, and have used them to generate a bunch of tools that in turn I have the model use.

yeah, I’ve been rolling this around in my head for a while. hopefully will do some work on it in the new year

as a small example, my partner had to do some work the other day on a pdf where there was quite a bit of existing accessibility stuff; the doc needed to be resized to uniform, have links added to the TOC, add a footer, etc.

sat with her for about an hour iterating on the problem in opus 4.5, having it write python to do the modifications. was like $21 in raw token costs. it did great! but it wasn’t as simple as saying “oh do xyz to this pdf”

If I tried to do it by hand it’d probably have been a weekend project? I don’t really know PDF spec that well nor the pdf libraries in Python.

But over time using LLMs costs you your skills to optimise code for your use case, no? Don't get me wrong I was working on a React component, prompted exactly what I wanted in detail and got exactly what I needed. I haven't looked at the generated code. Could it be optimised? Probably butnot by me.

premature optimization is the root of all evil anyway wait until there's a problem worth complaining about, and only then optimize (and trust it'll come quick enough, agents don't have a great sense of optimized code yet)

Wouldn't it become more difficult to go through the code and pinpoint areas to improve if one relies heavily on LLMs? I am not sure about the quotas, but if one is working on a large project, they'd hit their quotas pretty quickly I'd imagine. Then again 100% with you on premature optimization.

no? code i don't know is most of my job (sre), and i've used claude to explore novel codebases much quicker than i could alone refactors are likewise quicker, esp w/ good tests claude code max hasn't hit quotas with me recently, nor have coworkers mentioned it, and we use it pretty extensively

They can be useful for developers who are experts and know what the output should be. They are a hindrance to junior developers and you shouldn't use them if you are learning or you don't know how to evaluate the output.

Which is to say, the opposite is: - exposure to things they may not have otherwise explored - used as an opportunity to learn more and introspect, not just poop out code - opportunity to learn more about the craft through the combination of those two thigns

That's still a big open question for me I've coached a lot of early stage developers and one of the key things I've found is that the first six months are agonizingly frustrating - you miss a semicolon and your code doesn't compile and it takes an hour to figure out why

This can also apply to developers tackling tech they're not familiar with, in complex apps, with LLM usage robbing them of what should have been a chance to learn. This also affects code review as a chance to learn, what do you do with critique of complex code you never understood? Plug it back in

Yeah, I think the most important thing for junior developers to understand is that they shouldn't just trust LLM output and always still try to understand what's going on. But it's great for getting pointers in the right directions, discussing different architecture/implementation options, etc.

It's Thanksgiving here in America, so I'll simply say I'm thankful I can continue to develop software and work with many fine talented people on a variety of projects completely and blessedly LLM-free. ☺️

I think the trick for most people is setting up effective guardrails and knowing how to review code. I've noticed that a lot of devs who say it has no utility tend to be ones where they don't spend a substantial portion of their work day reviewing the code of juniors.

I would say that they are better at writing code that most programmers already, and they know all the languages and all the common libraries and frameworks, it is like having a team of programmers at your command, you just need to know what to program and be good at reading and reviewing code...

Finding code smells and correcting/refactoring/refining the solutions in loop with adding new features is crucial, good practices are more important than ever, but if you already have all that in place you suddenly find that you don't have to write code anymore, just ask for changes and review them.

I always say this, but I actually think the importance of good coding practices and program structure is more important than ever It's going to be critical to be able to comprehend and interpret the models' code, and if they're writing spaghetti that will be impossible (that's my go-to stance tho)

it does a really great job of taking psuedocode and poorly syntaxed shit and turning it functional. it is a huge productivity boost for "i know what i need the thing to do, i know how it should do it, but fuck if i can remember how this language does it" stuff

I am in this boost, I can't quite believe this week - I prepared the data system for 2 years and it's running, but I had only my scripts for ui but now I have a fully functional static website that experts can use to classify images and share those easily. It's doing everything and more

Having credible results also with Rust, C++, Python, R and combinations of those, haven't yet explored those deeply but my prompt is getting better. I ask it to help me brainstorm and often it's just right on it

I let Claude play with playwright. It started to make screenshots of pages for error handling and it got its way around cookie banners in no time. That feels very much like the future. It's a tool. An artist makes art with a hammer, the laymen gets the nail in.

IMO the problem is that we can't coherently measure productivity in software engineering (particularly in and across teams) as a baseline to make sense of this claim.

You're right we can't, but on a subjective level it sometimes gets hard to discount if you have enough moment where you go, "Wow, this just saved me 2 weeks of work". There's a lot of opposite moments as well, but you can get better at avoiding them by getting a feel for how/when to use LLMs.

The problem is that I have seen enough LLM-assisted work that saved a day for one person, only to add a day of extra work for two other people. So your gut feeling that you saved yourself time can be misleading.

that happens with human code all the time too we call it technical debt, and tell ops people -- i.e. me -- to suck it up when it makes them extra work so i'm not sure we can lay this at the feet of the llms, unless we can prove an overall increase (and gl w/ tech debt metrics: not v measurable)

This is, why IMO, it's more about the size and criticality of the task you use it for and when you choose not to use it. And my criticism is that for most people, no task is off limits.

I think that because code generation is an LLM strength (helped by the fact there is little to no satirical code equivalent to "put glue on a pizza" in the training data), many people who have used them primarily for coding overestimate their usefulness in other areas.

I wouldn't argue with that, but it supposes that the main issue with software development is the speed of production of code, and it is certainly not. Nothing I have seen has convinced me that no silver bullet is not still valid. We are still not reducing any of the essential complexity.

I used to hold this view, but after a year of using agents since sonnet 3.5 up to now, I am realizing that I am getting some sort of free lunch with the latest agents. it won't work for every codebase, but for a lot of them, reducing the effort to add a feature by 95% helps immensely

So for me, I observed the project outcomes between my team where they did or didn't adopt AI assistance, and there is not an observable difference. Other factors are way larger.

Information theory could be of use here (not an info theorist myself). Complexity can't be destroyed, only transformed and hidden. Like any compression algo that makes one file smaller must make some other file larger. If prompting becomes the face of programming, where does the complexity go?

This is why I'm not on board with the idea that we will all switch to building software with owners and not care about the underlying code The code is where the complexity lies. The best software will be written by engineers who continue to care about that code quality just like they do today

Agree! By the way, this is a fantastic thread that feels like the early days of Twitter (RIP) where smart people were all sharing ideas and learning from each other. Kudos!

Expanding a bit: programming languages are like compression algos - any abstraction that makes one problem simpler makes another problem more complex. Natural language prompting makes a lot of things simpler. What does it make more complex? The answer can't be "nothing".

Yes, it's not a new effect. We have been chipping away at making building things easier, meanwhile we just make more complex things and the overall cost goes up instead of down. Code generation isn't new, and people still mistake programmers for typists.

Say more. I'd posit that we're becoming increasingly more avoidant in our belief that this tech will sort of "figure itself out". And in this way we're not developing tolerance, but more acceptance. Greater (essential) complexity is a lot of hard work; sitting in the discomfort of unknowing.

that could all be right. I meant tolerance in a broad enough sense to include avoidance. I don’t think we can know yet whether we’re making a complexity bomb for our future selves. I tend to doubt it (LLMs are also great for building meta-tools for managing our tools) but I am an optimist

💯People talk about scaling for usage, but we hardly ever talk about scaling for complexity Apps only get more complex over time as we add new features, so if you're not constantly thinking about how to scale for complexity you're likely painting yourself into a corner

I'm also a bit anxious about a Jevon's paradox situation. I.e Code is cheaper, so we make and use more of it, which is likely to lead to more issues. Most of the cost of systems is in maintenance not build. We will see, if it was going to have a huge impact we should be seeing it.

as a counterpoint, i'm sre/ops, so most of my work is maintenance rather than build and i'm seeing improvements in many parts of my job, especially in the work of learning tools i'm obligated to maintain but don't currently understand so i'm cautiously optimistic, though definitely very cautious

The sorts of large enterprises which immediately blocked access to ChatGPT when it appeared for fear of internal data being accessed/trained on are also only now getting around to (stupidly) forcing LLM usage by monitoring whatever they're now using and adding it to perf review processes

What you say is true but in my limited experience with Agentic coding can benefit: - it's faster to write tests (both before shipping and later a failing test for an existing bug) - existing code is a good context for the LLM to maintain - LLM can read thru legacy code to find a bug faster than me

Thats a really great application of Jevons I haven't seen before I've been thinking a bit recently about what changes now that code is much cheaper to write but I hadn't made the connection to that meaning there's going be a LOT more of it, which will cause all sorts of new problems

There’s kind of an inverted incentive now; because writing code is easy, writing a lot if code is now a productivity antipattern. The most valuable engineer is no longer the one who can solve a problem with +10k lines of code in a weekend, but the one who can solve same with -2k lines.

This has been my concern for a long time, not least because AI-written code has a tendency to be a _lot_ more verbose. I've already seen it in a professional context. The scariest part is that occasionally reviewing developers are so overwhelmed by the amount of code they turn to AI to review it...

I had some thoughts on this for a talk I gave recently about the impact of AI coding tools. Including this Jevons! One enterprise use of cheap code is that you can more economically do data migration by integrating the two systems instead of just moving the data. Lower risk, smoother transition.

I haven't found that to be true any more If the task is novel I use them more as typing assistants - I'll dictate a solution ("write a function that does XYZ, now write tests for that, update the tests in this way, refactor the function and ensure the tests still pass") and correct along the way

My own spectacular LLM failure was also with sim/geometry/rendering C++ code. It simply couldn't stay consistent about our right-handed coordinate system, kept sneaking in left-handed stuff. But that was forever ago (i.e. about three months) and I'm told the models are much better now.

If you're going through the chat interface that's very different than what most people are talking about. I don't know how often the agents one shot correct solutions because the power is in their ability to run code, test, and iterate.

Same feelings... One question I have for you though is whether any of this goodness is accessible from mobile devices? From my laptop I can easily have several terminals with llms churning interesting things... But it's frustrating that I can't seem to get nice workflows from the phone.

I was surprised by how much pushback there was on this 😅 There's a ton of work being done now and in the near future defining how folks work with AI, which is a great spot to have some realistic moral conversations about the right and wrong way it's done. Missing out on that is a shame.

People like to amplify the negative examples and generally won't accept anything less than perfection. Because even if on average Opus 4.5 is way better than an average human SWE, it still makes mistakes. Less than a human, but different that a human would, so it's easy to point at.

This is unfortunately entirely true. They can be a 10x force multiplier for me. When they work, which is maybe 80% of the time, with 20% of the time being worse than useless and throwing the attempt in the trash and starting over.

People who start off with "at the risk of starting the flame war..." are usually hoping to start a flame war. Don't take the bait. Sure, if LLM's work for you, go for it. For me, I prefer to do my own thinking, and get a deeper understanding of the problems I'm coding for.