QGIS-Enhancement-Proposals

Open Source Fights Back: QGIS Bans AI Contributions The QGIS mapping project just banned AI-generated code to protect its maintainers and codebase. Will other open-source giants follow suit? #shorts Source: QGIS-Enhancement-Proposals#387 [de-DE] Open Source wehrt sich: QGIS verbietet KI-Beiträge Das QGIS-Kartierungsprojekt hat KI-generierten Code verboten, um seine Entwickler und die Codebasis zu schützen. Werden andere große Open-Source-Projekte diesem Beispiel folgen? #shorts Quelle: QGIS-Enhancement-Proposals#387 [es-US] El código abierto contraataca: QGIS prohíbe las contribuciones de IA El proyecto de cartografía QGIS acaba de prohibir el código generado por IA para proteger a sus desarrolladores y su código fuente. ¿Seguirán el ejemplo otros gigantes del código abierto? #shorts Fuente: QGIS-Enhancement-Proposals#387 [fr-FR] L'Open Source contre-attaque : QGIS bannit les contributions par IA Le projet de cartographie QGIS vient d'interdire le code généré par l'IA afin de protéger ses mainteneurs et sa base de code. D'autres géants du logiciel libre suivront-ils cet exemple ? #shorts Source : QGIS-Enhancement-Proposals#387 [hi] ओपन सोर्स का पलटवार: QGIS ने AI योगदान पर लगाया प्रतिबंध QGIS मैपिंग प्रोजेक्ट ने अपने मेंटेनर्स और कोडबेस की सुरक्षा के लिए AI द्वारा जनरेट किए गए कोड पर प्रतिबंध लगा दिया है। क्या अन्य ओपन-सोर्स दिग्गज भी ऐसा ही करेंगे? #shorts स्रोत: QGIS-Enhancement-Proposals#387 [id] Open Source Melawan Balik: QGIS Larang Kontribusi AI Proyek pemetaan QGIS baru saja melarang kode yang dihasilkan AI untuk melindungi pengembang dan basis kodenya. Akankah raksasa open-source lainnya mengikuti langkah ini? #shorts Sumber: QGIS-Enhancement-Proposals#387 [it] L'Open Source reagisce: QGIS vieta i contributi AI Il progetto di mappatura QGIS ha appena vietato il codice generato dall'IA per proteggere i suoi manutentori e il codice sorgente. Altri colossi dell'open source seguiranno l'esempio? #shorts Fonte: QGIS-Enhancement-Proposals#387 [pt-BR] Open Source contra-ataca: QGIS proíbe contribuições de IA O projeto de mapeamento QGIS acaba de banir o código gerado por IA para proteger seus mantenedores e a base de código. Será que outros gigantes do código aberto seguirão o exemplo? #shorts Fonte: QGIS-Enhancement-Proposals#387

QGIS bans all AI-assisted code: its "AI assisted" label has 60 PRs, 49 closed unmerged. Enforcement? "By trust." That punishes those who disclose. AI help adds value; disclosure is #OpenSource honesty. QGIS-Enhancement-Proposals#387

