4 ms·

What do you think about the argument that we are entering a world where code is so cheap to write, you can throw the old one away and build a new one after you'

by ahepp 6mo ago

What do you think about the argument that we are entering a world where code is so cheap to write, you can throw the old one away and build a new one after you've validated the business model, found a niche, whatever? I mean, it seems like that has always been true to an extent, but now it may be even more true? Once you know you're sitting on a lode of gold, it's a lot easier to know how much to invest in the mine.

eloisant 6mo ago
It hasn't always been true, it started with rapid development tools in the late 90's I believe. And some people thought they were building "disposable" code, only to see their hacks being used for decades. I'm thinking about VB but also behemoth Excel files.
- ahepp 6mo ago
  I guess the question is, are the issues not worth fixing because implementing a fix is extremely expensive, or because the improvements from fixing it were anticipated to be minor? I assume the answer is generally a mix of the two.
tombert 6mo ago
I actually think that might actually be a good path forward. I hate self-promotion but I posted my opinions on this last night https://blog.tombert.com/Posts/Technical/2026/04-April/Stop-Pushing-AI-Generated-Code-to-Git https://blog.tombert.com/Posts/Technical/2026/04-April/Stop-... The tl;dr of this is that I don't think that the code itself is what needs to be preserved, the prompt and chat is the actual important and useful thing here. At some point I think it makes more sense to fine tune the prompts to get increasingly more specific and just regenerate the the code based on that spec, and store that in Git.
- alephnerd 6mo ago
  This is actually a pretty good callout. Observability into how a foundation model generated product arrived to that state is significantly more important than the underlying codebase, as it's the prompt context that is the architecture.
  - tombert 6mo ago
    Yeah, I'm just a little tired of seeing these pull requests of multi-thousand-line pull requests where no one has actually looked at the code. The solution people are coming up with now is using AI for code reviews and I have to ask "why involve Git at all then?". If AI is writing the code, testing the code, reviewing the code, and merging the code, then it seems to me that we can just remove these steps and simply PR the prompts themselves.
    - alephnerd 6mo ago
      Yep. Also, the approach you described is what a number of AI for Code Review products are using under-the-hood, but human-in-the-loop is still recognized as critical. It's the same way how written design docs and comments are significantly more valuable than uncommented and undocumented source.
    - zephen 6mo ago
      > why involve Git at all then? I made a similar point 3 weeks ago. It wasn't very well received. https://news.ycombinator.com/item?id=47411693 https://news.ycombinator.com/item?id=47411693 You don't actually need source control to be able to roll back to any particular version that was in use. A series of tarballs will let you do that. The entire purpose of source control is to let you reason about change sets to help you make decisions about the direction that development (including bug fixes) will take. If people are still using git but not really using it, are they doing so simply to take advantage of free resources such as github and test runners, or are they still using it because they don't want to admit to themselves that they've completely lost control?
      - tombert 6mo ago
        > are they still using it because they don't want to admit to themselves that they've completely lost control? I think this is the case, or at least close. I think a lot of people are still convincing themselves that they are the ones "writing" it because they're the ones putting their names on the pull request. It reminds me of a lot of early Java, where it would make you feel like you were being very productive because everything that would take you eight lines in any other language would take thirty lines across three files to do in Java. Even though you didn't really "do" anything (and indeed Netbeans or IntelliJ or Eclipse was likely generating a lot of that bootstrapping code anyway), people would act like they were doing a lot of work because of a high number of lines of code. Java is considerably less terrible now, to a point where I actually sort of begrudgingly like writing it, but early Java (IMO before Java 21 and especially before 11) was very bad about unnecessary verbosity.
- xienze 6mo ago
  > At some point I think it makes more sense to fine tune the prompts to get increasingly more specific and just regenerate the the code based on that spec, and store that in Git. Generating code using a non-deterministic code generator is a bold strategy. Just gotta hope that your next pull of the code slot machine doesn’t introduce a bug or ten.
  - tombert 6mo ago
    We're already merging code that has generated bugs from the slot machine. People aren't actually reading through 10,000 line pull requests most of the time, and people aren't really reviewing every line of code. Given that, we should instead tune the prompts well enough to not leave things to chance. Write automated tests to make sure that inputs and outputs are ok, write your specs so specifically that there's no room for ambiguity. Test these things multiple times locally to make sure you're getting consistent results.
    - xienze 6mo ago
      > Write automated tests to make sure that inputs and outputs are ok Write them by hand or generate them and check them in? You can’t escape the non-determinism inherent in LLMs. Eventually something has to be locked in place, be it the application code or the test code. So you can’t just have the LLM generate tests from a spec dynamically either. > write your specs so specifically that there's no room for ambiguity Using English prose, well known for its lack of ambiguity. Even extremely detailed RFCs have historically left lots of room for debate about meaning and intention. That’s the problem with not using actual code to “encode” how the system functions. I get where you’re coming from but I think it’s a flawed idea. Less flawed than checking in vibe-coded feature changes, but still flawed.
      - tombert 6mo ago
        > Write them by hand or generate them and check them in? Yes, written by hand. I think that ultimately you should know what valid inputs and outputs are and as such the tests should be written by a human in accordance with the spec. > Less flawed than checking in vibe-coded feature changes, but still flawed. This is what I'm trying to get at. I agree it's not perfect, but I'm arguing it's less evil than what is currently happening.
