Skip to content
Back to search

green-claude

🌱 Eco-design skill for Claude Code: digital sobriety, RGESN/GR491 compliance, AI responsibility, eco-conception, frugal AI, carbon footprint, water/electricity/CPU/GPU optimization, sustainable software, green IT

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/Institut-du-Numerique-Responsable/green-claude with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/Institut-du-Numerique-Responsable/green-claude'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/institut-du-numerique-responsable--green-claude/badge.svg)](/listings/institut-du-numerique-responsable--green-claude)

HTML

<a href="/listings/institut-du-numerique-responsable--green-claude"><img src="/api/listings/institut-du-numerique-responsable--green-claude/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Via the Claude Code plugin manager (recommended)

/plugin marketplace add Institut-du-Numerique-Responsable/green-claude
/plugin install green-claude@green-claude

Claude Code then handles updates (`/plugin update green-claude`) without a manual `git pull`.

Via install.sh

git clone https://github.com/Institut-du-Numerique-Responsable/green-claude.git
cd green-claude
./install.sh

The script installs the skill into `~/.claude/skills/green-claude` and offers audit, cache and framing hooks separately. The plugin manager does not configure these hooks.

Prerequisite: `jq`, needed by the audit script and the hooks (`brew install jq` / `sudo apt install jq`).

Claude.ai and Claude API

From a local clone, build the archives:

bash skills/green-claude/scripts/package-skill.sh    # writes into dist/

| Channel | Archive | How to install | |---|---|---| | Claude.ai | `dist/green-claude-claude-ai.zip` | Settings → Capabilities → Skills → Upload skill (code execution must be enabled) | | Claude API | `dist/green-claude-api.zip` | `client.beta.skills.create(files=files_from_dir("green-claude"))` |

The archives contain the same skill, with a description adapted to each channel. Running the audit requires `bash` and `jq` in the execution environment.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 15 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "green-claude",
  3. "owner": {
  4. "name": "Institut du Numérique Responsable",
  5. "url": "https://institutnr.org/"
  6. },
  7. "description": "Eco-design skill for Claude Code: 107 rules for digital sobriety (RGESN 2024 / GR491). Automatically applies eco-conception best practices during coding. Covers AI sobriety (water, electricity, CPU, GPU), frontend, backend, hosting, and algorithms. Open source, Apache-2.0 (code) and CC BY 4.0 (rules and documentation).",
  8. "plugins": [
  9. {
  10. "name": "green-claude",
  11. "source": "./",
  12. "description": "Applies RGESN/GR491 eco-design rules while Claude Code writes or reviews code, with deterministic audit and responsible usage practices. 107 rules for AI sobriety (water, electricity, CPU, GPU), frontend, backend, hosting, algorithms. Open source, Apache-2.0 (code) and CC BY 4.0 (rules and documentation)."
  13. }
  14. ]
  15. }