The quiz hook is a Level 1 control — and the bypass is logged --- description: A new Git hook pauses your push and quizzes you on your AI's code before shipping. The HN debate proves it sits exactly where the taxonomy predicts — Level 1, visible and bypassable — and the detail everyone missed is that the bypasses are logged. tags: ai, security, programming, devops series: receipts --- A tool launched on Show HN this week that belongs in this series' taxonomy: Sphinx — a Git hook that pauses your push on protected branches and quizzes you on what the AI's code actually does. Wrong answer: you learn why and try a new scenario. Correct answer: the push proceeds. Install is npm install -g sphinx-understand, sphinx install wires it to your agents, and pushes work as usual after that. It works with Codex, Claude Code, Cursor, OpenCode, Pi, or plain Git. It runs on minimal tokens from your existing coding agent, or any OpenAI-compatible endpoint. Your answers never reach the coding agent, and the .env files and keys are never opened. MIT licensed, Node 22.19+, macOS, Linux, or WSL. And one flag in the docs separates it from every "AI gate" tool that shipped this year: sphinx yolo lets pushes through without the quiz — and logs every skip. The HN debate is a rung assignment The Show HN discussion ran the full argument in half a day, and both sides are worth reading as data, not opinions. The praise: it "slows things down and is quick to implement"; one builder of a similar tool was "positively surprised by the question quality"; and the comparison that lands hardest is to the industry's oldest reflex — never copy Stack Overflow code you didn't understand. The criticism: the quiz is trivially bypassed — paste the questions back into the agent, or just delete the hook; it doesn't catch diff-level defects — a leftover debug print or a weakened assertion passes any comprehension quiz; a commenter predicts "confirmation fatigue" and agents answering the quiz for us; and the sharpest dismissal: all of this to avoid knowing what you're doing. Both sides are right, and the taxonomy explains why without taking sides. The quiz hook is a Level 1 control — a primitive in context, on the ladder this series has been building. It exists, it is visible, it slows people down. What it cannot do is enforce: the human can fail the quiz on good code and pass it on bad, the agent can answer for the human, and the hook can be removed. Level 1 controls are real — they slow the eighty percent who are lazy but not malicious — and they are the first thing to outgrow. What the discussion proved without noticing: the bypass is priced and logged. sphinx yolo lets pushes through, and every skip lands in a log. That single design detail moves the tool up a half-rung — a bypass that leaves a record is no longer invisible drift, it is a decision trail. The QGIS project's failed tagging process — roughly fifty PRs tagged, forty closed, and then abandoned — had no such log. The rung it shares with its ancestors The Stack Overflow comparison in the thread is the deepest one, and it is twenty years old: never ship code you copied without understanding. The industry's answer then was the same rung — a human review, a production incident, eventually understanding. The AI version compresses the cycle: the code arrives faster, in larger volumes, with the confidence of fluency. The quiz hook is the modern re-skin of the oldest control in software. What the quiz will never catch: the diff-level defects that comprehension cannot see — the leftover debug print, the weakened assertion, the subtly wrong error path. Those need the other rung: machine checks on the diff itself. What the machine checks will never catch: whether the human understands what they just shipped. Two failure modes, two controls, and a team that confuses them has neither. !Diagram: the quiz hook graded — Level 1 visible and bypassable, the yolo bypass priced and logged, Level 2 the gate that checks the diff — two failure modes, two controls The design question for any team is therefore not "should we quiz the humans" but "which failure mode are we actually defending against" — and the honest answer for most AI-assisted teams today is neither: the code ships, the comprehension gap silently grows, and the first measurement happens at the incident. What to steal - The logged bypass is the receipts culture in a single flag. sphinx yolo does not pretend the quiz did not happen — it records the skip. Any gate you deploy should have the same property: bypassable, but never invisibly. - Comprehension and diff-defects are different failure modes. A quiz catches the first; linting, tests, and diff review catch the second. A team that deploys one and expects the other has bought a seatbelt for the wrong seat. - The bypass debate is the rung assignment. If your control's criticism thread is full of "easily bypassed", you have a Level 1 control — and that is fine, as long as the docs say so and the log records the bypasses. Run the whole post in three commands The tool is its own demo: install it, let the quiz fire on your next AI-assisted push, then bypass it and watch the skip get logged. Three commands, and you have lived everything this post argues: npm install -g sphinx-understand sphinx install # wires Git and your coding agents git push # your next AI-assisted push — the quiz fires Wrong answer: you learn why and rewrite the scenario. Right answer: the push proceeds. Then bypass it, and check the trail: sphinx yolo # pushes pass without the quiz git push # passes — and the skip is logged That logged skip is the entire debate, settled in one line of your own terminal: the control slowed you down once, the bypass was recorded anyway, and the record is now yours to audit. Two honest limits I did not build or run Sphinx — the audit is from the repo, the docs, and the thread. The quiz mechanics, the yolo logging, and the token claims are from the project's own materials; the HN debate is quoted with attribution. My contribution is the taxonomy placement, which anyone can dispute by running the tool — that dispute is welcome, it is the differential working. And the tool is four days old, which means the bypass debate is the ceiling by design. A Level 1 control cannot be patched into Level 2 — the quiz cannot verify the diff, and the hook cannot verify the quiz. What can grow: the log. If the skip data ever feeds a dashboard — pushes shipped, skips logged, comprehension answered per developer over time — the tool stops being a quiz and becomes a measurement. That is the version worth waiting for. Your turn Sphinx is MIT, one npm command, and works with your existing agents. Run it on your next AI-assisted push and count three things: the questions you answered, the skips you logged, and the one defect the quiz could never have caught. Post the three numbers — the ratio is the state of AI-assisted development on your team, measured instead of argued.

