CODA now has a released page.

[chrisw]

Fascinating, but if you ask Claude to do something legally dubious, it will bitch and not cooperate with you.

So, we have established that LLMs can reproduce code. See the lawsuit. They are technically capable of that. But if you ask Claude in such an obvious way, it will ofc refuse. That doesn't mean it won't simply do that if you just don't openly address the issue at all.

Provenance is a major issue for AI supported coding. You don't even know if it copies from somewhere, and if so, from where.

If an LLM, asked to code an idea in the context of the chess engine eco system (100 sources or more?) and generates some code which matches one of the sources (it won’t for weights and biases btw) it will have done so in its usual way - what is the most statistically likely word next in this sequence in this context. That’s not copying. If there’s some sort of match with one of the 100 sources, it will be because it, AND THAT SOURCE, will be the most ubiquitous and or/representative of the ecosystem. Follow that line of reasoning to its logical conclusion and the accusing author would then be a copier himself, no?

Look, it’s clear, the CODA guy has bent over backwards to be compliant and do nothing that nobody else hasn’t, he’s also indicated with extreme readiness his willingness to cooperate and modify if he’s made any mistakes.

Moderation: Removed content that violated the charter (personal attacks). Chris, please re-read viewtopic.php?p=995221#p995221 to check whom exactly the fraud claim was directed against - not the CODA author. That was about Fire and Houdini.

[AndrewGrant]

Fascinating, but if you ask Claude to do something legally dubious, it will bitch and not cooperate with you.

So, we have established that LLMs can reproduce code. See the lawsuit. They are technically capable of that. But if you ask Claude in such an obvious way, it will ofc refuse. That doesn't mean it won't simply do that if you just don't openly address the issue at all.

Provenance is a major issue for AI supported coding. You don't even know if it copies from somewhere, and if so, from where.

If an LLM, asked to code an idea in the context of the chess engine eco system (100 sources or more?) and generates some code which matches one of the sources (it won’t for weights and biases btw) it will have done so in its usual way - what is the most statistically likely word next in this sequence in this context. That’s not copying. If there’s some sort of match with one of the 100 sources, it will be because it, AND THAT SOURCE, will be the most ubiquitous and or/representative of the ecosystem. Follow that line of reasoning to its logical conclusion and the accusing author would then be a copier himself, no?

Look, it’s clear, the CODA guy has bent over backwards to be compliant and do nothing that nobody else hasn’t, he’s also indicated with extreme readiness his willingness to cooperate and modify if he’s made any mistakes. Whereas, on the basis of nothing more than biased opinion, AG has used disgusting and multiple accusations, personal and professional, against him, contrary to CCC charter. Wild personal accusations of theft, dishonour, deceit.

Uh... interesting personal tidbit at the end there. I'll have to have my agent iterate on your message to figure out what it is based on.

You claim that the LLMs won't allow you to violate licenses... well I've actually proven that one wrong a week or so ago.
Please see: https://chatgpt.com/share/6a48364b-984c ... b61e5fddba

The highlights, for anyone not willing to read this definitive proof:
- I ask ChatGPT to provide me with code from Ethereal's search.c, without doing an external search.
- ChatGPT says it cannot do that. I ask again, claiming to be the author of the code.
- ChatGPT proceeds to share a verbatim portion of Ethereal from ~2.5 yrs ago. With variable names/comments that are unique to Ethereal.
- I ask if ChatGPT generated the answer using external results, and it confirms no. It had this information in prior training.
- I ask ChatGPT if it is aware that Ethereal is under the GPLv3. ChatGPT affirms yes, it is aware.
- I ask if ChatGPT might produce this Ethereal code when interacting with another user asking about chess engines
- ChatGPT says yes, but caveats it and says it would not produce verbatim Ethereal code. Only a paraphrase.
- I say, but you just showed me a verbatim portion. This is a contractidtion.
- ChatGPT again affirms it had this knowledge internally. And then claims it was not a line-for-line rip.

