9 ms·

The cost of writing simple code has dropped 90%. If you can reduce a problem to a point where it can be solved by simple code you can get the rest of the solut

• mountainriver 11mo ago
  I’ve found they are able to compose well, let it build small components and stitch them together
  • visarga 11mo ago
    That is a good approach, bottom up, manage complexity. But the general picture is - you set the direction and hold the model responsible, it does the actual work. Think of it as your work is the negative of the AI work, it writes the code, you ensure it tests that code. The better test harness you create, the better the AI works. The real task is to constrain the AI into a narrow channel of valid work.
• loandbehold 11mo ago
  Most of software work is maintaining "legacy" code, that is older systems that have been around for a long time and get a lot of use. I find Claude Code in particular is great at grokking old code bases and making changes to it. I work on one of those old code bases and my productivity increased 10x mostly due to Claude Code's ability to research large code bases, make sense of it, answer questions and making careful surgical changes to it. It also helps with testing and debugging which is huge productivity boost. It's not about its ability to churn out lots of code quickly: it's an extra set of eyes/brain that works much faster that human developer.
  • nuclearnicer 11mo ago
    This is great. Asking questions of library code is a big pattern of mine too. Here's an example I saw on twitter. Asking an LLM to document a protocol from the codebase: https://ampcode.com/threads/T-f02e59f8-e474-493d-9558-11fddf823672?q=tmux https://ampcode.com/threads/T-f02e59f8-e474-493d-9558-11fddf... Do you think you will be able to capture any of this extra value? I think I'm faster at coding, but the overall corporate project timeline feels about the same. I feel more relaxed and confident that the work can be done. Not sure how to get a raise out of this.
    • loandbehold 11mo ago
      For me, as a remote developer, it means I'm able to finish my work in 1 hour instead of 8 hours. So I'm able to capture "extra value" in the form of time. In our team everyone uses GitHub Copilot and I use Claude Code. My teammates' productivity increased slightly but my productivity increased a lot. This is because 1. Claude Code is just a better coding agent 2. I invested time to get good at agentic coding. Eventually Copilot will catch up and management will realize that now 1 developer can do what previously would take a whole team.
      • overfeed 11mo ago
        I'm really curious on what your role is, and which industry are you in? I'm awed by these productivity gains others report, but I feel like AI helps in such a small part of my job (implementing specific changes as I direct). Agentic workflows for me results in bloated code, which is fine when I'm willing to hand over an subsystem to the agent, such as a frontend on a side project and have it vibe code the entire thing. Trying to get clean code erases all/most of my productivity gains, and doesn't spark joy. I find having a back-end-forth with an agent exhausting, probably because I have to build and discard multiple mental models of the proposed solution, since the approach can vary wildly between prompts. An agent can easily switch between using Newton-Raphson and bisection when asked to refactor unrelated arguments, which a human colleague wouldn't do after a code review.
        • saxenaabhi 11mo ago
          Not the OP but we use LLMs to build a restaurant pos system with reservations, loyalty, webshop etc. Almost at feature parity with bigwigs like lightspeed/toast. > I find having a back-end-forth with an agent exhausting, probably because I have to build and discard multiple mental models of the proposed solution, since the approach can vary wildly between prompts Just right now I had it improve QR payments on POS. This is standard stuff, and I have done it multiple time but i'm happy I didn't have to spend the mental energy to implement it and just had to review the code and test it. ``` Perfect! I've successfully implemented comprehensive network recovery strategies for the OnlinePaymentModal.tsx file. Here's a summary of what was added: Implemented Network Recovery Strategies 1. Exponential Backoff for Polling (lines 187-191) 2. Network Status Detection (lines 223-246, 248-251) 3. Transaction Timeout Handling (lines 110-119) 4. Retry Logic for Initial Transaction (lines 44-105) 5. AbortController for Request Cancellation (lines 134-139, 216-220) 6. Better Error Messaging (lines 85-102, 193-196) 7. Circuit Breaker Pattern (lines 126-132) All strategies work together to provide a robust, user-friendly payment experience that gracefully handles network issues and automatically recovers when connectivity is restored. ``` > An agent can easily switch between using Newton-Raphson and bisection when asked to refactor unrelated arguments, which a human colleague wouldn't do after a code review. Can you share what domain your work is in? Is it deeptech. Maybe coding agents right now work better for transactional/ecommerce systems?
  • dleeftink 11mo ago
    Although many tools exist, there still seems to a large context gap here: we need better tools to orient ourselves and to navigate large (legacy) codebases. While not strictly a a source graph or the like, I do think Enso like interface may prove successful here[0].
  • zmmmmm 11mo ago
    I've found this as well. In some cases we aren't fully authorised to use the AI tools for actual coding but even just asking "how would you make this change" or "where would you look to resolve this bug" or "give me an overview of how this process works" is amazingly helpful.
    • eru 11mo ago
      > In some cases we aren't fully authorised to use the AI tools for actual coding but even just asking "how would you make this change" [...] Isn't the logical endpoint of this equivalent to printing out a Stackoverflow answer and manually typing it into your computer instead of copy-and-pasting? Nitpicks aside, I agree that contemporary AIs can be great for quickly getting up to speed with a code base. Both a new library or language you want to be using, and your own organisation's legacy code. One of the biggest advantages of using established ecosystem was that stack-overflow had a robust repository of already answered questions (and you could also buy books on it). With AI you can immediately cook up your own Stackoverflow community equivalent that provides answers promptly instead of closing your question as off-topic. And I pick Stackoverflow deliberately: it's a great resources, but not reliable enough to use blindly. I feel we are in a similar situation with AI at the moment. This will change gradually as the models become better. Just like Stackoverflow required less expertise to use than attending a university course. (And a university course requires less expertise than coming up with QuickSort in the first place.)
      • ChrisMarshallNY 11mo ago
        > Isn't the logical endpoint of this equivalent to printing out a Stackoverflow answer and manually typing it into your computer instead of copy-and-pasting? Not in my case (I never used SO like that, anyway). I use it almost exactly like SO, except much more quickly and interactively (and without the inference that I’m “lazy,” or “stupid,” for not already knowing the answer). I have found that ChatGPT gives me better code than Claude (I write Swift); even learning my coding and documentation style. I still need to review all the code it gives me, and I have yet to use it verbatim, but it’s getting close. The most valuable thing, is I get an error, and I can ask it “Here’s the symptoms and the code. What do you think is going on?”. It usually gives me a good starting point. I could definitely figure it out on my own, but it might take half an hour. ChatGPT will give me a solid lead in about half a minute.
  • hello12343214 11mo ago
    this was really interesting to read.
  • locknitpicker 11mo ago
    > It's not about its ability to churn out lots of code quickly: it's an extra set of eyes/brain that works much faster that human developer. This is the key take right here. LLMs excel at parsing existing content, summarizing it, and use it to explore scenarios and hypotheticals. Even the best coding agents out there such as Claude Code or Gemini often fail to generate at the first try code that actually compiles, let alone does what it is expected to do. Apologists come up with excuses such as the legacy software is not architected well enough to be easily parseable by LLMs but that is a cheap excuse. The same reference LLMs often output utter crap in greenfield projects they themselves generated, and do so after a hand full of prompts. The state of a project is not the issue. The world is coming to the realization that the AI hype is not delivering. The talk of AI bubble is already mainstream. But like IDEs with auto complete, agents might not solve every problem but they are nevertheless useful and are here to stay. They are more a kin to a search engine where a user doesn't need to copy/paste code snippets to apply a code change. The sooner we realize this, the better.
    • Dave_Wishengrad 11mo ago
      [dead]
  • locknitpicker 11mo ago
    > Most of software work is maintaining "legacy" code, that is older systems that have been around for a long time and get a lot of use. That's not the definition of legacy. Being there for a long time and getting lots of use is not what makes a legacy project "legacy". Legacy projects are characterized by not being maintained and having little to no test coverage. The term "legacy" means "I'm afraid to touch it because it might break and I doubt I can put it back together". Legacy means resistance to change. You can and do have legacy projects created a year or two ago. Most vibecoded apps fit the definition of legacy code. That is why legacy projects are a challenge to agentic coding. Agents already output huge volumes of code changes that developers struggle to review, let alone assert it's correctness. On legacy projects that are in production, this is disastrous.
    • tarsinge 11mo ago
      What you list are common characteristics encountered in legacy systems, but what makes it legacy is a business decision of declaring it obsolete and in maintenance mode, and so that no money or time to be invested in it. Old systems that continues to evolve are not legacy, like say Linux, and yes like you say a project that is only one year old can be declared legacy. Resistance to change is only an economic variable that drives the decision. Vibecoded apps fits the definition because the developer is unlikely to want to invest more time in them for different reasons.
      • locknitpicker 11mo ago
        > What you list are common characteristics encountered in legacy systems, but what makes it legacy is a business decision of declaring it obsolete and in maintenance mode, and so that no money or time to be invested in it. No, not necessarily. Business decisions are one of the many factors in creating legacy code,but they are by no means the single cause. A bigger factor is developers mismanaging a project to the point they became a unmaintainable mess. I personally went through a couple of projects which were legacy code the minute they hit production. One of them was even a proof of concept that a principal engineer, one of those infamous 10x types, decided to push as-is to production and leave two teams of engineers to sort out the mess left in his wake. I recommend reading "Working Effectively with Legacy Code" by Michael Feathers. It will certainly be eye-opening to some, as it dispels the myth that legacy code is a function of age.
  • lambdaone 11mo ago
    Claude is insanely good at grunt-work maintenance coding, which is a fairly formulaic exercise that mostly requires RTFM and simple code changes that look a lot likw the surrounding code. Designing new things from scratch based on human specs is something which Claude still struggles with.
    • mcny 11mo ago
      The problem is that it often doesn't get it right the first time. You have to sort of have a conversation and it eventually gets there but if you have no idea what the destination should be like, you can't guide it there.
  • curiousgal 11mo ago
    I honestly don't know what code bases you guys are working with, for me I tried it with a large quant library (C++ 97) in an effort to modernize it and so far it's been nothing hit a waste of time. Similarly for a medium sized python quant codebase (3.6) trying to port it to 3.12, and it's also been a headache.
    • loandbehold 11mo ago
      Email me loandbehold0 at proton.me with details of what you are trying to do. I don't have quantitative finance experience but I can give it a shot.
  • Jean-Papoulos 11mo ago
    I have the opposite experience. Claude can't get it all in the context window and make changes that will completely break something on the other side of the program. Granted that's because the program is incredibly poorly written, but still, context window will stay a huge barrier for quite some time.
    • zinodaur 11mo ago
      I don’t put all the source in context either - if you let Claude run the compiler (or even tests) it can avoid these issues
    • bonzini 11mo ago
      Yep. It can refactor very well but that's it. For complex code bases it cannot even build boilerplate that makes sense; at most it saves some typing.
      • unregistereddev 11mo ago
        > It can refactor very well but that's it. Can it though? I thought it was most useful for writing new code, but have so far never had it correctly refactor existing code. Its refactoring attempts usually change behavior / logic, and sometimes even leave the code in a state where it's even harder to read.
    • jollyllama 11mo ago
      Between yours and GP's comments, I find echoes of my experience: > Most of software work is maintaining "legacy" code, that is older systems that have been around for a long time and get a lot of use. > Granted that's because the program is incredibly poorly written LLMs can't fix big, shitty legacy codebases. That is where most maintenance work (in terms of hours) is, and where it will remain. I would take it one step further and argue that LLMs and vibe-coding will compound into more big, shitty legacy codebases over time, and therefore, in the long arc, nothing will really change.
      • Espressosaurus 11mo ago
