TehPers

assurance that they don’t disappear if a forge dies

Publishing to multiple forges is a good idea, but I also wanted to add that anybody who clones your repository creates their own local copy of (parts of) your repository. Due to the nature of Git, simply having multiple contributors makes it that much harder to erase all traces of a repository.

You can also publish bundles of the repository somewhere else if you want another alternative. Every so often, bundle the repo and publish that as a “backup” somewhere, and anyone can download the bundle and initialize a repo off of it directly through git clone.

At work? Do what they want you to do I guess. If they are mandating you mass produce slop, do exactly that. I’ve tried fighting against it. There’s nothing you can do when your coworker opens a 785 file PR (not an exaggeration) and it needs to be reviewed today. Your carefully crafted code can never keep up with the constant waterfall of whatever the fuck Claude/ChatGPT/whatever calls acceptable these days.

Your best bet at work is to direct the agents others will use. Use a strict linter. Mandate a strict formatter. Add to the instructions that tests must be written and must pass. Do what you can to force it to emit semi-acceptable code (or fail if it can’t).

Outside of work? What’s a coding agent?

I couldn’t afford to do it on a project only intended for me to use. It takes “throw money at the problem” to a different level. For the same cost, he could have put up bounties and gotten open source devs excited about the port.

Edit: meant to respond to a different comment. Whatever lol.

Meanwhile, we have an entire ecosystem of JS tools being written in Rust that are absolutely amazing, including oxc, rolldown, biome, and so on. They’re not awesome because they’re written in Rust though, but because actual thought and effort was put into making them great. They could have been written in any language (see: eslint, prettier, vite, tsgo, and so on).

Bun was never behind for being written in Zig, but was actually pushed forward by the language to accomplish what would have been far more difficult to do in C.

What killed it was when Bun stopped committing human effort in favor of mass-produced slop. Where I used to recommend Bun, I now just recommend pnpm/Node.js.

As an aside, I’ve been using Boa as an embedded runtime recently, and I’ve been loving it. It doesn’t have the performance of other options, but it’s good enough™ and still has room to improve.

Work on open source projects, especially those that people use. Show that you can take user feedback and turn it into features. Show that you can work with others as a team on a large project.

Those will look the best.

As your southern neighbor, in skilled fields, the last thing you want is companies to outsource their skilled labor to other countries instead of bringing immigrants to your country to work there since they can create jobs, and if their position becomes vacant again, it’s still in your country. In unskilled jobs, when you decide to kick them out of your country, you’re left with a lot of vacant jobs that nobody wants to take.

The real issue is rampant exploitation of immigrants. With fair wages, you actually favor non-immigrants because of the additional costs associated with relocating someone from another country. When you’re unfairly exploiting them, the upfront cost becomes less relevant.

Anyway, I agree that getting into freelancing is going to be a nightmare. Trying to convince skilled devs that LLMs generate garbage in bulk is already difficult enough. Doing that to a non-dev manager is practically impossible.

There are a few tools out there that can recommend improvements to grammar. For example, a tool might suggest rewriting:

Benchmarks are a tool to validate a list of things, contrast, page load, images using modern formats, dead links, time to first paint, and semantic HTML, a `` isn’t a <div>.

to:

Benchmarks are a tool to validate a list of things: contrast, page load, images use modern formats, dead links, time to first paint, and semantic HTML (i.e. a </div> isn’t a <div>).

Many of them are now LLM-based, so you could probably just ask a locally-running Qwen3.5 or something for advice as well. Just be careful if you do this to constrain it only to grammar suggestions and not allow it to rewrite your article (LLM-speak is easy to spot).</div>

All feedback in the post is welcome.

Would it be rude to recommend a grammar checker? The topic and supporting arguments for the post are fine (if a little disorganized, but that’s common for blog posts). I just found the run-ons a bit distracting.

Otherwise, I agree that the internet is getting shittier. More ads, more walls to defend against scraping, less accessibility, etc. There’s no real metric for how well a page presents its contents, only metrics for specific things like load times, layout shift, and so on. I also suspect that, over time, page scoring will shift toward which sites present the data in ways that are more usable by LLMs.

I don’t know why it’s worth arguing (both of you) over the versioning scheme of a LLM-assisted/generated project that was posted by a new user with no other activity, but anyway…

PyPi (and Python) do not require semver, nor do all packages in the ecosystem use semver. However, Python tooling depends on packagers following a semver-esque versioning scheme while still allowing some freedom to maintainers to pick a scheme that works best for them.

Code shows signs of LLM use, in case anyone’s curious. Unless, of course, you normally type em dashes in your documentation I suppose.

Anyway, this feels to me like a small part of what is essentially a durable task framework. If you need atomicity and durability, consider one of those. If all you need is atomicity, a database guarantees it through so many methods, from inserts to locks*.

*Edit: and transactions, of course, but long running transactions aren’t usually a good idea.

To answer the question posed in the title: if you’re processing images given to you by strangers, you should normalize RGB values by 255.

The author isn’t advocating for you to do so. They are just exploring the two approaches. Even in the sentences following this one where they mention where 256 might work, they conclude with your colleagues breaking it all anyway by using 255.