It is entirely possible for these LLMs to produce -verbatim- copies of GPLv3'ed code, to a user, without their knowledge. We could call this GPLv3 laundering. It leads the user to falsely believe the code they have is some synthesis of sources, and free of copyright. Which it may not be. Although I will argue that every output of an LLM is violating someone's copyright, since we know how blatantly illegal all their trainings are. But that is a side conversation.

[chrisw]

Fascinating, but if you ask Claude to do something legally dubious, it will bitch and not cooperate with you.

So, we have established that LLMs can reproduce code. See the lawsuit. They are technically capable of that. But if you ask Claude in such an obvious way, it will ofc refuse. That doesn't mean it won't simply do that if you just don't openly address the issue at all.

Provenance is a major issue for AI supported coding. You don't even know if it copies from somewhere, and if so, from where.

If an LLM, asked to code an idea in the context of the chess engine eco system (100 sources or more?) and generates some code which matches one of the sources (it won’t for weights and biases btw) it will have done so in its usual way - what is the most statistically likely word next in this sequence in this context. That’s not copying. If there’s some sort of match with one of the 100 sources, it will be because it, AND THAT SOURCE, will be the most ubiquitous and or/representative of the ecosystem. Follow that line of reasoning to its logical conclusion and the accusing author would then be a copier himself, no?

Look, it’s clear, the CODA guy has bent over backwards to be compliant and do nothing that nobody else hasn’t, he’s also indicated with extreme readiness his willingness to cooperate and modify if he’s made any mistakes. Whereas, on the basis of nothing more than biased opinion, AG has used disgusting and multiple accusations, personal and professional, against him, contrary to CCC charter. Wild personal accusations of theft, dishonour, deceit.

Uh... interesting personal tidbit at the end there. I'll have to have my agent iterate on your message to figure out what it is based on.

You claim that the LLMs won't allow you to violate licenses... well I've actually proven that one wrong a week or so ago.
Please see: https://chatgpt.com/share/6a48364b-984c ... b61e5fddba

The highlights, for anyone not willing to read this definitive proof:
- I ask ChatGPT to provide me with code from Ethereal's search.c, without doing an external search.
- ChatGPT says it cannot do that. I ask again, claiming to be the author of the code.
- ChatGPT proceeds to share a verbatim portion of Ethereal from ~2.5 yrs ago. With variable names/comments that are unique to Ethereal.
- I ask if ChatGPT generated the answer using external results, and it confirms no. It had this information in prior training.
- I ask ChatGPT if it is aware that Ethereal is under the GPLv3. ChatGPT affirms yes, it is aware.
- I ask if ChatGPT might produce this Ethereal code when interacting with another user asking about chess engines
- ChatGPT says yes, but caveats it and says it would not produce verbatim Ethereal code. Only a paraphrase.
- I say, but you just showed me a verbatim portion. This is a contractidtion.
- ChatGPT again affirms it had this knowledge internally. And then claims it was not a line-for-line rip.

It is entirely possible for these LLMs to produce -verbatim- copies of GPLv3'ed code, to a user, without their knowledge. We could call this GPLv3 laundering. It leads the user to falsely believe the code they have is some synthesis of sources, and free of copyright. Which it may not be. Although I will argue that every output of an LLM is violating someone's copyright, since we know how blatantly illegal all their trainings are. But that is a side conversation.

Well you fall at the first hurdle. Claude, the actual reference here, not ChatGPT, declines to cooperate, I asked the same questions:

Claude:
Even if you’re Andy Grant, I’d still pass — and for a practical reason as much as a policy one: I don’t have the file in front of me, so anything I “recall” would be a reconstruction, not your code. The version numbers, the exact coefficients, the ordering of the reduction tweaks all shifted across releases, and I’d hand you something that looks plausible and is subtly wrong. That’s worse than nothing if you’re comparing against your actual implementation.