README.md · README · 325 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # Green Claude: digital sobriety for Claude Code
  2. 🇫🇷 [Lire en français](README.fr.md)
  3. [![Claude Code](https://img.shields.io/badge/Claude%20Code-skill-CC785C?logo=claude&logoColor=white)](https://github.com/Institut-du-Numerique-Responsable/green-claude)
  4. [![Audit](https://img.shields.io/badge/audit-Bash%2FAWK-4EAA25?logo=gnubash&logoColor=white)](hooks/)
  5. [![Python](https://img.shields.io/badge/Python-3-3776AB?logo=python&logoColor=white)](scripts/)
  6. [![Licenses](https://img.shields.io/badge/licenses-Apache--2.0%20%2B%20CC%20BY%204.0-green.svg)](LICENSE)
  7. [![Release](https://img.shields.io/github/v/release/Institut-du-Numerique-Responsable/green-claude)](https://github.com/Institut-du-Numerique-Responsable/green-claude/releases)
  8. [![Site](https://img.shields.io/badge/site-green--claude-blue)](https://institut-du-numerique-responsable.github.io/green-claude/)
  9. **Green Claude** helps [Claude Code](https://claude.com/claude-code) write code that uses fewer resources, with eco-design rules and a local audit tool.
  10. A project by the [Institut du Numérique Responsable](https://institutnr.org): **107 general rules, 137 rules for 24 languages and frameworks, 13 responsible-use practices and 30 token sobriety rules**. The approach is presented on the INR website (in French): [Écoconcevoir avec un assistant de code](https://institutnr.org/ecoconcevoir-avec-un-assistant-de-code).
  11. The skill guides the model when loaded; its application is not guaranteed on every response. The audit flags candidates for review, without certifying RGESN compliance or measuring energy savings. Optional hooks run the audit after supported code-writing operations.
  12. The rules draw on RGESN 2024, GR491, the Green Software Foundation and the W3C Web Sustainability Guidelines. A version portable to other assistants is being developed in [regles-ecoconception-ia](https://github.com/Institut-du-Numerique-Responsable/regles-ecoconception-ia).
  13. [Installation](#installation) · [Usage](#usage) · [Languages and frameworks](docs/languages/README.md) · [Limits and hooks](#limits-and-hooks) · [Contributing](CONTRIBUTING.md) · [License](#license)
  14. ## Installation
  15. ### Via the Claude Code plugin manager (recommended)
  16. ```
  17. /plugin marketplace add Institut-du-Numerique-Responsable/green-claude
  18. /plugin install green-claude@green-claude
  19. ```
  20. Claude Code then handles updates (`/plugin update green-claude`) without a manual `git pull`.
  21. ### Via install.sh
  22. ```bash
  23. git clone https://github.com/Institut-du-Numerique-Responsable/green-claude.git
  24. cd green-claude
  25. ./install.sh
  26. ```
  27. The script installs the skill into `~/.claude/skills/green-claude` and offers audit, cache and framing hooks separately. The plugin manager does not configure these hooks.
  28. Prerequisite: `jq`, needed by the audit script and the hooks (`brew install jq` / `sudo apt install jq`).
  29. ### Claude.ai and Claude API
  30. From a local clone, build the archives:
  31. ```bash
  32. bash skills/green-claude/scripts/package-skill.sh # writes into dist/
  33. ```
  34. | Channel | Archive | How to install |
  35. |---|---|---|
  36. | Claude.ai | `dist/green-claude-claude-ai.zip` | Settings → Capabilities → Skills → Upload skill (code execution must be enabled) |
  37. | Claude API | `dist/green-claude-api.zip` | `client.beta.skills.create(files=files_from_dir("green-coding"))` |
  38. The archives contain the same skill, with a description adapted to each channel. There it is named `green-coding`: Claude.ai and the API reject a skill name that contains "claude". Running the audit requires `bash` and `jq` in the execution environment.
  39. ## Usage
  40. Three ways to use it:
  41. | You want to... | What you do |
  42. |---|---|
  43. | Have Claude write sober code by default | Install the skill; explicitly request its use when needed |
  44. | Audit an existing file | Just ask: *"eco-design audit of this file"* |
  45. | See the full checklist | Type `/green-claude` |
  46. The audit uses local patterns and detectors, without calling a model for detection. Interpreting its results with Claude consumes tokens.
  47. ## Real example
  48. This entirely ordinary piece of code:
  49. ```js
  50. import _ from 'lodash';
  51. app.get('/api/users', (req, res) => {
  52. db.query('SELECT * FROM users', (err, rows) => {
  53. res.json(rows);
  54. });
  55. });
  56. ```
  57. `bash skills/green-claude/scripts/eco-audit.sh api.js` (output excerpt):
  58. ```
  59. [High] ECO-FRONT-01 — No heavy library for a minor need
  60. File : api.js
  61. Category : 6. Frontend
  62. RGESN : 6.x
  63. Recommendation : Prefer the language's native functions or lighter alternatives (date-fns, Alpine.js).
  64. [High] ECO-BACK-01 — Optimise SQL queries
  65. File : api.js
  66. Category : 7. Backend
  67. RGESN : 7.x
  68. Recommendation : Select only the columns you need, index the filtered columns, and avoid functions in WHERE clauses and N+1 queries.
  69. [High] ECO-JS-01 — Whole-library import
  70. File : api.js
  71. Category : JS/TS — dependencies and weight
  72. RGESN : 6.1, 6.2
  73. Recommendation : Targeted imports (import { x } from 'lib/x'); native APIs first (fetch, Intl, URL, structuredClone, Date/Temporal) before adding a dependency.
  74. 3 ecodesign issue(s) found.
  75. ```
  76. The skill can help Claude avoid these patterns while writing; use the audit to check the result.
  77. ---
  78. ## The rules: 107 rules aligned with the 9 RGESN 2024 families
  79. [`skills/green-claude/rules/ecoconception.json`](skills/green-claude/rules/ecoconception.json) covers all **9 families** of [RGESN 2024](https://www.arcep.fr/mes-demarches-et-services/entreprises/fiches-pratiques/referentiel-general-ecoconception-services-numeriques.html) (78 official criteria) **plus a new "Hosting for AI" category**. Every rule carries an RGESN reference (`rgesn_ref`) and a [GR491](https://gr491.isit-europe.org/) family (`gr491_famille`).
  80. How precise that reference currently is: **38 rules** point at specific criteria (e.g. `4.8`), **67 rules** only point at their family (`1.x` to `9.x`) because that mapping has not been done yet, and two rules follow the Green Software Foundation rather than the RGESN. Refining those family-level references is open work — the field states what it knows, never more.
  81. | RGESN family | Rules | Examples |
  82. |---|---|---|
  83. | 1. Strategy | 9 | Measure before optimizing, reasoned data collection, open formats, sustainability advocate, awareness training, user transparency |
  84. | 2. Specifications | 5 | Compatibility with old devices, low bandwidth, third-party services impact |
  85. | 3. Architecture | 12 | Low-tech first, resources matched to load, sober test environments, tested and maintainable code |
  86. | 4. UX/UI | 8 | No autoplay or infinite scroll, native components, limited fonts, most sober medium, prefers-reduced-motion |
  87. | 5. Content | 3 | Optimized images, SVG, fonts |
  88. | 6. Frontend | 14 | No heavy libraries, lazy loading, minification, dependencies, no dead code, no implicit globals, no synchronous XHR, lean DOM, no duplicate IDs, limited `!important`, no duplicate CSS, no legacy IE hacks, deferred scripts |
  89. | 7. Backend | 13 | Optimized SQL, connection pools, complexity, pagination + cache, N+1 queries |
  90. | 8. Hosting | 12 | Sober hosting, HTTP compression, HTTP cache, HTTPS/TLS, broken links |
  91. | 9. **Algorithms (incl. AI)** | 27 | **Justify AI use, right-size the model, measure, sober alternatives, quantification, batching, streaming** |
  92. | 10. **Hosting for AI** | 4 | **Inference-optimized GPUs, green datacenters, CPU inference, model sizing** |
  93. Rules with no detectable pattern (process, governance) are skipped by the audit and serve as a checklist in `/green-claude`.
  94. ---
  95. ## Language rules: 137 rules loaded on demand
  96. The 107 rules above hold whatever the language. They set the goal without saying how to reach it in Python or in Java: "avoid N+1 queries" doesn't choose between `select_related`, `JOIN FETCH`, `Include` and `with()`.
  97. [`skills/green-claude/rules/langages/`](skills/green-claude/rules/langages/) goes one level down, with one file per language, applied **only to files of that language**:
  98. Examples from the **24 languages and frameworks**. See the [complete list and detailed rules](docs/languages/README.md).
  99. | File | Files covered | Rules | What it catches on its own |
  100. |---|---|---|---|
  101. | `python.json` | `**/*.py` | 11 | Django/SQLAlchemy N+1, `iterrows()`, unbounded `lru_cache()`, `requests.get` without a session |
  102. | `sql.json` | `**/*.{sql,pks,pkb,prc,fnc,trg}` | 11 | `SELECT *`, `OFFSET` pagination, non-sargable predicates, PL/SQL cursors, retention |
  103. | `javascript.json` | `**/*.{js,jsx,ts,tsx,mjs,cjs}` | 9 | `import * as`, `fs.*Sync`, `setInterval`, listeners never removed |
  104. | `java.json` | `**/*.java` | 8 | `findAll()`, JPA N+1, `parallelStream()`, unbounded static cache |
  105. | `csharp.json` | `**/*.cs` | 8 | Premature `ToList()`, `.Result`, `new HttpClient()` per request |
  106. | `php.json` | `**/*.php` | 7 | Unbounded `->get()`, Eloquent/Doctrine N+1, `file_get_contents`, cache without purge |
  107. | `ruby.json` | `**/*.rb` | 7 | `.all.each`, `map(&:col)`, `count > 0`, cache without `expires_in` |
  108. | `rust.json` | `**/*.rs` | 7 | Convenience `clone()`, intermediate `collect()`, blocking an async executor |
  109. | `c.json` | `**/*.{c,h}` | 6 | `strlen()` in a loop condition, repeated `strcat()`, byte-by-byte I/O, busy waiting |
  110. | `cpp.json` | `**/*.{cpp,cc,cxx,hpp,hh}` | 6 | Pass by value, linear `std::find`, `shared_ptr` by default |
  111. Without this filtering by extension, one language's patterns fire on the others: `.all()`, `save()` and `+=` exist everywhere and don't point at the same problem. The audit only loads the file for the languages actually present among its arguments.
  112. ```bash
  113. bash skills/green-claude/scripts/eco-audit.sh --list-langs # covered languages and their globs
  114. bash skills/green-claude/scripts/eco-audit.sh --list-rules python # full checklist for one language
  115. bash skills/green-claude/scripts/eco-audit.sh --rules src/App.tsx # compact rules for a file, a family or a language
  116. ```
  117. ---
  118. ## Measure, don't assume
  119. `eco-score.sh` counts the patterns found in a repository, weights them by impact and reports them against code volume:
  120. ```bash
  121. skills/green-claude/scripts/eco-score.sh # human-readable
  122. skills/green-claude/scripts/eco-score.sh --json # one line per measurement, to keep over time
  123. ```
  124. This score counts known patterns, not joules. A falling density says the code holds fewer recognizable patterns, not that it draws less power. Compare it to last month's rather than to zero, and check it against a real runtime measurement (query count, bytes transferred, CPU time, EcoIndex on a page): that's what settles it.
  125. If the audit fails, the command exits with an error and produces no score. Hooks and the score derive their supported extensions from the rule catalog; automatic selection excludes Markdown and JSON.
  126. Two more checkpoints, both optional:
  127. - `hooks/green-claude-pre-commit.sh` audits the staged content, even when the working copy differs. Where the Claude Code hook only sees what Claude writes, this one also sees what you write. It reports without blocking, unless you pass `GREEN_CLAUDE_STRICT=1`.
  128. - `.github/workflows/eco-audit.yml` runs the rule test suite on every PR and publishes the repository's density in the job summary.
  129. ## Responsible-use practices for Claude Code
  130. Coding with AI also uses resources during the session. Green Claude therefore maintains its own recommendations for avoiding unnecessary context, output, retries, and compute. Token counts are an activity indicator, not a direct measurement of energy or emissions; environmental claims require measurements from the actual execution context.
  131. [`skills/green-claude/rules/usage.json`](skills/green-claude/rules/usage.json) contains 13 project-authored recommendations. The table adds two practices now carried by the token sobriety rules (NR-TOK, next section):
  132. | Practice | The move |
  133. |---|---|
  134. | Context minimalism | Minimal prompt, let Claude fetch its own context |
  135. | Rewind instead of correcting | `/rewind` (double Esc) instead of stacking corrections into the context |
  136. | `/clear` vs `/compact` | New task → `/clear`. Related task → `/compact <instruction>` |
  137. | Map the codebase | A repo index (CODEMAP.md, or a tool like [graphify](https://github.com/Graphify-Labs/graphify)) avoids re-reading the same files whole every session |
  138. | Dense answers | Get straight to the result instead of rephrasing (the spirit behind tools like [caveman](https://github.com/juliusbrussee/caveman)); plain style without AI writing tics, checked with [stop-slop](https://github.com/hardikpandya/stop-slop) when installed (NR-TOK-001 to 005) |
  139. | Write the rule, don't re-correct | "Add this to CLAUDE.md" fixes it once and for all |
  140. | A skill for anything repeated | A daily workflow becomes a slash command |
  141. | Give it a way to verify | Tests, a command, a browser: fewer correction cycles |
  142. | Match effort to the task | Use the controls available in the client and verify their effect through evaluations (NR-TOK-023, NR-TOK-024 for subagents) |
  143. | Minimal mode for scripts | Avoid loading customizations an automation does not need |
  144. Full detail: [`skills/green-claude/rules/usage.json`](skills/green-claude/rules/usage.json).
  145. The skill applies these rules to its own replies: no em dash, no phrase that announces an idea instead of delivering it, no pseudo-cleft sentence, no emphatic presentative or detached fake subordinate clause, no epanorthosis, verbal anaphora or binary antithesis, no counted announcement or announced list. They hold in every language ("Writing your replies" section of [`SKILL.md`](skills/green-claude/SKILL.md)).
  146. > The third-party tools cited are verified open source: graphify and stop-slop under the MIT license, caveman under the Apache License 2.0 (see [Attribution and third-party licenses](#attribution-and-third-party-licenses)). The project doesn't audit them and doesn't depend on them.
  147. ## Token sobriety for AI agents
  148. [`skills/green-claude/rules/tokens.json`](skills/green-claude/rules/tokens.json) holds the 30 NR-TOK rules of the Institut du Numérique Responsable. They cut the tokens consumed, the model calls and the needless processing without degrading quality, security, maintainability or understanding of the code. They target development agents such as Claude Code, OpenAI Codex and Mistral Vibe.
  149. | Family | Rules | Examples |
  150. |---|---|---|
  151. | A. Reply sobriety | NR-TOK-001 to 006 | answer directly, no redundant conclusion, few messages between tool calls |
  152. | B. Context management | NR-TOK-007 to 014 | load what is needed, targeted search, compress logs while keeping errors, numbers and paths |
  153. | C. Operation sobriety | NR-TOK-015 to 022 | investigate before changing, targeted changes, stop at the acceptance criteria |
  154. | D. Model optimization | NR-TOK-023 to 026 | proportionate model, deterministic local processing, cache |
  155. | E. Quality and measurement | NR-TOK-027 to 030 | no saving at the cost of quality, measure, session report |
  156. Seven rules are mandatory: NR-TOK-007, 011, 015, 016, 022, 027 and 030. NR-TOK-023 to 026 and NR-TOK-028 depend on what the environment allows. The others apply by default. They absorb the former USAGE-CTX-06, USAGE-CPU-01 and USAGE-CPU-02 practices, and each rule's `related` field names the responsible-use practices they still overlap.
  157. `eco-audit.sh --rules tokens` prints them in compact form, followed by the session report format required by NR-TOK-030. The report closes any task that ran tools or changed files, never a plain question. It lists the rules applied, the optimizations, the available measurements, the tests and the limits. It invents no metric and gives a saving percentage only against a comparable baseline. Cutting tokens, cutting costs and cutting environmental impact remain three separate goals.
  158. ---
  159. ## Limits and hooks
  160. A skill runs *during* a session that's already started, and the model decides whether to apply it. So it can't pick the starting model, can't intercept a call before it leaves, and can't guarantee a rule gets checked every single time. Four levers therefore live outside the skill, in [`hooks/`](hooks/), optional and offered at install time:
  161. - **Systematic audit** (`hooks/green-claude-audit.sh`): wired as `PostToolUse` on `Write|Edit|MultiEdit`. Claude Code runs it after every code file written, without asking the model. It audits what was just added and returns findings to Claude for review and possible correction.
  162. - **Explicit local cache** (`hooks/green-claude-cache.sh`): prefix a self-contained factual question with `[cache] `, for example `[cache] What is the capital of France?`. Only these requests can reuse a response for one hour without calling the model. Ordinary requests always reach Claude. Do not use this prefix for code audits, actions, or questions that depend on files or previous messages: the cache does not track those changes. A cache hit is displayed as a hook message and is not added to Claude's conversation context.
  163. - **Off-peak warning** (same hook): flags peak hours (outside 22:00-06:00 UTC) without ever blocking.
  164. - **Framing before writing** (`hooks/green-claude-brief.sh`): wired as `UserPromptSubmit`. On a request to produce code, it recalls the three rules that decide what gets written at all — the least code that solves the problem, challenge the request and the model, ask before you build. On a question, it stays quiet. Those rules also live in the skill; the hook repeats them when the request is made.
  165. ## Two files that silence what should not speak
  166. A candidate you dismiss once comes back on the next run, and the one after that. Dismissed six times, it teaches the whole team to skim past the audit, which costs more than the rule ever saved. Two versioned files close the question, at the repository root.
  167. `.green-claude/decisions.md` holds what the team has settled:
  168. ```
  169. ECO-CONT-01 docs/index.html ACCEPTED logo.jpg kept as the og:image fallback
  170. ECO-SH-05 install.sh TODO two mktemp with no trap
  171. ```
  172. `ACCEPTED` silences that rule for that file, and only there. `TODO` stays visible: a debt taken on deliberately is not an exemption. The audit reports how many findings it hid and where the file lives, so nothing vanishes without a trace. The rest of the file is free prose; only lines in the right shape are read.
  173. `.green-claude/ignore` takes files out of scope, one pattern per line:
  174. ```
  175. skills/green-claude/scripts/test-eco-audit.sh
  176. skills/green-claude/rules/
  177. ```
  178. A test suite and a rule corpus **contain** faulty code without ever running it. Flagging them is a false positive by construction, and it produced more noise than anything else while this repository was written.
  179. Both locations can be overridden with `GREEN_CLAUDE_DECISIONS` and `GREEN_CLAUDE_IGNORE`.
  180. These hooks wire into `~/.claude/settings.json`. If you answer "y", `install.sh` adds them there (other settings are preserved, and a backup of the original file is left at `settings.json.green-claude.bak`). Without `jq`, it prints the config to paste in by hand. To remove them: delete the `green-claude-*` entries from the file.
  181. ---
  182. ## Writing your own rules
  183. The [contribution guide](CONTRIBUTING.md) covers the JSON format, source attribution, detectors and required tests. After local changes, rerun `./install.sh` to update the installed copy.
  184. ---
  185. ## 🤝 Contributing
  186. 1. **Fork** this repository
  187. 2. Create a branch (`git checkout -b feature/my-rule`)
  188. 3. Add your rules or improvements (`jq empty skills/green-claude/rules/*.json` to validate the JSON)
  189. 4. Open a **Pull Request**
  190. Most useful contributions: new audit rules sourced from RGESN, GR491, GSF, WSG, or another recognized public reference, with their `rgesn_ref`; pattern fixes (false positives); translations.
  191. Full detail on the rule format and PR process: [CONTRIBUTING.md](CONTRIBUTING.md).
  192. Community participation is governed by the [Code of Conduct](CODE_OF_CONDUCT.md)
  193. and [governance policy](GOVERNANCE.md). See [SUPPORT.md](SUPPORT.md) for the
  194. right help channel and [SECURITY.md](SECURITY.md) for private vulnerability
  195. reporting.
  196. ---
  197. ## Releases
  198. Notable changes are recorded in the [changelog](CHANGELOG.md). New releases use
  199. Semantic Versioning tags in the form `vMAJOR.MINOR.PATCH`; legacy tags retain
  200. their original names so existing links keep working. A tagged release is
  201. published automatically only after its version, tests, and packaged archives
  202. have been verified.
  203. ---
  204. ## 🙏 References
  205. - [RGESN 2024](https://ecoresponsable.numerique.gouv.fr/publications/referentiel-general-ecoconception/): Référentiel Général d'Écoconception de Services Numériques (78 criteria, 9 families)
  206. - [GR491](https://gr491.isit-europe.org/): reference guide for responsible digital service design (61 recommendations, 516 criteria)
  207. - [Green Software Foundation](https://greensoftware.foundation/): software eco-design patterns
  208. - [W3C Web Sustainability Guidelines](https://w3c.github.io/sustainableweb-wsg/): web sustainability guidelines (UX, development, hosting, strategy)
  209. - [YellowLabTools](https://github.com/YellowLabTools/YellowLabTools): open-source front-end quality audit tool, source of several thresholds (DOM, CSS, fonts)
  210. - [Anthropic](https://www.anthropic.com/): Claude and Claude Code
  211. ## Maintainers
  212. - [Guillaume Gallon](https://github.com/gridboy) ([LinkedIn](https://www.linkedin.com/in/ggallon/)) — [Institut du Numérique Responsable](https://institutnr.org)
  213. ## Attribution and third-party licenses
  214. ### Caveman
  215. A few ideas of the NR-TOK rules ([`rules/tokens.json`](skills/green-claude/rules/tokens.json)) come from the open source project [Caveman](https://github.com/JuliusBrussee/caveman) (Copyright 2026 Julius Brussee, Apache License 2.0). The INR reworked and rewrote those rules for the goals and reference frameworks of responsible digital practice.
  216. This project is independent of Caveman and its author. Referring to Caveman implies no endorsement, affiliation or participation on their part.
  217. ## License
  218. Code: **Apache-2.0**. Rules and documentation: **CC BY 4.0**. Reuse, adaptation and commercial use are permitted under these licenses, with the required notices and attribution.
  219. © 2026 Institut du Numérique Responsable. Principal author: Guillaume Gallon; other contributions: Git history. See the [license scope](LICENSE) and [credits](skills/green-claude/NOTICE). Third-party sources retain their own terms.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.