I don’t understand specifically the copyright issue with respect to “trained on x data”

It’s a question of whether the output of the LLM is a derivative work of the training data. From a copyright standpoint, if the work is derivative (and not fair use), then it needs to follow the terms set by any licenses you have to its parent works.

people are often nasty when others ask questions they assume to be stupid.

It sounds to me like you might want to reevaluate the communities you’re in. This sounds incredibly toxic.

And I agree, for simple questions, it can be helpful. I would caution against overreliance on the answers though. Even the best models available today hallucinate regularly. Always verify answers when they are important.

Also, learning to read documentation directly is a valuable skill to develop. Even if you don’t rely on the documentation directly, reading a lot of it will make it easier to write documentation as well.

I think the post (well, this translation anyway) is best read as a fantasy rather than associated with reality. It’s predicated on a lot of assumptions, including the assumption that AI has the ability to develop large software almost entirely autonomously, that large brands have no means to lock users within an ecosystem, that people will be able to articulate exactly the software they need and how it should be designed, and so on.

The future being described by this post is the elimination of all roles of software and product development, spanning from developers to designers to even product managers.

As a thought experiment, it’s interesting. It shouldn’t be confused as reality, though.

Is this even a surprise? Giving away free access to Copilot hemorrhages money and only exists to convert those users into paying customers. It costs them nothing to take away some features from these users.

The only real ways to prevent this are local hosting (which is much more realistic these days) or an explicit contract stating that the features you want will remain for the duration of the contract. The latter is not an option with GH Copilot, as far as I’m aware, and is basically nonexistent with any modern services.

It looks like this was briefly touched in the article, but LLMs don’t learn shit.

If I tell you your use of a list is dumb and using a set changes the code from O(n) to O(1) and cuts out 15 lines of code, you probably won’t use a list next time. You might even look into using a deque or heap.

If your code was written by a LLM? You’ll “fix” it this time (by telling your LLM to do it) and then you’ll do it again next time.

I’m sorry, but in the latter case, not only are you mentally handicapping yourself, but you’re actively making the project worse in the long term, and you’ve got me sending out resumes because, and I mean this in the politest way possible, but go fuck yourself for wasting my time with that review.

Right now it’s no big deal to any AI company because more code means more training for the AI, but will we get to the point that they’re happy with code output enough and then turn around claiming they own those?

At least in the US:

The vast majority of commenters agreed that existing law is adequate in this area and that material generated wholly by AI is not copyrightable.

So it seems unlikely that they would be able to claim any ownership.

As for the rest of your comment (the parts around ownership): you always own the copyright for any copyrightable work you create, including code. When you post on a website, according to the ToS of that site, you’re licensing your comment/code/whatever to the website (you need to for them to be able to publish your work on their website).

Some (many, most depending on what you use) websites overlicense your work and use it for other purposes as well (like GitHub), but in the US the judges have basically ruled that AI companies can pirate whatever works they want without any attempt to license them and still be fine, so the “overlicense” bit is more of a formality at this point anyway.

there should be a fork of dotnet.

Dotnet is maintained by the .NET Foundation and is entirely open source. There are thousands of forks and local clones of the repos under that organization. Rather than hoping someone does this, it’d actually be a huge benefit to everyone for you to create a local clone of the repo and update it now and then, assuming you’re worried it might go down anyway.

telemetry being totally removed

DOTNET_CLI_TELEMETRY_OPTOUT=1, though it’s lame that it’s an opt-out and not opt-in. The CLI does give a fat warning on first use at least (which hilariously spams CI output). Opt-in would be so much better though, and opt-out by default is really not great.

an alternative to nuget.org

You can specify other package sources as well, so nothing technically stops someone from making their own alternative. That being said, you’d have to configure it for each project/solution that wants to use that registry.

Setting such a thing up could be insurance in case they pull anything in the future, too.

The main thing I’d be worried about here is nuget.org getting pulled. As far as I can tell, it’s run by MS, not the foundation. That’d be basically the entire ecosystem gone all at once. Fortunately, it’s actually super easy to create private registries that mirror packages on nuget.org, and it’s actually standard practice to do this at many companies. This means that at the very least it would be possible to recover some of the registry if this happened.

For a fork, I would think these would be the main goals I’d look for:

• Default to opt-in for telemetry, or make it local-only. Telemetry should go to a sink owned by the forking organization if sending telemetry is even possible at all.
• Default package registry should be one owned and maintained by the forking organization. This would be incredibly expensive though, so they’d need funding for this.
• Organization should be independent, and not funded at all, by MS. Alternatively, MS can provide funds, but not a majority amount - instead, sponsors are limited so that no single sponsor can fund enough of the fork to have independent control over it. In either case, the goal is that no single company has enough control to shift the direction meaningfully themselves.

Please cite one example of Microsoft ever giving a fuck about users.

There aren’t many examples, but one that comes to mind is the adaptive controller. It’s not cheap, but it’s also presumably low volume, and it’s unbelievably configurable.

Outside of that, I’m out of ideas. Usually every good change comes in response to user backlash, from my experience anyway. I’ve moved over to Linux by now because I’m tired of dealing with what Windows has become.