開源地圖軟體 QGIS 不收 AI 寫的程式碼了 開源地圖軟體 QGIS 宣布主程式不再收 AI 寫的程式碼，事後被發現還會處分，Hacker News 上吵了四百多則留言。 專案：QGIS-Enhancement-Proposals#387 #shorts #AI #QGIS #開源 #AI寫程式 時間軸 00:00 開場 00:03 發生什麼事 00:11 新規定 00:19 舊規定 00:26 大家怎麼看

Linus Torvalds Calls Rules That Police AI Tools 'Utterly Stupid'. Here's Linux's Rule Instead The Linux kernel is about to drop the Assisted-by tag it asks contributors to put on AI-assisted commits. Linus Torvalds backs the change, and when a developer pushed back on LKML he called rules that police your tools "UTTERLY STUPID". By his logic, banning AI-written code outright is the same mistake. Days earlier, QGIS went the other way and banned AI-assisted code from its main repository. Two serious open source projects looked at the same flood of LLM patches and wrote opposite rules. I think the kernel's rule is better, and I'd copy it into any project's CONTRIBUTING.md. But most projects that copy it will skip the part that makes it work, so there's a paste-ready version further down. What Linus Torvalds actually said about AI code Some background first, because the headlines blurred it. Since Linux 7.0 the kernel's AI coding assistants guide has asked developers to add an Assisted-by tag to commits made with LLM help. At the Maintainers Summit in Prague on October 8, 2026, a majority of the roughly 30 invited developers backed dropping that tag. On October 9 Sasha Levin (stable/LTS co-maintainer, Nvidia) posted a patch to remove the requirement. His revised version on October 13 came with a number: only about 10% of the 18,533 non-merge commits in Linux 7.3 through -rc7 carried the tag, and heise says actual AI use is much higher. People either didn't know the rule or ignored it, and maintainers rarely asked. (heise) Laurent Pinchart objected to dropping the tag. Torvalds replied on LKML on October 13: > Here's a new rule just for you: don't use compilers for any of your kernel submissions. Because if you can't show that you really understand what the machine is actually doing by writing your code in assembler, then I don't want to see your code contribution. Then he said what he does expect: > The kind of expectations _I_ have is that people do their best and I expect people to understand what they are doing. But that understanding has very little to do with what tools they use. He also threw in "you had better not use an editor to write that commit message either", which is pure Linus. Jonathan Corbet has merged Levin's patch into docs-next; at the time of writing it hasn't hit mainline. Under the new text, developers describe how they used AI tools in the patch cover letter instead of tagging each commit, so maintainers still get some transparency, just not a label on every commit. (heise, TNW) The sign-off rule stays, and that's the one I care about. The kernel guide spells it out: "AI agents MUST NOT add Signed-off-by tags. Only humans can legally certify the Developer Certificate of Origin (DCO)." The human who signs off is responsible for reviewing all AI-generated code, checking licensing, and "taking full responsibility for the contribution." So the kernel ends up with no ban and no per-commit tag. A human signs every patch and owns it. Torvalds wrote kernel patches with Claude Code Torvalds isn't arguing from the sidelines, which makes this harder to dismiss. Around the summit he posted a short patch series that speeds up page cache reads by marking hot folios, so reads can skip taking a folio reference. The commit message credits Claude Code, working under his direction, with the code, the test programs, the review and a first draft of the commit message, and the branch is literally named noref-filemap-read-with-llm (It's FOSS). With eight threads reading the same cached file, throughput went from about 10 million reads per second to 30 to 33 million on his laptop, with some security mitigations disabled (Linuxiac). Review then found a race condition in it (LWN), and I'd call that the policy working. The patch went out under a human's name and other humans read it and caught the bug in review. Nobody needed a tag to know where to look; they reviewed the code like any other patch from Linus. Why QGIS banned AI code instead QGIS's QEP 408, "AI tool use policy" started in January 2026 as a disclosure-based policy by Even Rouault. Version 2.0, dated September 24, says: > No LLM, AI or agent assisted code contributions are allowed in the qgis/qgis repository. Break it and "you will be subject to code reversion and contributor rights sanctioning." It was approved on October 7. Before you laugh at that, look at why. Under the old disclose-and-label rule, a reviewer in the discussion estimated about 50 PRs got the AI label and roughly 40 of them were closed unmerged (remio; that's an estimate from the thread, not an audit). That's 40 rejections someone had to read first. "The submitter owns it" means nothing to a volunteer maintainer when the submitter is a drive-by account that will never come back to own anything. Torvalds conceded as much at Open Source Summit Europe in Prague, saying AI is improving the code base but "is also stressing maintainers out to the point that it's a problem." (TNW) Ban vs sign-off: the two policies side by side | | Linux kernel | QGIS (QEP 408 v2.0) | |---|---|---| | AI-written code allowed | Yes | No, in qgis/qgis | | Disclosure required | Assisted-by tag dropped in docs-next; AI use goes in the cover letter | Moot | | Who is accountable | Human who adds Signed-off-by | Contributor, via sanctions | | Enforcement | Normal review, DCO | Reversion, rights sanctions | | Can it be detected? | Doesn't need to be | Not reliably | That last row is where the ban falls apart. You can't tell good LLM-assisted code from good human code, so a ban only catches the sloppy stuff, and sloppy stuff was already rejectable on quality grounds. The people who obey it are the careful contributors you wanted to keep. But the kernel has something QGIS doesn't: a deep subsystem maintainer hierarchy and a sign-off culture that's been enforced since the SCO days. "You own it" works there because owning it has consequences. Get a reputation for unreviewed garbage on LKML and your patches stop getting read. An AI policy for your CONTRIBUTING.md (the part most projects skip) If you copy the kernel's rule into a five-maintainer repo and stop there, you get the QGIS problem. You need the accountability and you need a cheap way to say no. So here's what I'd paste into CONTRIBUTING.md: ## Tools, including AI Use whatever tools you like: compilers, linters, IDE completion, LLMs, agents. We don't ban tools and we don't require you to label them. If saying how you used one would help the reviewer, put it in the PR description. What we require: 1. A human signs off. Every commit needs `Signed-off-by:` from a real person (`git commit -s`), certifying the DCO (https://developercertificate.org/). Tools and agents must never add a sign-off. 2. You understand every line. If a reviewer asks why a line exists, "the model wrote it" is not an answer. You must be able to explain, test and fix it yourself. 3. You checked the licence. You are certifying the code can be submitted under this project's licence, whatever generated it. 4. You stick around. Respond to review. Unattended PRs are closed after 14 days. 5. We can say no without a debate. Maintainers may close any PR that looks unreviewed by its author (huge unexplained diffs, invented APIs, tests that don't test anything) without a line-by-line review. Repeat offenders get blocked. Point 5 does most of the work. It moves the review cost back onto the submitter, which is what QGIS was really after with the ban. You get to the same outcome without pretending you can detect which tool someone used. Enforcing point 1 is cheap. A CI step like this fails any PR with an unsigned commit: for c in $(git rev-list origin/main..HEAD --no-merges); do git log -1 --format=%B "$c" | grep -q '^Signed-off-by: ' \ || { echo "missing Signed-off-by: $c"; exit 1; } done On GitHub Actions, check out with fetch-depth: 0 so origin/main and the full PR history are there. Or install the DCO GitHub app and skip the script. Is "you own every line" enough? On its own, no. The Lobsters thread argued about this for two days. One commenter said verifying LLM output "is more or less as time consuming as writing the code myself." Another described colleagues who say "well Claude says..." and push huge diffs they don't understand. Both complaints are real, and a Signed-off-by line doesn't fix either of them. Still, I think banning the tool aims at the wrong thing. People were sending code they didn't understand long before LLMs, copying it from Stack Overflow, and Linus's rule goes after that directly. Small projects just need to bolt on the right to close PRs quickly. So what would you actually enforce on your repo: a QGIS-style ban, or make the submitter own every line? And if you maintain something, has the "you own it" approach survived your first week of agent-generated PRs? Sources - Linus Torvalds on LKML, 13 Oct 2026: lore.kernel.org - Kernel AI coding assistants guide: docs.kernel.org - heise on dropping the Assisted-by tag: heise.de - TNW on the LKML reply and OSS Europe talk: thenextweb.com - LWN on Torvalds's LLM-assisted patch series: lwn.net - QGIS QEP 408: github.com/qgis/QGIS-Enhancement-Proposals/blob/m… - Lobsters discussion: lobste.rs

AI는 빨라도 리뷰어는 복제되지 않으니까요. QGIS-Enhancement-Proposals#387

QGIS enacts moratorium on AI contributions

The 11-year-old premise inside Rust's memory-safety proof --- published: true description: "If it compiles, the memory is safe" — a machine-checked proof, Level 2 enforced by the compiler itself. Yesterday an 11-year-old hole appeared in it, and the team's severity call exposed the premise the proof rests on: Drop impls are honest. Verified live on stable and nightly. tags: rust, security, programming, python series: receipts --- "If it compiles, the memory is safe." That is Rust's brand — not a slogan, a machine-checked proof: the borrow checker refuses unsafe lifetimes at compile time, host-enforced, the strongest rung any language has claimed. Yesterday, issue #164250 landed on the rust-lang tracker: an unsoundness in the borrow checker, reproducing on current stable, with variants compiling since 1.18.0 (2017) — and one version traced back to 1.4. Eleven years inside the proof. I ran the reproduction tonight on the official playground — stable channel. The output, verbatim: read after scope: hello world, this is long enough the stack slot is freed. the string still printed. A short-lived reference escaped a T: 'static bound through field assignment after construction, survived a Drop that assumed the bound held, and was read after its stack slot was freed. On stable. Same result on nightly. The receipts are one click away — the ASAN run in the issue shows it in seconds. The mechanics, in three sentences struct Q<T: 'static + Send> demands its payload outlive the program. Assigning a field after construction (q.0 = Some(&l), where l is stack-local) unifies the types covariantly — and that unification does not re-check the 'static bound. A Drop impl that pushes the value into a static list assumes the bound held; it leaks the reference out; a downcast_ref::<&'static String>() reads freed stack memory. With AddressSanitizer, per the issue, the same program crashes with stack-use-after-scope. The number that matters is not 11 It is the severity call: P-high, downgraded from P-critical. The pinned note from lcnr is explicit — it would have been P-critical regardless of whether anyone encountered it in the wild, and it is P-high only because it has been latent for eleven years with "very likely that this unsoundness has not caused memory unsafety by accident." The exploit requires, per the issue, "an intentionally malicious Drop implementation." Read that as an auditor, because it is a premise confession, and it is not Rust-specific. The compiler's proof descends a ladder: borrow check → variance rules → trait bounds → and at the floor, an assumption nobody executes — Drop implementations respect the bounds they inherit. The type system verified everything it could check and rested on the one thing it could not: the honesty of every Drop impl ever written by every hand that touched every crate. Eleven years, that premise held by accident of nobody aiming at it. This week someone aimed. Sound familiar? It is the QGIS conscience test — "did you in good conscience write the code yourself" — inside a compiler. It is the authority ladder — rung 0, "the caller's argument": a claim the impl author makes, unverifiable by the checker below. Every soundness proof, every security certification, every "guaranteed" has a floor like this. The floor is not a scandal. An unlabeled floor is. !diagram Credits, because the finder's method is the receipts - jsnell filed it October 13, with the reproduction that compiles and prints freed memory. - theemathas added the I-unsound label, a minimal core repro, and traced a variant compiling "ever since 1.18.0 (2017)" — and asked the question in the thread: "How on earth was this not found before this???" - maxdexh contributed a version going back to 1.4, and the generalization: "unification just generally doesn't check lifetime bounds of the type" — including via mem::swap, no field assignment needed. - lcnr pinned the severity reasoning and the linkage to the next-gen trait solver and Project Zero rework. PR #164277 is the fix in motion. Four people, four contributions, each with its own denominator. That is what a healthy process looks like from the outside — and it is also, per the issue, a thread that was briefly locked as too heated before being unlocked and re-locked to collaborators. Soundness conversations run hot. What to steal - Audit the premises under your proofs. Every guarantee you rely on — a type system, a SOC 2 report, a DCO sign-off, a "tested and measured" claim — rests on unlabeled assumptions the guarantee cannot check. Name one. The table is the audit. - Label your severity calls with their reasons. P-high because eleven years latent because it needs a malicious Drop — that reasoning is the difference between a decision and an assertion. Rust's team did this in the pinned note; copy the format. - Permalinks for reproductions. The playground link makes my claim one click from being your claim. If your repro needs setup, ship the setup. Two honest limits The exploit requires a malicious Drop by design, and the team's downgrade is defensible. Eleven years without an accidental hit is evidence of something — either the premise held because nobody aimed, or because honest Drops overwhelmingly dominate. Both readings favor the team's call. My point is narrower: the premise existed, was unlabeled, and now is labeled — by the issue, in public. And my run is a playground snapshot, not a forensic audit. Stable and nightly, debug profile, no AddressSanitizer in my harness — the stack-use-after-scope confirmation cited in the issue comes from their ASAN run, not mine. One compiler family, one evening. The issue's own denominators are better than mine; use theirs. Your turn The reproduction is twenty lines, the playground is free, and here is the whole thing — paste it into a fresh playground, hit Run, and compare your output to mine: static KEPT: std::sync::Mutex<Vec<Box<dyn std::any::Any + Send>>> = std::sync::Mutex::new(Vec::new()); struct Q<T: 'static + Send>(Option<T>); impl<T: 'static + Send> Drop for Q<T> { fn drop(&mut self) { if let Some(v) = self.0.take() { KEPT.lock().unwrap().push(Box::new(v)); } } } fn main() { let l = String::from("hello world, this is long enough"); { let mut q = Q(None); q.0 = Some(&l); } // <- Drop here: the short-lived reference escapes as if 'static let kept = KEPT.lock().unwrap(); let s = kept[0].downcast_ref::<&'static String>().unwrap(); println!("read after scope: {}", s); println!("the stack slot is freed. the string still printed."); } Run it on your rustc, your channels, your edition, and post your output — the issue's variants reach back to 1.4, and every data point sharpens the map. Then pick one guarantee you ship or rely on, and write down the premise under it that nobody executes. That list is where the next eleven-year bugs live.

QGIS、正気か？ QGIS-Enhancement-Proposals#387

QGISは既存のAI方針QEP-408が機能せず、AI生成PRの量がメンテナのレビュー能力を超えた。QEP428はAIによる貢献を禁止し、IDE補完や翻訳は後に個別許可する方針。AI Assistedタグ付きPR約50件中約40件が未マージでクローズ / Add QEP428: No ai contributions permitted QGIS-Enhancement-Proposals#387