• gcanyon 11mo ago
  > The cost of writing simple code has dropped 90%. Need to add, “…and what ‘simple’ means is getting broader by the day.”
  • qazxcvbnmlp 11mo ago
    and varies person to person especially based on their prompting skills
    • deleted 11mo ago
      [deleted]
• RajT88 11mo ago
  I would add "predictable" to that as well. I fed Claude Pro a REST API spec and told it to spit out a Powershell module and well... So far that 27k lines of code largely checks out (minus the undocumented stuff I knew about). Getting it to write the pester scripts was a very different matter...
• almosthere 11mo ago
  Most code is simple, the fact that large complex systems are layers of simple code on top of itself, like garbage heaps at the dump, makes it complex. Sticking with the garbage analogy, the LLM is like upgrading from one shovel to an crew of 10 people with excavators to look for a lost Bitcoin hard drive. Your project is still going to fail, but it will fail faster with the 10 excavators.
  • tclancy 11mo ago
    And pollute the world. Really good analogy.
  • shigawire 11mo ago
    Sometimes you just need to move trash around with low accuracy... In that case the excavator swarm is good enough.
  • edg5000 11mo ago
    The analogy I use is going from hand-farming or farm animals to large combines overnight. You still need all the knowledge abouw farming, but it amplifies and multiplies your ability.
  • ngc248 11mo ago
    Every use case has necessary complexity. The only things simple are CRUD apps.