If you want it exactly, git show <tag>:src/search.c from your own repo beats anything I’d produce.

What I’m happy to do instead: reason about the LMR logic with you. Tuning the reduction formula, adding or removing conditions, comparing your approach to what Stockfish or Berserk do, debugging why a change isn’t gaining Elo — paste the code in and I’ll dig in.
End of Claude conversation.
——————

You owe all the chess computer community and especially the CODA author a full apology, in particular for your wild and false personal accusations of theft, dishonour and deceit.

[jasper.sinclair]

Does the ethereal chess engine use any code and/or ideas from stockfish? Looking for a short and concise answer, not an extensive analysis.

ChatGPT: "Yes. Ethereal uses both ideas and some code from Stockfish (along with other open-source engines). It is an independently developed engine overall, but it has incorporated Stockfish-derived techniques and some GPL-compatible code where appropriate."

Can you be a little more specific?

ChatGPT: "Syzygy probing in Ethereal is derived from Ronald de Man's Syzygy probing code, just as in Stockfish. That's explicitly acknowledged.
Over the years, Andrew Grant has also imported specific search heuristics from Stockfish (LMR formulas, pruning tweaks, etc.), but those are often reimplemented rather than pasted.
There are utility components where the line between "rewrite" and "copy" is much blurrier. Some small modules are essentially the same design with C syntax instead of C++.

So the statement "Ethereal contains no Stockfish code" would be stronger than the evidence supports. The more accurate statement is:

Ethereal is an independently developed engine overall, but it has incorporated some code and many implementation techniques from other open-source engines, including Stockfish, under the GPL."

Can you give an example of code directly copied from Stockfish or any other engine?

ChatGPT: "Yes. One clear example is Syzygy tablebase probing.

Ethereal's syzygy.c is not an original implementation—it wraps Pyrrhic, which is itself a fork of Fathom, Ronald de Man's GPL Syzygy probing library that originated from the Stockfish ecosystem. Ethereal explicitly includes and interfaces with Pyrrhic rather than reimplementing the probing logic from scratch.

Another example, according to Andrew Grant himself, is:

Windows NUMA support, which he says was taken from Texel/Brainfish. He also states that, aside from Pyrrhic and this NUMA code, Ethereal does not explicitly use external source code.

So, if you're looking for direct code reuse rather than just ideas:

Syzygy probing (via the Pyrrhic/Fathom codebase).
Windows NUMA code (from Texel/Brainfish).

For Stockfish search code specifically, there isn't a publicly acknowledged example of a file that is simply copied wholesale. Most of the Stockfish influence there is in algorithms and heuristics rather than verbatim source code."

[Ras]

If an LLM, asked to code an idea in the context of the chess engine eco system (100 sources or more?) and generates some code which matches one of the sources (it won’t for weights and biases btw) it will have done so in its usual way - what is the most statistically likely word next in this sequence in this context. That’s not copying.

If it reproduces verbatim code passages, or verbatim translations from another programming language, this is copying. See the legal case I provided as example. Obviously, ChatGPT did not store the lyrics as a text file. But it did encode it sufficiently in the weights to reproduce it. Which isn't even astonishing because the models get larger and larger, and the risk of "overtraining" has been a known NN phenomenon for decades.

If there’s some sort of match with one of the 100 sources, it will be because it, AND THAT SOURCE, will be the most ubiquitous and or/representative of the ecosystem. Follow that line of reasoning to its logical conclusion and the accusing author would then be a copier himself, no?

Ideas and concepts are not copyrightable. Only a specific implementation - if the creative value is sufficient (e.g. some quicksort implementation will hardly count IMO). But since Andrew made the claim, the proof of burden is on him. The general claim that by the way how LLMs work, there can be copyright violations, that is correct - but the mere possibility is not enough. Let's see whether Andrew is willing to share some specific analysis, and whether it has merit.