tracerbulletx 6mo ago
Someone has to figure out how to make the experiences of the two generations consistent in the ways it needs to be and differ only in the ways it doesn't still.

by ahepp 6mo ago

eloisant 6mo ago

It hasn't always been true, it started with rapid development tools in the late 90's I believe. And some people thought they were building "disposable" code, only to see their hacks being used for decades. I'm thinking about VB but also behemoth Excel files.

ahepp 6mo ago
I guess the question is, are the issues not worth fixing because implementing a fix is extremely expensive, or because the improvements from fixing it were anticipated to be minor? I assume the answer is generally a mix of the two.

tombert 6mo ago

I actually think that might actually be a good path forward. I hate self-promotion but I posted my opinions on this last night https://blog.tombert.com/Posts/Technical/2026/04-April/Stop-Pushing-AI-Generated-Code-to-Git https://blog.tombert.com/Posts/Technical/2026/04-April/Stop-... The tl;dr of this is that I don't think that the code itself is what needs to be preserved, the prompt and chat is the actual important and useful thing here. At some point I think it makes more sense to fine tune the prompts to get increasingly more specific and just regenerate the the code based on that spec, and store that in Git.

alephnerd 6mo ago
This is actually a pretty good callout. Observability into how a foundation model generated product arrived to that state is significantly more important than the underlying codebase, as it's the prompt context that is the architecture.
- tombert 6mo ago
  Yeah, I'm just a little tired of seeing these pull requests of multi-thousand-line pull requests where no one has actually looked at the code. The solution people are coming up with now is using AI for code reviews and I have to ask "why involve Git at all then?". If AI is writing the code, testing the code, reviewing the code, and merging the code, then it seems to me that we can just remove these steps and simply PR the prompts themselves.
  - alephnerd 6mo ago
    Yep. Also, the approach you described is what a number of AI for Code Review products are using under-the-hood, but human-in-the-loop is still recognized as critical. It's the same way how written design docs and comments are significantly more valuable than uncommented and undocumented source.
  - zephen 6mo ago
    > why involve Git at all then? I made a similar point 3 weeks ago. It wasn't very well received. https://news.ycombinator.com/item?id=47411693 https://news.ycombinator.com/item?id=47411693 You don't actually need source control to be able to roll back to any particular version that was in use. A series of tarballs will let you do that. The entire purpose of source control is to let you reason about change sets to help you make decisions about the direction that development (including bug fixes) will take. If people are still using git but not really using it, are they doing so simply to take advantage of free resources such as github and test runners, or are they still using it because they don't want to admit to themselves that they've completely lost control?
    - tombert 6mo ago
      > are they still using it because they don't want to admit to themselves that they've completely lost control? I think this is the case, or at least close. I think a lot of people are still convincing themselves that they are the ones "writing" it because they're the ones putting their names on the pull request. It reminds me of a lot of early Java, where it would make you feel like you were being very productive because everything that would take you eight lines in any other language would take thirty lines across three files to do in Java. Even though you didn't really "do" anything (and indeed Netbeans or IntelliJ or Eclipse was likely generating a lot of that bootstrapping code anyway), people would act like they were doing a lot of work because of a high number of lines of code. Java is considerably less terrible now, to a point where I actually sort of begrudgingly like writing it, but early Java (IMO before Java 21 and especially before 11) was very bad about unnecessary verbosity.
xienze 6mo ago
> At some point I think it makes more sense to fine tune the prompts to get increasingly more specific and just regenerate the the code based on that spec, and store that in Git. Generating code using a non-deterministic code generator is a bold strategy. Just gotta hope that your next pull of the code slot machine doesn’t introduce a bug or ten.
- tombert 6mo ago
  We're already merging code that has generated bugs from the slot machine. People aren't actually reading through 10,000 line pull requests most of the time, and people aren't really reviewing every line of code. Given that, we should instead tune the prompts well enough to not leave things to chance. Write automated tests to make sure that inputs and outputs are ok, write your specs so specifically that there's no room for ambiguity. Test these things multiple times locally to make sure you're getting consistent results.
  - xienze 6mo ago
    > Write automated tests to make sure that inputs and outputs are ok Write them by hand or generate them and check them in? You can’t escape the non-determinism inherent in LLMs. Eventually something has to be locked in place, be it the application code or the test code. So you can’t just have the LLM generate tests from a spec dynamically either. > write your specs so specifically that there's no room for ambiguity Using English prose, well known for its lack of ambiguity. Even extremely detailed RFCs have historically left lots of room for debate about meaning and intention. That’s the problem with not using actual code to “encode” how the system functions. I get where you’re coming from but I think it’s a flawed idea. Less flawed than checking in vibe-coded feature changes, but still flawed.
    - tombert 6mo ago
      > Write them by hand or generate them and check them in? Yes, written by hand. I think that ultimately you should know what valid inputs and outputs are and as such the tests should be written by a human in accordance with the spec. > Less flawed than checking in vibe-coded feature changes, but still flawed. This is what I'm trying to get at. I agree it's not perfect, but I'm arguing it's less evil than what is currently happening.

tracerbulletx 6mo ago

Someone has to figure out how to make the experiences of the two generations consistent in the ways it needs to be and differ only in the ways it doesn't still.