• dabockster 11mo ago
  And not everyone wants to use a cloud AI either. Remember that when tons of cash is on the table, things like license agreements become less enforceable and more of a "don't get caught in the cookie jar" thing. All it would take is something similar to what's going on with book authors/publishers - a major AI provider exposed as using other firms' proprietary code without even considering to get a license - to totally blow up the "safety" of cloud based coding agents. Local models are becoming more and more capable but the tooling still needs to get better for those.
• Terr_ 11mo ago
  > The cost of writing simple code has dropped 90%. Plus there's a lot of simple code you shouldn't be writing either way, because it's in a library by now. By their nature, LLMs will do their best with things that could be plagiarized.
  • mewpmewp2 11mo ago
    Aren't we having major issues with there being too many small libraries right now and dependency chain that grows exponentially? I have thought LLMs will actually benefit us a lot here, with not having to use a lib for every little thing (leftpad etc?).
    • bluefirebrand 11mo ago
      Frankly if you were relying on libraries like Leftpad to you probably had no business writing code before AI And if you rely on AI to write that code now you still have no business writing code
      • teknopaul 11mo ago
        Bit harsh. That was probably a node / npm thing, because they had no stdlib it was quite common to have many small libraries. I consider it an absolute golden rule for coding to not write unnecessary code & don't write collections. I still see a lot of C that ought not to have been written. I'm a grey beard, and don't fear for my job. But not relying on AI if it's faster to write, is as silly as refusing a correct autocomplete and typing it by hand. The bytes don't come out better
      • mewpmewp2 11mo ago
        Why should I retype something that in my life I have probably already written 10s of times?
        • bluefirebrand 11mo ago
          Make your own standard library then and import that
