Yeah, that latter one basically focused on the fact the output looked verbatim like the 'training' material, so the judgement was that AI was more an excuse than a demonstrable transformative thing.

Note in some other case I recall the AI company arguing that the ingest and training of material is 'transformative' but the engines could be used to violate copyright, but then the *operator* would be on the hook for infringement, as the operator supplied the prompt that resulted in infringement.

There was also that OpenAI deal with Disney that was going to let Disney characters be used in OpenAI output but that got dropped. Lots of mixed assumptions in play with the AI companies asserting that they don't need permission, getting permission or forcing permission anyway, and shifting responsibility to the users.

Even if it exactly works as advertised, if you thought a rock kicked up by a tire was bad, just wait....

And thanks to hiring 1,000 new people to patch it, now they have N * 1.5 vulnerabilities!

I meant infested, not invested

*You* would not want this.

However on endpoints vaguely related to your work, your employer *loves* excuses to give Microsoft money to invest as many endpoints as possible.

Nowhere in this do I see how maintaining the history in this manner even benefits AI. I haven't seen evidence that it can benefit from an insanely over-granular change history.

This is not debating the volume of code, it's the granularity of delivering it as tiny 'changesets'. Just because you *can* create a system that can partition changes into 3 second intervals does not mean there's any value for machine nor human in doing so.

To start, the condescension is hardly helpful.

The point stands, you have to consider the audience for the change tracking. How much granularity is really useful even for the AI models themselves to digest? Certainly no human will digest, but I also don't think the AI is going to be prioritizing putting hundreds of thousands of change history entries into the context window on the off chance that it is relevant to the task at hand.

It seems like a solution to pretend around change management while abandoning any actual use of change management, by human or machines.

Though in that scenario, it seems bad or useless for the AI as well, as the bloated change history is a waste of context window. Unless they just ignore it in which case what was the point in bothering.

But perhaps it is just another attempt to normalize "human shouldn't be in the loop" mindset, the new toy is but an excuse to say you *should* be having a codebase that is being changed every couple of seconds without bound.

I just cannot wait for that day. When people have a least a *little* less incentive for certain folks to butt in on other people's jobs and tell them how it should be done, despite never even doing nor using an AI to do said job in a serious capacity.

This story triggered a colleague to tell me that I need to stop using git, despite never having used *any* version control scheme nor even using an AI to generate code, just super armchair software development. I do not understand that mindset of people that invested in the nitty gritty of software development without the will to actually do software development.

A changeset history is only so useful compared to analysis of the code as it is. Even pretty large context windows need prioritization. I would think an overly granular changeset history would be a really low prioriity.

Compared to more aggregated changes into fewer changesets, where the history would be probably more digestable, even for AI consumption.

We can't actually know if it is 'actually quite good', because we have only their own self-assessment to go on.

No way to debate how it compares with git partial/shallow clones in broader circumstances. They don't want to share it, they just want to use the concept to fluff their image. It might be amazing, it might be trash, impossible to say anything substantial based on this.

The issue is the situation isn't binary.

Linus comes along with an attempt at nuance and suddenly all sorts of high-slop vibe coders think they are just like Linus.

I know a team that has gone very hard on slopping it up AI, though they just had a flamewar where the AI bros bitched that the more careful people were holding them back by insisting on human review and rejecting merge requests where the human didn't understand what they were submitting.

The thing is, this team was already pumping out shit code for years, so in their case the AI might actually be compelling. Infested by PHB thinking of 'hire many people in random geography, to change each year as different geographies are proven to be shit when you only pay bottom of the barrel'. They have been rotating cheap labor forever hoping for the magical geo where the cheapest people are still skilled (no such geography exists, the bottom of the barrel in any geo is trash). So AI is next on their search.

Absolutely on point. Even if you did decide the volume of code was acceptable, there's no way you need to land 30,000 commits in a day. That's less than 3 seconds per change.

If a human were pushing too many changes, I'd tell them to slow down and take a bit more time per commit. Larger commits that are more manageable instead of rapid fire tiny commits that are impossible to wrangle. If you say the AI commits are large even rapid fire, the point still stands in relative terms.

Commit histories should be there for humans to operate on. To follow the progression of changes, to bisect in case of a long delayed bug, or as the increment to trigger a deployment activity. No human can follow a commit log of 30,000, the AI doesn't need a commit log to do whatever it is doing, bisect is prohibitively slow with that many commits, you need to jump to something other than just picking out of the commit log by that time, and there's no software on earth than needs to be redployed every 3 seconds.

Slopping it up so hard that git was the bottleneck absolutely should not be the brag they think it is.

Though already CI/CD pipelines were choking on the unit tests. So they aren't *free*.

Had an LLM generated request that was pretty straightforward, and the LLM generated 272 unit tests for a very simple function. Can't really afford that.

Also, despite the 272 unit tests, when I tried to try it out in the way a human would, it immediately failed. All the mocking the AI generated never actually properly imitated the real world. However, the submitter was *quite* proud of having hundreds of unit tests, despite them being, in this scenario, utterly worthless.