I think we're in a new enough situation that we can look beyond what's legal in a license. When many of us started working on open source projects, AI was a far-off concept. Speaking for myself, I thought we'd see steady improvement in code-completion tools, but I didn't think I'd see anything like GPT-4 in my lifetime.
Licenses were written for humans working with code. We can talk about corporations as well, but when I've thought about corporations in the past, I thought about people working on code at corporations. The idea of an AI using my open source project to generate working code for someone or some corporation feels...different.
Yes, I'm talking explicitly about feelings. I know my feelings don't impact the legalities of a license. But feelings are worth talking about, especially as we're all finding the boundaries of new tools and new ways of working.
I don't agree with everything in the post, but I think this is a great conversation to be having.
Free software has a principle of "freedom to run, to do whatever you wish" (freedom 0), so arguably has said that training AI is OK. (We could quibble over the word Run, but the Gnu.org,and RMS clearly say "freedom 0 does not restrict how you use it."
GPL code can be used by the military to develop nuclear weapons. Given that the is a guiding principle of the FSF its hard to argue that the current usage is not OK.
The problem is Copilot training on source code and then discarding any restrictions of the licenses. Maybe it is legal right now but I'm sure this case will find it's way into open source licenses pretty soon.
Additionally I'm not sure if AGPL does anything.
I suspect the ethics and such of licensing when large fractions of work are training AI and using AI need to be worked out rather than getting mad at any individual.
What does copy left look like for AI?
I can only hope, that lawmakers hurry to catch up with reality and impose transparency obligations for AI models.
When a person learns from GPL code this question doesn't arise. The state of a person's brain is outside of copyright. But is the state of an LLM also outside of copyright or outside of the terms covered by the GPL? I'm not sure.
An LLM can not only emit source code derived from code published under the GPL, it can also potentially execute a program and could therefore be considered object code.
This isn't necessarily a problem as long as the model isn't distributed and does not include any AGPL code.
It clearly isn’t. Which is why clean-room reverse engineering always requires at least two people. Or why a musician that accidentally recreates a chord progression they heard years ago but don't remember the source might still get sued.
When I read and remember a text, possibly also learning from it, I'm not making a copy and I'm not creating a derivative work. The state of my brain is outside of copyright. Only at the point where I create a new representation based on what I have read I may be violating someone's copyrights.
But is it the same for an AI? Is the act of reading, remembering and learning (i.e. adjusting model weights) not in itself tantamount to creating a derivative work?
Is it actually? If we could fully pull out the state of your brain, and understand that you stored a copy of a copyrighted work, I think you could be on the hook for licensing it, paying fees every time you remember the work as a performance of it.
They don't impact the current legality of a licence, but it will affect future ones.
GPL/BSD/Apache/proprietary, they are all picked for ideological concerns which all stem from feelings. It is good to discuss these things, and it is good to recognise that these are emotionally driven.
Don't they? Even the most liberal licenses require that you at least keep the license and attributions. Which are exactly the parts that AI systems remove. I would have no problem with an AI system trained on GPL code if the output was still covered by the GPL.
It's the licence I choose for new projects.
edit: to clarify, he's allowing you to _use_ it however you like, including making a derivative work, including it wholesale, etc. However, claiming authorship of the original code would still run afoul of the original copyright.
edit2: oh - if you mean relicensing the code - that is allowed.
The reality is, these models don't copy or distribute anything directly, which makes applying copyright a bit of a stretch. Many people feel like it is a use that should have some sort of IP law applying to it, which is why I think there's some chance that courts or legislators will decide to screw the letter of existing law and just wedge new interpretations in, but it's not super simple: they'd have to thread the needle and not make things like search illegal, and that's tricky. Besides that, these models are out there, they're useful, and if they're ruled infringing they'll just be distributed illegally anyways.
I don't envy the people who will have to decide these cases, I suspect what's better for the world overall is to leave the law as-is and clarify that fair use holds (nobody will stop publishing content or code just because AI is slurping it up, a few weirdos like the article author excepted), but there are going to be a lot of pissed off people either way...
If they rule that it's ok to do that, I might be ok with AI being ruled as fair use.
It's the whole point of the discussion… is it really?
And if it's not fair use to train on windows source code because of copyright… doesn't that same copyright law cover everything else as well?
Just like Covid introduced epidemiological terms to the general public, this issue can introduce design choices around licensing, copyright and watermarking to more people.
I assume there is a group of researchers building tools to provide fine-grained historical views into AI output. And yes, for billions of parameters trained on billions of documents, linking every letter to a source document is a UX nightmare.
But what a cool problem. That's the interesting part. Yeah, something like TileBars[1] or Seesoft[1] seems like the right tool. But maybe keeping it all text with some graphical marker of authenticity is the better choice.
So many cool problems. But, that authenticity marker is the hard sell. Can enough sane discussions be enough to introduce that, or is drama required?
https://people.ischool.berkeley.edu/~hearst/irbook/10/node7....
There are plenty of arguments to choose a licence, and as the world changes we will evolve. See how the GPL itself evolved to handle TiVo. These things arent static.
I personally agree that GPL trained code should produce GPL code, I see a distiction between teaching people and teaching computers but that isn't my call.
This is exactly what code laundering ANNs circumvent and that might open up a dystopian future for all of us, not only us code monkeys, but society in general.
Or, perhaps more commonly, they were picked for business model reasons or (related) because building a community that includes commercial interests tends to favor more permissive licensing.
This may seem a bit nitpicky and philosophical, but anyway: these feelings you mention are about things, and these things the feelings come from are what is most important. Feelings are never standalone, if they are they are just moods which are so personal its hard to have a conversation over.
Let's call 'the things' values. I'd say feelings are perceptions of values, and as such they invariably have a conceptual element to them. And exactly that conceptual aspect makes them suitable for conversation and sometimes even debate, insofar as they can be incorrect. We can acknowledge the subjective, emotive aspect of feelings as highly and inalienably personal, respect the individual opinion behind them and contest the implicit truth-claims all at the same time.
All software licences are based on copyright, same as writing, art, music, etc. Some software licences are permissive. Some writing is permissive (e.g. Cory Doctorow). Some music is permissive (e.g. Amanda Palmer). It entirely depends on what the author wants. The fact that more software is permissive is a good thing, right?
I entirely agree that there are ethical problems with training AI on copyrighted training data. But please let's not start gatekeeping this. We need to have a serious discussion as a culture about it, and saying "you're way down the list of victims" isn't helping.
The tech community has a tendency to not care about issues like this until it effects us. I’m not telling people to shut up about this. I’m saying don’t be a hypocrite. If this is the wrong approach for GitHub, it is a problem with the way all these AI are trained.
You are allowed to care about the things you care about and not have a concrete well-informed opinion on something related that might be more pressing. It only becomes hypocricy as soon as you actively dismiss the other thing as if you were well-informed. And I don't see anyone here doing that.
Broken logic.
What I disagree with is the idea, that they should therefore not complain, or that there could not be an AI system, that does not code laundering, but keeps licenses in place and does this ethically and in an honest way. Adding "ethically" and "honest way", because I am sure that companies will try to find a way around being honest, if they ever are forced to add back the licenses.
In fact, artists might not be the group, that grasps the impact of training on that corpus as quickly as the dev communities. Perhaps it is exactly the devs, who need to complain loudest and first, to have a signal effect.
The busybox authors disagree: https://busybox.net/license.html
§5.c of the GPL Version 3 states explicitly:
> You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.
As in, all modifications must be made available. Is that not meeting your definition of giving back? GPL (all variants) is one of the most widely distributed of the free software licenses and has an explicit "give back" clause as far as I can see it. -- and is part of why some people referred to GPL as a "cancer".
FWIW the issue I've come to have with copilot is that you're not explicitly permitted to use the suggestions for anything other than inspiration (as per their terms), there is no license given to use the code that is generated. You do so at your own risk.
But that's ok. If upstream is somewhat active then it's just a pain to keep maintaining your in-house patches, compared to sending them upstream. So that's automatically a motivator. If upstream is not active, then it does not matter anyway.
If I host GPL software on a webserver and my users use that webserver, I don’t have to give them the source code for modified GPL programs. This is fairly common.
Available to all users. Not previous authors. There may be overlap, or there may not be overlap.
Plus, I would say it's giving forward, not back. If there are public users then the original authors can become users and get the code. But there will be bug fixes and features smooshed together.
Which is why i posit that there's no "give back" concept in the license. Only "give forward".
then that's a problem- not dissimilar to
^
If you want to get a better picture of the situation, read up on the licenses and what they do, specifically the term "copyleft".
I make this point because it causes confusion. Saying "my OSS project is being run by others for money and I get none of it" is confusing, as it uses the supertype. Using the subtype is clearer, and even self-explanatory: "my project I licenced so others can make money from it while giving me none is being run by others to make money from it and I get none".
That may be a bad situation, but at least the reasons are now clear.
No! That's a gross misrepresentation of what open sourcing is. It's the offer of a deal. You publish the source code and in return for looking at it and using it for sth, I have obligations. Like attribution and licensing requirements regarding derived works.
You can read licensed code, learn from it, and then write your own code derived from that learning, without having committed a copyright violation.
You can also read licensed code, directly copy paste it into your codebase, and still not have committed a copyright violation, as long as you did so in a way that constituted fair use (which copy-pasting snippets certainly would).
There’s no copyright issue here at all, and rationally speaking there aren’t any legitimate misuse of open source concerns either. If these people were honest they’d just admit to feeling threatened by AI, but nobody would care about that, so they just try to manufacture some fake moral panic.
If it's not a hard derivation, then it's difficult to prove or even notice.
I as a programmer touched X during training (learning how to code). Is all my work now derivative because of that?
Now factor in that machine models don't have a fallible or degrading memory and I think the answer is quite clear.
An important difference is that AIs are much cheaper than a human. Having a library reimplemented by a human usually isn’t cost-effective, but having it done by an AI may become viable. That could cause a major change in the open-source dynamics, while possibly also reducing average software quality (because less code is publicly scrutinized).
In essence, copyleft licenses are exactly that. They oblige the author of a derived work to publish the changes to all users under the same terms. The original authors tend to be users. So, a license which would grant this directly to the original authors would end up providing the same end result since the original authors would be both allowed to and reasonably expected to distribute the derived work to their users as well.
This aligns with the reason why some people publish their work under copyleft licenses: You get my work, for free, and the deal is that if you find and fix bugs then I get to benefit from those fixes by them flowing back to me. Obviously as long as you only use them privately you are not obliged to anything, the copyleft author gives you that option, but once you publish any of this, we all share the results.
That's the spirit here and trying to argue around that with technicalities is disingenuous. That's what Copilot does since it ignores this deal.
Speaking generally, I'm not sure that one can claim
>> The original authors tend to be the users
There are endless forks of say emacs,and I expect RMS is not s user of any of them.
Of course RMS is free to inspect the code for all of them, separate out bug fixes from features, and retro apply it to his build. But I'm not seeing anything in any license that requires a fork to "push" bug fixes to him.
>> This aligns with the reason why some people publish their work under copyleft licenses: You get my work, for free, and the deal is that if you find and fix bugs then I get to benefit from those fixes by them flowing back to me.
I think you are reading terms into the license that simply don't exist. I agree a lot of programmers -believe- this is how Free Software works, and many do push bug fixes upstream, but that's orthogonal to Free Software principles, and outside the terms of the license.
>> That's the spirit here and trying to argue around that with technicalities is disingenuous.
Licenses are matters of law, not spirit. The original post is about this "spirit". My thesis is that he, and you, are inferring responsibilities that are simply not in the license. This isn't a technicality,it goes to the very heart of Free Software.
Consider Linux. It's huge and most vendors really don't want to maintain a fully independent fork. One reason they might do it anyway, is if they could keep their patches private. But the GPL means they can't, so most just choose to upstream patches.
But that's a downstream decision regarding efficiency in their developing process. That's not what free software is about, there is nothing about that in its principles nor licences.
That's just Development Process and maintenance decision, offloading patch integration to upstream, which they might or not accept depending on your changes. None of that is about Free Software. You can see similar decisions/trade-offs taking place in any org with multiple software dev teams with ownership over libs etc, regardless if it is free software or not.
But also, i think even the spirit of the original copyleft movement is being misunderstood. As a GP said, the spirit was about centering users, requiring developers to be responsible to _users_, in order to create the kind of society where our _use_ of technology would be unconstrained in certain ways.
It was not about anything owed to the "original" developers, it was not about developers responsibility to other developers. In original spirit, even. It was definitely not about creating a system where people could make adequate income from writing software. That was not even the spirit in which the licenses were devised.
not really.
All this Free Software movement started by something really similar to "right to repair", a firmware bug in a printer that was proprietary software. Free Software is about being in control of software you use. The spirit was never "contribute back to GNU", the spirit was always "if you take GNU software, you can't make it non-free". Those GNU devs at the time just wanted a good and actually free/libre OS, that would remain free no matter who distributed it.
You are using expectations of modern day devs in the world of a lot of social development thanks to Github.
You might claim that GP was using the technicalities of the licences, but you can actually check the whole FSF philosophy an you note that they align perfectly with "giving forward" not "giving back".
Free Software is about user's freedom. Not dev rights, or politeness, etc. Now obviously, some devs picked up copyleft licenses with the purpose of improving their own software from downstream changes (Linus states that is the reason he picked GPL), but that's a nice side effect, not the purpose. Which ofc, with popular social sharing platforms like github, those things gets confused.
Distinction without a difference. The end result is the same.
GPL software is a box that must be kept open, so that everybody would be able to take from it.
If you pick the box and build an altered version of it, you must keep it open, you are legally prohibited from attaching a lid to it.
There's nothing about any expectations, let alone obligations, to put anything back into the original box. Usually it's not very easy (you must follow strict standards) or even impossible (see e.g. SQLite).
The same goes for Apple and Google's OSS browser. The source is there, but there is more or less no way to give back, and they certainly don't.
Well, license obliging the original author to take patches back would be weird one.
But Google could suck in any change to their own and make it better.
> The same goes for Apple and Google's OSS browser. The source is there, but there is more or less no way to give back, and they certainly don't.
That's a different problem that's a bit orthogonal to licensing and has more to do with project leadership. Like, you don't even need to have OSS license to allow users to contribute to project.
> The freedom to distribute copies of your modified versions to others (freedom 3). By doing this you can give the whole community a chance to benefit from your changes. Access to the source code is a precondition for this.
Emphasis in "give the whole community a chance to benefit from your changes".
1. https://www.gnu.org/philosophy/free-sw.en.html#four-freedoms
You can try to fork it into something workable, but that can sometimes literally mean trying to figure out what the actual deployment process is and what weird tweaks were done to the deploying device beforehand. In addition, forking those projects is also unworkable if the original has pretty much enterprise-speed development. At best you get a fork that's years out of date where the maintainer is nitpicking every PR and is burnt out enough to not make it worthwhile to merge upstream patches. At worst, you get something like Iceweasel[0] where someone just releases patches rather than a full fork (and having done that a few times, it's a pain in the neck to maintain those patches).
FOSS isn't at all inherently community-minded; it can be and can facilitate it, but it can also be used as a way to get cheap cred from the people who are naïeve enough to believe the former is the only place it applies.
[0]: "Fork" of Firefox LTS by the GNU Foundation to strip out trademarked names and logo's. It's probably one of their silliest projects in term of relevancy.
I might be in the wrong, but this is not how I understand GPL [0]. Care to correct me if I'm wrong.
What I get from the license is that you have to share the code with the users of your program, not anyone else.
AFAIK you could do an Emacs fork and ask money for it. Not only that but the source code only needs to be available to the recipients of the software, not anyone else.
A company could have an upgraded version of a GPL tool and not share it with anyone outside the company. Theoretically employees might share the code outside, but I doubt they'd dared.
[0] https://www.gnu.org/software/emacs/manual/html_node/emacs/Co...
You're correct, but it's sort of a meaningless distinction because those users are entirely within their rights under the GPL to share that code on with anyone they want, which is why we don't really see the model of "secret GPL" you describe, in the wild.
GPL code has to be shared with users who receive binaries. SAAS happily didn't shop binaries, so quite legally didn't ship source code.
AGPL redefines this in terms of "user" not "binary". That refinement completely exists to cater for unexpected use cases. No doubt new licenses (AIGPL?) will be needed to address this issue.
The whole need for Open Source protection played out with the (Apache licensed) Elastic Search. Switching to a ELv2 and SSPL license was controversial and in some ways "not open source", certainly not "free" because it limits what a user can do with the software.
So the distinction is far from meaningless and in some ways rendered GPL obsolete.
First, I am not a lawyer, but don't licenses exist precisely for their technicalities? This is not like a law on the books in which case we can consider the "Letter and Spirit of the law" because we know in what context in which it was written in/for. With a written license however, someone chooses to adopt a license and accepts those terms from an authorship point-of-view.
Well I guess you know why you may be hated for this already. For anyone who has surf HN since ~2010 would know or should notice the definition of open source has changed over the past 10-15 years. Giving Back and Communities are the two predominant Open Source ideals now. Along with making lots money on top of OSS code being somewhat a contentious issue to say the least.
But I want to side step the idealistic issue and think this is more of an economic issue. Where this could be attributed as a zero interest rate phenomenon. You now have developers ( especially those from US ) for most if not all of their professional life living under the money / investment were easy, comparatively speaking. And they should give back when money ( or should I say cash flow ) isn’t an issue. When $200K Total Comp were suppose to be the norm for fresh grad joining Google. And management thinking $500K is barely enough they need to work their way to $1M, while seniors developer believes if Junior were worth $200K than they are asking for $1M total comp is perfectly sane, or some other extreme where everyone in the company should earn exactly the same.
If Twitter or social media were any indication you see a lot of these ideals were completely gone from the conversation. Although this somehow started before the layoffs.
It is somewhat interesting to see the sociologic and idealogical changes with respect to economics changes. But then again, economics in itself is perhaps the largest field psychology study.
You suggest I try it twice and since it will probably not copy paste in those 2 tries, assume it never copy pastes (despite existing evidence that it does copy paste in some other cases).
What problem would this exercise solve? I can't see it.
But yes, exactly, you never know if a snippet came from another project or not, so let's not assume it did without some convincing evidence.
The fact that you tried it a couple of times (or 10 or 20) means absolutely nothing.
1 copyright infringement is enough for a lawsuit.
In Uni, students run their theses through plagiarism checkers, even if it's novel research as it naturally occurs.
As the thought experiment goes, given infinity, a monkey with a typewriter will inevitably write Shakespeares works.
Exactly. People are getting mad that Microsoft is making good money while the people who made all that free software available mostly did it for free (like in no money and no recognition). It can sound unfair but that's the deal. If you didn't want people or AI to learn from your code, open source was not the right option.
There's nothing wrong with other people using - learning and creating derivative works of - one's open-source code, provided they respect the terms of the license. It seems to me that the real issue is the fact that these licenses don't have enough teeth.
You're right. It's a politeness law some people have invented.
It's also a value people have, but that's for themselves. I like contributing to OSS projects. But, as soon as it's imposed on others, and there are punishments for disobeying, it's a politeness law.
Not "if". We know it does.
And since it doesn't show citations, it might be the case that you use and mistakenly end up making your entire software GPL, because of including copy pasted GPL software.
Whether you were trawling Usenet or just a presence in your local BBS scene, "teach it forward" was always a core concept. Still is. It's difficult to pay back to the person who taught you something valuable, so you can instead pay it forward by teaching the lessons - along with your own additions - to the later newcomers.
Of course the Eternal September changed the landscape. And now we can't have nice things.
0: https://en.wikipedia.org/wiki/Etiquette_in_technology#Netiqu...
> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
Does GPT spit out the copyright notice when it regurgitates my code?
1) We don't know when/if GPT will. GPT in its current form can't seem to guarantee safety (either from "substantial" verbatim snippets or from complex "hallucinations" of random pachinko output).
2) GPT doesn't know when/if it has. GPT in its current form likely cannot know this. (In part, because it doesn't really "know" anything, that's too anthropological a word for what is still mostly just a casino full of pachinko machines.)
3) Define "substantial portions" in a way that a jury of your peers can understand it in a court of law.
4) Can you define "substantial portions" again, only this time in code as guide rails for something like GPT? "Substantial portions" is barely a human term designed for human lawyers and courts. There's a fascinating challenge here on quantifying it.
If we were somehow able to prevent AI models from ingesting a codebase, that would mean everyone else who wants to produce similar code would have to re-invent the wheel, wasting their time repeating work that has already been done.
All because... the person who did it first wants attribution? They want their name to be included in some credits.txt file that nobody will ever read? That's ridiculous.
Yes, and yes. Those would be the terms that person publishes their code under. If you can't agree to those terms - maybe because including a single name in a credits.txt file that no-one reads is somehow too onerous for your process - then you are always free to re-implement that code on your own.
GPL, for instance, merely states that distributed sources or patches "based on" the program should be "conveyed" under the same terms. In other words, anyone who gets their hands on it will do so under the same license.
If anything, I would be worried that GitHub trained itself on publicly-available but not clearly licensed code, because then it would have no license to "use" it in any way[0]. GPL provides such a right, so there is no problem there. It would be even more worrying if the not clearly licensed code was in a private repository but I think I remember reading that private repositories were not included in the training data.
However, would you consider a black box program, of which the output can consistently produce verbatim or at the very least slightly modified copies of code from GPL code to be transformative? The problem does not lie in how the code is distributed but in how transformative the distributed code is. Not only does the same apply to any program besides AI-powered software, it applies to humans[1].
Given how unpredictable the output of an AI is, one should not be able to train itself on GPL code if it cannot reliably guarantee it will not produce infringing code.
[0]: https://docs.github.com/en/site-policy/github-terms/github-t... (https://archive.ph/susi0#4-license-grant-to-us)
[1]: One such example would be how Microsoft employees allegedly prevented themselves from reading refterm source code, cf. https://github.com/microsoft/terminal/issues/10462#issuecomm...
Licensing operates on a continuum of permissiveness. They can only relax the restrictions that you as a creator are given by default. You can't write a copyright license that adds them. You could write a legal instrument that compels and prohibits certain behavior(s), but at that point you're talking about a contract. (And there's no way to coerce anyone to agree with the contract.)
Harry Potter has even more restrictions than the GPL or any other open source license. It's "All Rights Reserved—it enjoys the maximum protections that a work can. And yet it would still be possible feed it into an AI model, even if all of Rowling, Bloomsbury, and Scholastic didn't want you to. They don't get a say in that. Nor do open source software developers in their works which selectively abandon some of the protections that Rowling reserves for herself and her business partners.
The only real viable path to achieve this using an IP license alone would be a React PATENTS-like termination clause—if your company engages in any kind of AI training that uses this project as an input, then your license to make copies (including distributing modified copies) under the ordinary terms are revoked, along with revoking permission for a huge swathe of other free/open source software owned by a bunch of other signatories, too. This is, of course, contingent upon the ability to freely copy and modify a given set of works being appealing enough to get people to abstain from the lure of building AI models and offering services based on them.
Taken to its logical conclusion, you could add the notion of Free Humans are legally bound to only produce Free Ideas. One could imagine this functioning like sort of monastic vow of charity or chastity. "Vow of silence on producing anything which is not Free (as in freedom)."
Would you take such a vow if offered 100,000 USD/year for the rest of your life (adjusted for inflation)? I would.
The problem is that the Copilot project doesn't claim to be abiding by the license(s) of the ingested code. The reply to licensing concerns was that licensing doesn't apply to their use. So unfortunately they would just claim they could ignore your hypothetical Free³ license as well.
I think github is largely correct in their view on licenses. However I would argue that you could create a stronger legal binding than say a GPL-3 license. For instance you could require and enforce that anyone that wishes to read the repo must sign a legal contract or EULA: "By decrypting this git repo you are agreeing to the following licenses, restrictions, contractual obligations, ..."
I'm not aware of any Open Source license,or Free license for that matter,that has a give-back clause. Source code is available to -users- ,not prior-authors.
Some Open Source licenses can be used in proprietary code, (MIT, BSD etc) with little more than simple attribution.
Those developers chose that license for a reason, and I've got no problem with commercial entities using that code.
There is a valid argument to be made about the training of models on GPL code. (Argument in the sense that there's two sides to the coin.) On the one hand we happily train humans on GPL code. Those humans can then write their own functions,but for trivial functions they're gonna look a lot like GPL Source.
If the AI is regurgitating GPL code as-is, then that's a problem- not dissimilar to a student or employee regurgitating the same code.
But this argument is about Free software licenses,not really (most?) Open Source licenses.
Either way OSS/Free is not about "giving back",its about giving forward.
In the specific case here of co-pilot making money,I'd say A) you're allowed to make money from Free/OSS code. B) no one is forcing you to use this feature.