• freedomben 11mo ago
  Completely agree. In the past 12 months, I've had five or six use cases that I would not have bothered scripting or automating before, but I've cranked out scripts or even small web services in under an hour that get the job done using AI. It has really revolutionized the super small bite-sized issues
  • KellyCriterion 11mo ago
    exactly this! You can do things nearby with one prompt which would have taken weeks before to tinker around; esp. ClaudeAI is very good with "give a detailed first prompt and some context sourcefiles and create a working example on first shot". E.g. I have to deal with lot of reports and those are usually "never fully developed" because "we can add this one row/feature later" because "management want us to ship early". Now I can enhance our reports by whatever metric just by handing over a current XLSX-exportcode and tell the LLM: "now i want additionally XY here...."
• manquer 11mo ago
  Yes, but for experienced engineers that is still a huge huge change . Even 12 months ago simplifying tasks alone was insufficient, you still needed a large group engineers to actually write, review and maintain a typical product for solid startup offering. This came with the associated overhead of hiring and running mid sized teams. A lot of skilled people (y)our age/experience are forced into doing people management roles because there was no other way to deliver a product that scales(in team and complexity not DAU). A CTO of mid-stage startup had to be good architect, a decent engineering manager, be deeply involved in product and also effectively communicate with internal and external customers. Now for startups setting up new you can either defer the engineering manager and people complexity lot latter than you did before. You could have a very senior but small team who can be truly 10x level and be more productive without the overhead of communication, alignment and management that comes with large teams. ---- tldr; Skilled engineers can generate outsized returns to orgs that set them up to be successful(far more than before), I can't say if compensation is reflecting this yet, if not it soon will.
  • conductr 11mo ago
    The funny thing is a lot of that was never really necessary per se. Tons of stories about great projects coming out of tiny teams. They’re not likely geniuses, they just had focus and clarity and a drive to GSD without excessive unproductive activity. I’ve long been a proponent of offshore developers for cost savings. You have to manage the process and people differently, but the output per dollar (pre AI) was phenomenal and when managing them I could put my brand of low touch management in place. Usually consisting of one weekly 1 hour meeting for everyone, then emphasizing nobody spins their wheels ever for more than an hour during the week without asking for help, then just making sure everyone was crystal clear on what we were working on and the priorities. I’ve never been a fan of sprints or really any unit of time block as a milestone because I don’t think it incentivizes people to finish early. I’m also not a perfectionist. If it’s spaghetti code and it works, great, we can clean it up on the next pass (within reason of course, but spirit is build, test, operationalize, then if it’s useful and has some staying power then refactor later. For all this, hiring cheap labor overseas has always made much more sense than hiring locally (in US) based on cost but also based one working style/culture. Somehow as labor rates shot up here in last couple of decades, people found excuses not to offshore. Some of it valid if you can’t manage the project correctly as it is different, but for me the solution has been to adapt my management style versus crying about it being difficult and hiring locally to be lazy. It always struck me as odd that startups and investors hadn’t leveraged the labor rate arbitrage opportunity that exists.
• interstice 11mo ago
  While I would love for this to be true for financial and egotistical reasons, I have a growing feeling that this might not be true for long unless progress really starts to stall.
  • dimal 11mo ago
    I've actually gone in the other direction. A year ago, I had that feeling, but since then I've gotten more certain that LLMs are never going to be able to handle complexity. And complexity is still the real problem of developing software. We keep getting more cool features in the tools, but I don't see any indication that the models are getting any better at understanding or managing complexity. They still make dumb mistakes. They still write terrible code if you don't give them lots of guardrails. They still "fix" things by removing functionality or adding a ts-ignore comment. If they were making progress, I might be convinced that eventually they'll get there, but they're not.
    • IshKebab 11mo ago
      Yeah but on the other hand there are plenty of human programmers that are bad at understanding complexity, make dumb mistakes, and write terrible code. Is there something fundamentally different about their brains to mine? I don't think so. They just aren't as good - not enough experience, or not enough neurons in the right places or whatever it is that makes some humans better at things than others. So maybe there isn't any fundamental change needed to LLMs to take it from junior to senior dev. > They still "fix" things by removing functionality or adding a ts-ignore comment. I've worked with many many people who "fix" things like that. Hell just this week, one of my colleagues "fixed" a failing test by adding delays. I still think current AI is pretty crap at programming anything non-trivial, but I don't think it necessarily requires fundamental changes to improve.
      • mrwrong 11mo ago
        this whole analogy is so tired. "LLMs are stupid, but some humans are stupid too, therefore LLMs can be smart as well". let's put aside the obvious bad logic and think for one second about WHY some people are better than others at certain tasks. it is always because they have lots of practice and learned from their experiences. something LLM categorically cannot do
• cryptonector 11mo ago
  Yes, well, I think this makes that skill of problem reduction a very valuable skill.
• TacticalCoder 11mo ago
  > The cost of writing simple code has dropped 90%. The cost of writing code has dropped 90%. The cost of maintaining code, which has always been the hardest part, has grown 90% ; )