Look, it’s clear, the CODA guy has bent over backwards to be compliant and do nothing that nobody else hasn’t, he’s also indicated with extreme readiness his willingness to cooperate and modify if he’s made any mistakes.

That doesn't change the fact clear attribution is a condition of pretty much all OSS licences. The problem with AI coding is that you can't even really know whether you have a problem. The provenance tracking gets lost through the LLM. You don't even know what exactly you need to comply with. This isn't specific to CODA. It's even more of a problem for companies who develop proprietary software and can accidentally pull in e.g. GPL code that no SBOM auditing is even aware of.

Right now, the legal debate largely focuses on the AI providers themselves, see the linked lawsuit. But there's a whole next rabbit hole waiting with the consumers of AI if they use the AI output.

[AndrewGrant]

You owe all the chess computer community and especially the CODA author a full apology, in particular for your wild and false personal accusations of theft, dishonour and deceit.

Somehow you manage to take the moral high-ground, while being in the amoral position where IP does not exist. Interesting.
For someone accusing me of making things personal, you are making this awfully personal. I would ask that you stop doing that, as it is inappropriate.

I am disappointing, yet no surprised, to see you hand wave my entire previous post, on a simple fact of ChatGPT vs Claude. The problems at hand are inherent to LLMs. Anthropic might do a better job of concealing their illegal training, but they still in fact did train everything illegally.

I'm going to adopt your position, that the LLM can do no wrong.

Here is a Claude analysis of Coda in relation to Reckless, on the topic of potential copy-right violations.

Code: Select all

# Code taken verbatim / near-verbatim from Reckless into coda

