This is the best case outcome. All too often, especially with mom and pop small landlords, the repairs are delayed or done incompetently, or there is no local ordinance offering recompense to the renter, or both.

The downside of doing that is you end up "locked in" to the property too. They now have a strong disincentive to sell, because they'll lose that sweet sweet interest rate and relatively low payment. I'm unsure what the broader effect is on the market.

If your household is a typical HN high earner, and you are early in your mortgage's amortization schedule, the tax money you save by deducting interest can fund a $10k emergency repair fund too. Maybe even in less than a year.

    def run():
        with contextlib.suppress(SystemExit):
            do_thread_thing()

    threading.Thread(target=run, daemon=True).start()

The model's response: "Honestly? Cargo-culting on my part. You should remove it."

You could always take a job on a cattle ranch or an abattoir or meat-packing plant, or watch a How It's Made documentary, and get some understanding of how the sausage gets made and put on the supermarket shelf for your convenience. This was also true as we built abstractions in computer technology: you could start off learning a high level language, then learn a lower level one, then study or build an operating system kernel, a compiler, an assembler, machine code, and then crack some books on microprocessor architecture and signal processing. You could always "go deeper" if you wanted to. And there is a payoff: understanding at a deeper level helps you get things done better at the higher levels (e.g.: understanding the concept of memory hierarchy helps you lay out data structures to make code faster).

There is no such step for slop-coded codebases: you become entirely dependent on a context-limited LLM to have a shot at even approximating some understanding. The proponents of this style will tell you, don't look at the code. It's the antithesis of every other abstraction we've built in computing.

Perhaps more productively, you treat the slop as a black box and build something understandable around it.

This is also why the notion that developers in the future will be committing LLM prompts in English to repositories instead of code written in a programming language is so foolish. I am saying this as someone who uses LLMs quite a lot to help with generating and understanding code.

https://developer.apple.com/musickit/

One example: https://github.com/immunant/c2rust/issues/1678

I firmly believe the right way to port C and C++ (and Zig) programs to Rust is to do it module by module ("Ship of Theseus"). It needs scrutiny by folks who know both languages deeply, and you can port test cases too so you can detect UB at runtime (using tools like Miri). That's what fish did, and their port has been quite successful.

Blindly trusting the results of a machine translation is never a good idea. Especially when the translator has a temperature parameter.