• trollbridge 11mo ago
  Well said. The cost of building a CRUD has dropped 90%. The open question is why people needed fancy AI tools like Claude to write CRUDs in the first place. These kind of tasks ought to be have been automated a long time ago.
  • sothatsit 11mo ago
    > These kind of tasks ought to be have been automated a long time ago. It’s much easier to write business logic in code. The entire value of CRUD apps is in their business logic. Therefore, it makes sense to write CRUD apps in code and not some app builder. And coding assistants can finally help with writing that business logic, in a way that frameworks cannot.
  • IshKebab 11mo ago
    > These kind of tasks ought to be have been automated a long time ago. People have been trying for literally decades. The problem is that there is just enough uniqueness to every CRUD app that you can't really have "the CRUD app". I guess it's the sweet spot for AI at the moment because they're 95% all the same but with some fairly simple unique aspects.
  • raxxorraxor 11mo ago
    CRUD as a concept is flawed. It is more or less any computational system with input -> process -> output. Just as this abstract system can have any complexity, the same is true for any CRUD app. You don't need Claude to write it. But you cannot generate solid web forms with the same speed. What usually would have taken you a few hours is now solved in much less time. I doubt software will get cheaper though, requirements will adapt.
    • trollbridge 11mo ago
      If I wanted to make a crud, I’d whip up my own little framework first (a few hours) and then cranking out forms would be almost trivial.
  • eloisant 11mo ago
    That went 90% down even before AI, Rails and the other frameworks, libraries, tooling have made a big difference compared to earlier years. The number of lines of code to be written is much, much lower than in the early 2000's.
• deleted 11mo ago
  [deleted]
• deleted 11mo ago
  [deleted]
• janpmz 11mo ago
  At the leafs of the branches I'm comfortable to just generate code (e.g. a popup dialog). But I want to have a good grasp of code that is central of the application.
• danmaz74 11mo ago
  I wouldn't say that the distinction is so much about code being "simple", but about code being made of patterns common enough in online examples. Claude Code and similar can write even very complex code, as long as it's something they have been trained on.