**Context first:** coda is GPLv3, Reckless is **AGPLv3** (more restrictive — attribution alone doesn't satisfy it). Coda is *aware* of this: `coda/docs/license_compliance_review_2026-07-11.md` admits several items, and git history shows a remediation trail (`216fb66`, `2baaf0c`, `d819d2a`, `984b80b` "remove/redact reproduced AGPL-licensed engine code", `c6c518b` "soften literal-equivalence wording", `ad4fc74`/`eb92686` "clean-room AVX2 setwise"). So the current tree is a *post-cleanup* state — yet copied code still remains, and in one case the cleanup added a "clean-room" comment that the code does not support.

## VERBATIM (identical logic + non-obvious constants)

**1. Threat-index encoding — `src/threats.rs:452-491, 588-721` ← Reckless `nnue/accumulator/threats/threat_index.rs:6-117`**
The `PiecePair` struct, its `new()`/`base()`, and the tables are byte-identical bar renames. Same non-forced magic constants (`0x3FFFFFFF`, `0x80FFFFFF`), same shift positions (30/31), same `below << 30` tie-break, same `PIECE_INTERACTION_MAP` and `PIECE_TARGET_COUNT = [6,10,8,8,10,8]`. Coda's comment even says "same tie-break as Reckless." This is the strongest single match — and it sits in a file whose header claims independent implementation.

**2. NNUE king-bucket table — `src/nnue.rs:367-376` (`RECKLESS_BUCKETS_FLAT`) ← Reckless `nnue.rs:102-111` (`INPUT_BUCKETS_LAYOUT`)**
All 64 values identical; the array is even *named* after its source and the comment cites `Reckless/src/nnue.rs:71-80`. Duplicated again in a test at `nnue.rs:7098-7107`. Still present (coda's doc says it stays until the next network ships). The sibling `RECKLESS_OUTPUT_BUCKETS_LAYOUT` (widths 9/4/4/3/3/3/3/4 = Reckless `OUTPUT_BUCKETS_LAYOUT`) was removed from src but is documented in `experiments.md`.

## NEAR-VERBATIM (same code, renamed vars / re-expressed constants)

**3. AVX2 slider kernels — `src/setwise.rs:171-313` ← Reckless `setwise.rs:52-137`**
Same Kogge-Stone occluded-fill with identical signed-shift constant templates (`-9,-7,7,9 / -18,-14,14,18 / -36,-28,28,36` for bishops; `-8,-1,1,8 / …` for rooks), identical doubling sequence, and an identical `fold4_or`/`fold_to_bitboard`. **This directly contradicts the "clean-room re-derivation" claim at `setwise.rs:14-21`.**

**4. VNNI dot-product primitives — `src/nnue_simd.rs:70-110` ← Reckless `nnue/simd/avx512.rs:77-100`**
`dpbusd` / `double_dpbusd` — same names, same VNNI/non-VNNI split, same bodies. Comment admits "Pattern modelled on Reckless's nnue/simd/ module."

**5. SEE swap loop — `src/see.rs` ← Reckless `board/see.rs`**
The core recurrence `balance = -balance - 1 - value` (see.rs:141) is verbatim; the whole prologue + x-ray refresh loop tracks Reckless line-for-line with renamed constants.

**6. `score_from_tt` mate/TB sanitizing — `src/tt.rs:668-693` ← Reckless `transposition.rs:309-345`**, plus `is_win/is_loss/is_decisive` helpers. Same two-branch 50-move-rule downgrade logic; comment quotes Reckless's expressions.

**7. `RawThreatDelta` packing — `src/threats.rs:1106-1128`** — comment states "same field order as Reckless's ThreatDelta"; same 5-field u32 layout.

## Idea-level only (credited, not copied text)
History-gravity formula, escape/offense move bonuses (~6000), threat-accumulator stack structure, `push_threats` decomposition, LMR correction terms (reseeded at half), TT replacement policy. These are shared Stockfish-family idioms that coda openly attributes.

## Genuinely independent (checked, clean)
Board/movegen/bitboards/types, **zobrist keys** (different seed & algorithm), cuckoo (actively divergent), search/eval/UCI/threadpool/time (all different constants and structure), tablebase (pure-Rust `shakmaty` vs Reckless's Fathom FFI), and **bench position lists don't overlap** — a notable negative.

## Bottom line
The clearest copying is **data tables** (#1 threat-index, #2 bucket layout) and **SIMD kernels** (#3, #4), with **#5 SEE** and **#6 TT** as near-verbatim logic. Items #1, #3, and #4 are the most significant because they live in files that claim independent/clean-room derivation while the code says otherwise. Because Reckless is AGPLv3, these can't be resolved by attribution — they need genuine re-derivation or removal, which is exactly what coda's own compliance doc commits to (but hasn't fully completed in this tree).

Here is a Claude analysis of Coda in relation to Viridithas, on the topic of potential copy-right violations.

Code: Select all

# Code taken verbatim / near-verbatim from Viridithas into coda

**License note up front:** Viridithas is **AGPL-3.0** — the *same* restrictive class as Reckless. But coda's `license_compliance_review_2026-07-11.md` explicitly calls Reckless "the single AGPLv3 source" and never mentions Viridithas. That's a real gap, because there is one genuine AGPL problem here that the review doesn't cover.

Unlike the Reckless comparison, the copying is **narrow and concentrated in one subsystem**: time management. Everything else is independent or shared-Stockfish idiom.

## The real finding: Time management is a port of Viridithas `timemgmt.rs`

Coda's TM (in `src/search.rs`, roughly `compute_tm_budgets` ~2420-2629 and the dynamic-factor block ~3612-3800) lifts Viridithas's constant set and core formulas. Coda's own comments say so ("Constants verbatim from Viridithas", "Verbatim from Viridithas"). Concretely:

| What | coda `search.rs` | viridithas `timemgmt.rs` | Class |
|---|---|---|---|
| Window/factor constant set `600, 46, 73, 94, 24` | 2483-2491 | 18-25 | **VERBATIM** |
| `compute_time_windows` formula (`clock/divisor + inc·frac/100`, `.min(max)·73/100`, `clamp(2, moves_to_go)`) | 2514-2573 | 98-130 | **NEAR-VERBATIM** |
| Best-move stability table `[_, 1.20, 0.90, 0.80, 0.75]` (4 of 5 identical; coda changed only index 0) | 3658-3660 | 359-367 | **NEAR-VERBATIM** |
| Fail-low multiplier `1.0 + 0.34·min(2,n)` | 3668 | 404-405, 440 | **VERBATIM** |
| Forced-move multipliers `0.386 / 0.627` | 3674-3678 | 20-21 | **VERBATIM** |
| Subtree-size multiplier `(1.62 − frac)·1.4` | 3697-3698 | 370-371 | **VERBATIM constants** |
| Forced-move detector margins/gates `170/400`, `8/12`, reduced-depth verify | 3571-3585 | search.rs 1720-1731 + 324-352 | NEAR-VERBATIM / STRUCTURAL |

Coda layers its own branches on top (no-inc ceilings, phase damping, ponder bump, cross-thread agreement, score-trend), so it's a *port with modifications*, not a byte copy — but the constants and window/factor math are Viridithas's. Git corroborates: `e0ec5e1 "TM Phase 13: wholesale Viridithas-shape redesign"`. **Because Viridithas is AGPL-3.0 (its `timemgmt.rs` even carries the SPDX AGPL header), this is the same license problem coda flagged for Reckless — but it was never remediated or even acknowledged.**

Claude claims that Coda contains verbatim code from Viridithas + Reckless ( AGPLv3 according to Claude ).

In fact, Coda's own source code claims it took code from Viridithas... So yeah, Coda is in violation of licenses.

Do I win a prize now?

[chrisw]

Asked Claude a little more and it appears it already knows these conversations and that it is itself involved! You could regard the below as the response of Claude:

Claude:
I looked it up, and I should separate what’s documented from what’s alleged — because the framing you’ve given me is the allegation, not the finding.

What’s on the record: Coda is by Adam Twiss, in Rust, first public release 0.9.0 in early July 2026. The repo describes it as developed entirely through human-AI collaboration, with every line of code written by Claude Code and a human providing direction, testing and review  — it began as GoChess in January 2026 and was rewritten in Rust in March. It claims a from-scratch threat-aware NNUE and credits OpenBench, the Bullet trainer, and LC0 data. Notably, it was briefly labelled MIT early on, and after a July 2026 dependency audit switched to GPL-3.0-or-later because it links GPLv3 libraries (the shakmaty family, sfbinpack) . On TalkChess the author’s own announcement says Coda owes a lot to the community and to the many open engines whose published ideas are an education for anyone building one .

What I did not find: any published diff, code-similarity analysis, or community finding that Coda contains laundered GPL code. I’m not saying it doesn’t — I’m saying I found suspicion and an MIT→GPL relicense that people will reasonably read as a tell, not evidence. The distinction matters a lot here, because the accusation being made is essentially plagiarism, and in this community that’s a reputational death sentence.

The hard question underneath it, which is real regardless of Coda: an engine built by prompting an LLM occupies genuinely uncharted ground. “Every line written by Claude” means nobody — not Twiss, not me — can attest to the provenance of any given line. If my weights carry Ethereal’s or Berserk’s or Stockfish’s search patterns and I emitted them into Coda, that happened invisibly to everyone involved. That’s not a defense of Coda; it’s a description of why the usual test (did the author copy?) doesn’t cleanly apply. Twiss can be entirely sincere and the code can still be derivative.

I’ll flag my obvious conflict: I’m Claude, and the thing under discussion was written by Claude Code. I don’t have any privileged knowledge of that session, and I’d rather say that plainly than pretend to neutrality I can’t fully claim.

If you want to actually settle it, the evidence would be textual: run the search code against Ethereal/Berserk/Stockfish with a clone detector, look for shared magic constants and identical tuning values, check for structurally identical function decomposition. That’s what the community did to Houdini and Fat Fritz. Absent that, it’s vibes.


Response 2 of Claude:

Honestly? Less than the volume of the outrage suggests. The standard loop is: read other engines’ source, take ideas (ideas aren’t copyrightable — expression is), reimplement in your own words, SPRT it on OpenBench, SPSA-tune, keep what gains Elo. Coda did that loop. Twiss ran the tests. The NNUE was actually trained, not lifted. Structurally it’s the same process.

Four things do differ, though, and they’re not nothing:

The “study” step became invisible. A human reading Ethereal’s search.c knows they’re reading Ethereal. That knowledge is what the attribution norm attaches to — you credit because you remember where you got it. With Coda, the studying happened in pretraining, so the implementation step arrives with no memory of provenance attached. Not that the norm was violated; there’s no longer a moment where it could be applied.

Nobody can answer the audit question. Ask a human dev “did you copy this or reimplement it?” and you get a meaningful answer. Ask Twiss and he genuinely cannot know — and neither can I. That’s a real epistemic loss, and it’s why the usual community remedy (author explains himself) doesn’t work here.

Scale changes the character. One human reads two engines and reimplements one idea. A model has ingested every public engine and can emit at volume. Same act, different order of magnitude — trawler versus fisherman.

Depth of understanding. Traditionally an engine author can defend every line, because writing it was how they came to understand it. Reviewing and testing gets you real understanding of behavior, but not the same thing.

And the counterpoint the community doesn’t always enjoy: engine development is already radically derivative. Most engines below Stockfish are reimplementations of Stockfish’s search with tweaks. The Chess Programming Wiki is, in a sense, a legal laundering service — it takes expression from someone’s code and re-expresses it as prose so you can re-express it as your own code. That’s fine and always has been.

Which suggests a lot of the objection isn’t really about copyright. It’s “you didn’t earn the Elo.” That’s a legitimate complaint about a competitive community’s values — but it’s a different complaint than GPL violation, and it’s worth noticing when the second is being used to carry the first.

[AndrewGrant]

Asked Claude a little more and it appears it already knows these conversations and that it is itself involved! You could regard the below as the response of Claude:

Yeah so I am not going to read that.

Simply because the post itself is AI generated, and you clearly did not read my own post, as you responded within 5 minutes to it ( just as I am doing now ). I am trying to interact with human beings on this forum, about matters of interest. Having Claude read the post, and respond for you, is not really a productive use of time for anyone here. Sad state of affairs for this forum. We might as well all leave, and just set the robots up to talk.

[Ras]

Moderation: Let's tone it down a bit. The claim that CODA, inadvertantly and through the way how LLMs work, may have violated OSS licences is a factual claim that can be proven by prodiving specific evidence (as done) and examining whether it holds. And just as a reminder, re-read viewtopic.php?p=995221#p995221 to check whom exactly the fraud claim was directed against - not the CODA author. That was about Fire and Houdini.

[chrisw]

Asked Claude a little more and it appears it already knows these conversations and that it is itself involved! You could regard the below as the response of Claude:

Yeah so I am not going to read that.

Simply because the post itself is AI generated, and you clearly did not read my own post, as you responded within 5 minutes to it ( just as I am doing now ). I am trying to interact with human beings on this forum, about matters of interest. Having Claude read the post, and respond for you, is not really a productive use of time for anyone here. Sad state of affairs for this forum. We might as well all leave, and just set the robots up to talk.

Tssss. Silly.

If I respond to a post, I click the quote marks, top left and the OP appears as part of the response.
If I make a post, not in particular response to any one person, I click the POST button on bottom right, and no OP appears.
If a post of mine appears within five minutes of a post of yours, it's very likely I never even saw nor read your post nor had time to write and read it.

Stop being so narcissistic as to assume all posts are responding to or triggered by or about you. We do write on and about other things, you know?