# Cursor vs Copilot Share Claims: 12 Steps, 85 Min

> Source: <https://shattered.io/cursor-vs-copilot-share-claim-linter-python-12-steps-2026/>
> Published: 2026-11-20 08:15:11+00:00

**Key takeaway:** The linter's eleven rules flag share claims that mix surveys, mismatch headline and edition years, treat multi-select usage rates as market share, compare paid-seat counts with survey usage rates, or lack a documented denominator, question wording and answer-option mapping.

Stack Overflow’s 2026 survey release says [66% of respondents use coding assistants or coding agents](https://stackoverflow.co/company/press/archive/stack-overflow-annual-developer-survey-ai-trust-conditional), 63% use general-purpose chat tools, and only 17.2% use no AI tools at all. That is a useful adoption figure. It says nothing about whether Cursor or GitHub Copilot leads, because a product share needs a product-level answer option, a stated denominator and a population that matches the other number you plan to put beside it.

Most cursor vs copilot market share headlines skip all three checks. They set a Stack Overflow percentage next to a JetBrains percentage, call the gap market share, and move on. Anyone who wants to test such a headline needs a repeatable procedure rather than another spreadsheet. A [market share audit built on counts and confidence intervals](https://shattered.io/cursor-vs-github-copilot-market-share-audit-12-steps-2026/) measures the numbers. The linter built below goes the other way: it reads a claim, looks up the survey behind it and grades the claim A to D.

The result is a Python package of about 400 lines (code plus tests) with no third-party dependencies, eleven rules, a TOML survey registry, a JSON and text report, a CI-friendly exit code and 11 unit tests. Every number inside the test claims is a made-up fixture, clearly labelled as one. Real survey figures come from the publishers’ own pages, and the linter tells you whether the claim you want to publish deserves them.

Don't miss new tech stories on Google

Add Shattered once in the Google app and our stories show up in your news suggestions.

[Add now](https://www.google.com/preferences/source?hl=en&q=https%3A%2F%2Fshattered.io%2F)

## What a Share Claim Linter Checks and Why Surveys Disagree

A share claim is any sentence that puts a Cursor number and a GitHub Copilot number in the same breath. Five failure modes account for nearly every bad one. The two numbers come from different surveys. The headline year and the cited edition disagree. Multi-select usage rates get called market share. A paid-seat count gets compared with a survey usage rate. And the registry entry behind the claim lacks a denominator, a question wording or an answer-option mapping, so nobody can say what the percentage was a percentage of.

The disagreement between surveys is structural, not a flaw in any one of them. Stack Overflow’s survey and JetBrains’ State of Developer Ecosystem report reach different people, ask differently worded questions and filter respondents differently. The facts both publishers put on their own pages already show it, as the table below lists.

| Item | JetBrains | Stack Overflow | 
|---|---|---|
| Edition | State of Developer Ecosystem 2026, the tenth edition, published November 10, 2026 | 2026 Annual Developer Survey | 
| Respondents | 28,945 developers | More than 30,000 responses | 
| Reach | 198 countries and regions | 169 countries | 
| Scope | Work practices, tools, languages and industry changes | 103 questions and 467 technologies | 
| Fieldwork | May to July 2026 | Not stated in the sources used here | 
| AI headline figure | More than half of employed developers use AI agents for over 60% of their work tasks | 66% use coding assistants or coding agents | 

The last row proves the point. Both headline AI figures are real, both come from 2026 editions, and neither can be subtracted from the other. One measures how much of the workday goes to agents among employed developers. The other counts respondents who use assistants or agents at all. A sound comparison needs the product-level rows underneath, and those need their denominators documented first.

Time also moves under the numbers. Both publishers have released 2026 editions, so any 2025 percentage that still circulates in blog posts is a previous edition. Stack Overflow’s own material reportedly describes its 2025 survey as covering nearly 50,000 developers, against more than 30,000 responses for 2026. That shift alone makes a naive year-over-year comparison risky. If you also need to compute the shares from the raw export, the [pandas workflow for the Stack Overflow survey](https://shattered.io/cursor-vs-copilot-stack-overflow-survey-pandas-12-steps-2026/) covers the arithmetic. The linter here decides whether the arithmetic’s output is safe to print.

One more boundary: the linter does not estimate sampling error. It runs a single rough noise screen (rule R11) and nothing more. For proper intervals on a survey proportion, a Wilson interval is the better tool, and the two approaches combine without conflict.

## Prerequisites and Versions

The project needs nothing beyond a current Python. No pip install, no virtual environment and no API keys are required, which keeps the linter easy to drop into any repository or CI runner.

- **Python 3.11 or newer.** The registry parser uses`tomllib` , which entered the standard library in 3.11. The outputs below come from Python 3.12.3.
- **Standard library only:**`tomllib` ,`json` ,`dataclasses` ,`argparse` ,`math` and`unittest` .
- **Any operating system with a terminal.** The commands below ran on Linux (kernel 6.8) and use no platform-specific features.
- **A text editor** and roughly 85 minutes. Steps 1 to 4 take about 25 minutes, steps 5 to 10 about 40, and steps 11 and 12 about 20.
- **Browser access to the survey results pages** from Stack Overflow and JetBrains. You will copy denominators, question wordings and answer labels from them into the registry.

Basic comfort with Python dataclasses and the command line is enough. Each rule is a small function from a claim and a registry to a list of findings.

## Steps 1 and 2: Create the Project and the Survey Registry

**Step 1: lay out the skeleton.** Four folders keep concerns apart: code in `claimlint`, survey metadata in `registry`, claims under test in `claims` and unit tests in `tests`.

```
mkdir share-claim-linter && cd share-claim-linter
mkdir claimlint registry claims tests
touch claimlint/__init__.py tests/__init__.py
python3 --version
```

The last command should print `Python 3.12.3` or any later 3.x release. If it prints 3.10 or older, install a newer interpreter before going further, or the registry loader fails on its first import.

### Step 2: Fill the registry from the official pages

The registry holds one table per survey edition. Each table records who ran the survey, which edition it is, what kind of metric it reports, whether respondents could tick several tools, and the fields that make a percentage interpretable: denominator, sample size, question wording and the exact answer labels that map to Cursor and GitHub Copilot. Save this as `registry/surveys.toml`.

```
# Survey registry. Fill every field from the survey's own methodology page.
# Leave a field out (or set it to "") when you have not verified it. The linter treats gaps as findings.

[so_2025]
publisher = "Stack Overflow"
edition_year = 2025
population = "self-selected respondents to the Stack Overflow annual survey"
metric_kind = "usage"
multi_select = true
denominator = ""            # fill in: all respondents, or only those who answered the AI-tool question
sample_size = 0             # fill in from the official 2025 results page
question_wording = ""       # fill in: copy the exact question text
cursor_option = ""          # fill in: the exact answer label that maps to Cursor
copilot_option = ""         # fill in: the exact answer label that maps to GitHub Copilot

[so_2026]
publisher = "Stack Overflow"
edition_year = 2026
published = "2026-10-06"
population = "self-selected respondents to the Stack Overflow annual survey"
metric_kind = "usage"
multi_select = true
denominator = ""            # fill in from survey.stackoverflow.co/2026
sample_size = 30000         # lower bound: the press release reports more than 30,000 responses
countries = 169
question_wording = ""
cursor_option = ""
copilot_option = ""

[jb_2025]
publisher = "JetBrains"
edition_year = 2025
population = "developers reached through JetBrains channels and partner panels"
metric_kind = "usage"
multi_select = true
denominator = ""
sample_size = 0
question_wording = ""
cursor_option = ""
copilot_option = ""

[jb_2026]
publisher = "JetBrains"
edition_year = 2026
published = "2026-11-10"
fieldwork = "May-July 2026"
population = "developers reached through JetBrains channels and partner panels"
metric_kind = "usage"
multi_select = true
denominator = ""
sample_size = 28945
countries = 198
question_wording = ""
cursor_option = ""
copilot_option = ""

[seats_export]
publisher = "internal"
edition_year = 2026
population = "your own organization"
metric_kind = "paid_seats"
multi_select = false
denominator = "all engineers on payroll"
sample_size = 0
question_wording = "n/a (billing export)"

# Fully documented FIXTURE survey: made-up values that exist only to prove a claim can earn an A.
[fx_complete]
publisher = "fixture"
edition_year = 2026
population = "fixture respondents"
metric_kind = "usage"
multi_select = true
denominator = "fixture: all respondents who answered the AI-tool question"
sample_size = 10000
question_wording = "fixture: which AI coding tools did you use in the past year?"
cursor_option = "Cursor"
copilot_option = "GitHub Copilot"
```

Three design choices matter here. First, an empty string or a zero means unverified. The linter never treats a blank as acceptable, it reports it. Second, the 2026 Stack Overflow sample is stored as 30000 with a comment that it is a lower bound, because the publisher reports more than 30,000 responses rather than an exact count. Recording sample size matters because every interval calculation needs it, and the [guide to margin of error with Wilson intervals](https://shattered.io/cursor-vs-copilot-margin-of-error-wilson-interval-12-steps-2026/) shows how to turn it into a proper range. Third, the last table, `fx_complete`, is a fixture with every field filled in using made-up values. It exists so at least one test claim can earn a clean grade, and its fixture prefix in the denominator text keeps anyone from mistaking it for real data.

Leave the real survey tables blank until you have read the official results page. Filling in a denominator from memory defeats the purpose of the exercise. A blank costs you a warning. A wrong value costs you a published error.

## Steps 3 and 4: Claim Records and the Rule Registry

**Step 3: model the data.** Three frozen dataclasses carry everything. `Survey` mirrors one registry table. `Claim` describes one statement under test, including which survey each product’s number came from and whether the text uses market-share wording. `Finding` records one problem: the claim it belongs to, the rule that fired, a severity and a message. Two loader functions read the TOML registry and a JSON Lines claims file. Save this as `claimlint/models.py`.

``` python
from __future__ import annotations

import json
import tomllib
from dataclasses import dataclass, field
from pathlib import Path

SEVERITIES = {"info": 1, "warning": 2, "error": 3}

@dataclass(frozen=True)
class Survey:
    id: str
    publisher: str = ""
    edition_year: int = 0
    published: str = ""
    population: str = ""
    metric_kind: str = ""
    multi_select: bool | None = None
    denominator: str = ""
    sample_size: int = 0
    countries: int = 0
    question_wording: str = ""
    cursor_option: str = ""
    copilot_option: str = ""
    fieldwork: str = ""

@dataclass(frozen=True)
class Claim:
    id: str
    text: str
    cursor_value: float | None = None
    copilot_value: float | None = None
    cursor_survey: str = ""
    copilot_survey: str = ""
    metric_kind: str = ""
    year_in_text: int = 0
    uses_market_share_wording: bool = False
    mentions_product_scope: bool = False
    note: str = ""

@dataclass(frozen=True)
class Finding:
    claim_id: str
    rule: str
    severity: str
    message: str

@dataclass
class Report:
    findings: list[Finding] = field(default_factory=list)

    def for_claim(self, claim_id: str) -> list[Finding]:
        return [f for f in self.findings if f.claim_id == claim_id]

def load_registry(path: str | Path) -> dict[str, Survey]:
    raw = tomllib.loads(Path(path).read_text(encoding="utf-8"))
    return {key: Survey(id=key, **vals) for key, vals in raw.items()}

def load_claims(path: str | Path) -> list[Claim]:
    claims = []
    for line_no, line in enumerate(Path(path).read_text(encoding="utf-8").splitlines(), 1):
        line = line.strip()
        if not line or line.startswith("#"):
            continue
        try:
            claims.append(Claim(**json.loads(line)))
        except (TypeError, json.JSONDecodeError) as exc:
            raise ValueError(f"{path}:{line_no}: bad claim record: {exc}") from exc
    return claims
```

Claims live in JSON Lines because each record is one line, which makes diffs readable in pull requests and lets you append a claim without touching the others. The loader skips blank lines and lines starting with a hash, and it names the file and line number when a record is malformed. Unknown field names raise an error on purpose. A typo such as `cursor_pct` should fail loudly instead of silently dropping a number.

**Step 4: add the rule registry.** Rules are plain functions with the signature `(claim, registry) -> list[Finding]`. A decorator adds each one to a dictionary keyed by its id, so the runner and the command line discover rules without a hand-maintained list. Start `claimlint/rules.py` with the header below.

``` python
from __future__ import annotations

import math
from typing import Callable

from .models import Claim, Finding, Survey

Registry = dict[str, Survey]
Rule = Callable[[Claim, Registry], list[Finding]]

RULES: dict[str, Rule] = {}

def rule(rule_id: str) -> Callable[[Rule], Rule]:
    def register(fn: Rule) -> Rule:
        RULES[rule_id] = fn
        return fn

    return register

def _cited(claim: Claim, reg: Registry) -> list[Survey]:
    ids = {claim.cursor_survey, claim.copilot_survey} - {""}
    return [reg[i] for i in sorted(ids) if i in reg]

def _f(claim: Claim, rule_id: str, severity: str, message: str) -> Finding:
    return Finding(claim.id, rule_id, severity, message)
```

The helper `_cited` returns the registry entries a claim actually references, sorted so output stays stable between runs. Stable output matters later, when you diff reports in CI. The helper `_f` builds a finding with the claim id filled in, which removes the same boilerplate from all eleven rules.

## Steps 5 to 7: Source, Year, Cross-Survey and Metadata Rules

**Step 5: reject claims with no source or a phantom one.** R01 fires when a claim names no survey for either product. R02 fires when a name is not in the registry, which usually means a typo or a survey you have not documented yet. Both are errors, because a claim without a traceable source cannot be graded at all. Append them to `rules.py`.

``` php
@rule("R01-no-source")
def no_source(claim: Claim, reg: Registry) -> list[Finding]:
    if not claim.cursor_survey and not claim.copilot_survey:
        return [_f(claim, "R01-no-source", "error", "Claim cites no survey id for either product.")]
    return []

@rule("R02-unknown-survey")
def unknown_survey(claim: Claim, reg: Registry) -> list[Finding]:
    out = []
    for sid in sorted({claim.cursor_survey, claim.copilot_survey} - {""}):
        if sid not in reg:
            out.append(_f(claim, "R02-unknown-survey", "error", f"Survey '{sid}' is not in the registry."))
    return out
```

**Step 6: catch year drift and cross-survey comparisons.** R03 compares the year in the claim’s text with the edition year of every cited survey. A headline that says 2025 while pulling from the 2026 edition is a common accident, usually after someone refreshes a chart and forgets the title. R04 is the rule that matters most for any cursor vs copilot comparison: if the Cursor number and the Copilot number come from two different surveys, the claim fails outright, no matter how reasonable each number looks alone.

``` php
@rule("R03-year-mismatch")
def year_mismatch(claim: Claim, reg: Registry) -> list[Finding]:
    if not claim.year_in_text:
        return []
    out = []
    for s in _cited(claim, reg):
        if s.edition_year != claim.year_in_text:
            out.append(
                _f(claim, "R03-year-mismatch", "error",
                   f"Text says {claim.year_in_text} but {s.id} is the {s.edition_year} edition.")
            )
    return out

@rule("R04-cross-survey")
def cross_survey(claim: Claim, reg: Registry) -> list[Finding]:
    a, b = claim.cursor_survey, claim.copilot_survey
    if a and b and a != b:
        return [_f(claim, "R04-cross-survey", "error",
                   f"Cursor comes from {a} and Copilot from {b}: different populations, wording and denominators.")]
    return []
```

Run the rules you have so far against the fixture claims. The R03 and R04 fixtures should fail, and so should the claim with no source.

```
python3 -m claimlint --only R01-no-source,R02-unknown-survey,R03-year-mismatch,R04-cross-survey
[D] fx-02-cross-survey: Fixture: Copilot 40% (one survey) beats Cursor 10% (another survey).
    ERROR   R04-cross-survey: Cursor comes from jb_2026 and Copilot from so_2026: different populations, wording and denominators.
[D] fx-04-year-drift: Fixture: a 2025 headline that quietly cites the 2026 edition.
    ERROR   R03-year-mismatch: Text says 2025 but jb_2026 is the 2026 edition.
[D] fx-05-seats-vs-survey: Fixture: our paid seats compared with a survey usage rate.
    ERROR   R04-cross-survey: Cursor comes from seats_export and Copilot from jb_2026: different populations, wording and denominators.
[D] fx-06-no-source: Fixture: 'Everyone says Copilot is ahead.'
    ERROR   R01-no-source: Claim cites no survey id for either product.

8 claims checked. Grades: A=4, B=0, C=0, D=4
```

Four claims drop to grade D, for three different reasons, while the other four pass these four rules. The command prints only claims that have findings plus the summary, because the A-grade lines were filtered out of this excerpt. Your own output shows all eight.

**Step 7: demand documented metadata.** R05 checks the registry entry itself. For each cited survey it looks for a denominator and a question wording, and it checks that the answer option for the product being claimed has been mapped. The rule raises a warning, not an error, because a gap in the registry is a to-do item, not proof that the claim is wrong. Append it next.

``` python
@rule("R05-missing-metadata")
def missing_metadata(claim: Claim, reg: Registry) -> list[Finding]:
    out = []
    for s in _cited(claim, reg):
        gaps = [name for name in ("denominator", "question_wording")
                if not getattr(s, name)]
        if claim.cursor_survey == s.id and not s.cursor_option:
            gaps.append("cursor_option")
        if claim.copilot_survey == s.id and not s.copilot_option:
            gaps.append("copilot_option")
        if gaps:
            out.append(_f(claim, "R05-missing-metadata", "warning",
                          f"{s.id} registry entry is missing: {', '.join(gaps)}."))
    return out
python3 -m claimlint --only R05-missing-metadata
[C] fx-02-cross-survey: Fixture: Copilot 40% (one survey) beats Cursor 10% (another survey).
    WARNING R05-missing-metadata: jb_2026 registry entry is missing: denominator, question_wording, cursor_option.
    WARNING R05-missing-metadata: so_2026 registry entry is missing: denominator, question_wording, copilot_option.
```

The excerpt above shows two warnings for the cross-survey fixture. Each tells you exactly which registry fields to fill from the official page. Once you complete a survey’s entry, its warnings disappear for every claim that cites it, so the work scales with the number of surveys and not the number of claims.

## Steps 8 and 9: Multi-Select, Metric Type, Product Scope and Stale Editions

### Step 8: Block market-share wording on overlapping data

R06 targets the most common mistake in the whole topic. Survey questions about AI tools let respondents tick every tool they used, so each tool’s rate is a share of respondents and the rates overlap. Add the Cursor rate and the Copilot rate and you may exceed 100%, and even when you do not, neither number is a slice of a pie. Calling it market share promises a pie. R06 raises an error whenever a claim uses market-share wording and any cited survey is multi-select.

R07 catches the neighbouring mistake, mixing metric types. A usage rate from a survey, a count of paid seats from a billing export and a revenue figure answer three different questions. Comparing them produces a number with no meaning. A [seat audit that measures cost per active developer](https://shattered.io/cursor-vs-copilot-seat-audit-cost-per-active-developer-12-steps/) is a good source for the paid-seat side, as long as you keep it on its own side of the comparison.

``` php
@rule("R06-share-wording")
def share_wording(claim: Claim, reg: Registry) -> list[Finding]:
    if not claim.uses_market_share_wording:
        return []
    multi = [s.id for s in _cited(claim, reg) if s.multi_select]
    if multi:
        return [_f(claim, "R06-share-wording", "error",
                   f"'Market share' wording on multi-select data ({', '.join(multi)}): "
                   "usage rates overlap and do not sum to 100%.")]
    return []

@rule("R07-metric-mismatch")
def metric_mismatch(claim: Claim, reg: Registry) -> list[Finding]:
    kinds = {s.metric_kind for s in _cited(claim, reg)}
    if claim.metric_kind:
        kinds.add(claim.metric_kind)
    kinds.discard("")
    if len(kinds) > 1:
        return [_f(claim, "R07-metric-mismatch", "error",
                   f"Mixed metrics in one comparison: {', '.join(sorted(kinds))}.")]
    return []
[D] fx-03-market-share: Fixture: 'Copilot holds 40% market share to Cursor's 30%' from multi-select usage data.
    ERROR   R06-share-wording: 'Market share' wording on multi-select data (so_2026): usage rates overlap and do not sum to 100%.
[D] fx-05-seats-vs-survey: Fixture: our paid seats compared with a survey usage rate.
    ERROR   R07-metric-mismatch: Mixed metrics in one comparison: paid_seats, usage.

8 claims checked. Grades: A=6, B=0, C=0, D=2
```

**Step 9: flag unclear product scope and old editions.** R08 is informational. It reminds the author to state which product surface an answer option covered. The reminder matters more each month. Cursor’s own release notes list Gemini 4 Argon, Grok 4.7 and Claude Opus 5.5 as newly available models, and Cursor has extended well beyond the editor into cloud agents, an Agent SDK and voice chat, and reportedly live-app building. A forum thread reportedly describes a change from a $20 plan to a [unified X plan at $30](https://forum.cursor.com/t/introducing-the-x-subscription/174450/434). A survey answer labelled Cursor in one year may therefore not describe the same product surface in another. That is analysis, not a measured result, and R08 asks the author to address it.

R09 flags claims that cite an edition when the registry holds a newer one from the same publisher. It does not forbid citing the older edition, since a history piece may do so on purpose, but it makes the author confirm the choice. Append both rules.

``` php
@rule("R08-product-scope")
def product_scope(claim: Claim, reg: Registry) -> list[Finding]:
    if (claim.cursor_value is not None or claim.copilot_value is not None) and not claim.mentions_product_scope:
        return [_f(claim, "R08-product-scope", "info",
                   "Claim does not say which product surface the answer option covered "
                   "(editor, agents, plans, extensions).")]
    return []

@rule("R09-stale-edition")
def stale_edition(claim: Claim, reg: Registry) -> list[Finding]:
    out = []
    for s in _cited(claim, reg):
        newer = [o for o in reg.values()
                 if o.publisher == s.publisher and o.edition_year > s.edition_year]
        if newer:
            latest = max(newer, key=lambda o: o.edition_year)
            out.append(_f(claim, "R09-stale-edition", "warning",
                          f"{s.id} has a newer edition in the registry: {latest.id}."))
    return out
[C] fx-07-old-edition: Fixture: an older edition still cited as current.
    WARNING R09-stale-edition: so_2025 has a newer edition in the registry: so_2026.

8 claims checked. Grades: A=7, B=0, C=1, D=0
```

The old-edition fixture now shows a warning that names its successor. This is the rule that retires the 2025 numbers still circulating in older articles: the moment you add the 2026 editions to your registry, every claim citing a 2025 edition starts to nag.

## Steps 10 to 12: Noise Screen, Runner, CLI and Tests

**Step 10: add the sample-size checks.** R10 warns when a cited survey has no sample size. R11 runs a rough screen: when both values come from the same survey and the sample size is known, it treats the two rates as independent proportions and compares their gap with a 95% band. The independence assumption is crude, because both rates come from the same respondents, so treat a hit as a prompt to compute a proper interval. A miss is not proof of a real lead. Append the last two rules.

``` php
@rule("R10-no-sample")
def no_sample(claim: Claim, reg: Registry) -> list[Finding]:
    return [_f(claim, "R10-no-sample", "warning",
               f"{s.id} has no sample size, so noise cannot be judged.")
            for s in _cited(claim, reg) if s.sample_size <= 0]

@rule("R11-noise-gap")
def noise_gap(claim: Claim, reg: Registry) -> list[Finding]:
    if claim.cursor_value is None or claim.copilot_value is None:
        return []
    if claim.cursor_survey != claim.copilot_survey or claim.cursor_survey not in reg:
        return []
    n = reg[claim.cursor_survey].sample_size
    if n <= 0:
        return []
    p1, p2 = claim.cursor_value / 100, claim.copilot_value / 100
    se = math.sqrt(p1 * (1 - p1) / n + p2 * (1 - p2) / n)
    gap = abs(p1 - p2)
    if gap < 1.96 * se:
        return [_f(claim, "R11-noise-gap", "warning",
                   f"Gap of {gap * 100:.1f} points is inside the rough 95% noise band "
                   f"of {1.96 * se * 100:.1f} points.")]
    return []
python3 -m claimlint --only R04-cross-survey,R11-noise-gap
[A] fx-01-clean: Fixture: Copilot 40% vs Cursor 10% in the same survey, usage rates, product scope stated.
[D] fx-02-cross-survey: Fixture: Copilot 40% (one survey) beats Cursor 10% (another survey).
    ERROR   R04-cross-survey: Cursor comes from jb_2026 and Copilot from so_2026: different populations, wording and denominators.
[A] fx-03-market-share: Fixture: 'Copilot holds 40% market share to Cursor's 30%' from multi-select usage data.
[A] fx-04-year-drift: Fixture: a 2025 headline that quietly cites the 2026 edition.
[D] fx-05-seats-vs-survey: Fixture: our paid seats compared with a survey usage rate.
    ERROR   R04-cross-survey: Cursor comes from seats_export and Copilot from jb_2026: different populations, wording and denominators.
[A] fx-06-no-source: Fixture: 'Everyone says Copilot is ahead.'
[A] fx-07-old-edition: Fixture: an older edition still cited as current.
[C] fx-08-inside-noise: Fixture: Copilot 20.5% vs Cursor 20% called a lead.
    WARNING R11-noise-gap: Gap of 0.5 points is inside the rough 95% noise band of 1.1 points.

8 claims checked. Grades: A=5, B=0, C=1, D=2
```

With a sample of 10,000 in the fixture survey, a half-point gap sits inside a 1.1-point band, so the fixture claim earns a C. The 30-point gap in the clean fixture passes without comment.

### Step 11: Write the runner, the grades and the command line

The runner loops over claims and rules, collects findings and assigns a grade per claim. The grade is the worst severity found: A for none, B for info only, C for warnings, D for any error. Save this as `claimlint/report.py`.

``` python
from __future__ import annotations

import json

from .models import Claim, Finding, Report, SEVERITIES
from .rules import RULES, Registry

def run(claims: list[Claim], reg: Registry, only: set[str] | None = None) -> Report:
    report = Report()
    for claim in claims:
        for rule_id, fn in RULES.items():
            if only and rule_id not in only:
                continue
            report.findings.extend(fn(claim, reg))
    return report

def grade(findings: list[Finding]) -> str:
    worst = max((SEVERITIES[f.severity] for f in findings), default=0)
    return {0: "A", 1: "B", 2: "C", 3: "D"}[worst]

def render_text(claims: list[Claim], report: Report) -> str:
    lines = []
    for claim in claims:
        found = report.for_claim(claim.id)
        lines.append(f"[{grade(found)}] {claim.id}: {claim.text}")
        for f in sorted(found, key=lambda x: -SEVERITIES[x.severity]):
            lines.append(f"    {f.severity.upper():7} {f.rule}: {f.message}")
    grades = [grade(report.for_claim(c.id)) for c in claims]
    summary = ", ".join(f"{g}={grades.count(g)}" for g in "ABCD")
    lines.append(f"\n{len(claims)} claims checked. Grades: {summary}")
    return "\n".join(lines)

def render_json(claims: list[Claim], report: Report) -> str:
    payload = [
        {
            "claim": c.id,
            "grade": grade(report.for_claim(c.id)),
            "findings": [vars(f) for f in report.for_claim(c.id)],
        }
        for c in claims
    ]
    return json.dumps(payload, indent=2)

def exit_code(report: Report, fail_on: str) -> int:
    threshold = SEVERITIES[fail_on]
    return 1 if any(SEVERITIES[f.severity] >= threshold for f in report.findings) else 0
```

The exit-code function is what turns the linter into a gate. It returns 1 when any finding meets the chosen threshold and 0 otherwise. Now the command line. Save this as `claimlint/cli.py`, plus the one-line `__main__.py` that makes `python3 -m claimlint` work.

``` python
from __future__ import annotations

import argparse
import sys

from .models import load_claims, load_registry
from .report import exit_code, render_json, render_text, run
from .rules import RULES

def main(argv: list[str] | None = None) -> int:
    p = argparse.ArgumentParser(prog="claimlint", description="Lint Cursor vs Copilot share claims.")
    p.add_argument("--registry", default="registry/surveys.toml")
    p.add_argument("--claims", default="claims/claims.jsonl")
    p.add_argument("--format", choices=["text", "json"], default="text")
    p.add_argument("--fail-on", choices=["info", "warning", "error"], default="error")
    p.add_argument("--only", help="comma-separated rule ids to run")
    p.add_argument("--list-rules", action="store_true")
    args = p.parse_args(argv)

    if args.list_rules:
        print("\n".join(sorted(RULES)))
        return 0

    reg = load_registry(args.registry)
    claims = load_claims(args.claims)
    only = set(args.only.split(",")) if args.only else None
    unknown = (only or set()) - set(RULES)
    if unknown:
        print(f"unknown rule ids: {', '.join(sorted(unknown))}", file=sys.stderr)
        return 2

    report = run(claims, reg, only)
    print(render_json(claims, report) if args.format == "json" else render_text(claims, report))
    return exit_code(report, args.fail_on)

if __name__ == "__main__":
    raise SystemExit(main())
python
from .cli import main

raise SystemExit(main())
```

**Step 12: add the claims file and the tests.** Save the fixtures below as `claims/claims.jsonl`. Each line targets one rule on purpose, and the first line is a comment reminding every reader that the numbers are fixtures.

```
# FIXTURES ONLY. The numbers below are made-up test values, not survey results.
{"id": "fx-01-clean", "text": "Fixture: Copilot 40% vs Cursor 10% in the same survey, usage rates, product scope stated.", "cursor_value": 10, "copilot_value": 40, "cursor_survey": "fx_complete", "copilot_survey": "fx_complete", "metric_kind": "usage", "year_in_text": 2026, "mentions_product_scope": true}
{"id": "fx-02-cross-survey", "text": "Fixture: Copilot 40% (one survey) beats Cursor 10% (another survey).", "cursor_value": 10, "copilot_value": 40, "cursor_survey": "jb_2026", "copilot_survey": "so_2026", "metric_kind": "usage", "year_in_text": 2026}
{"id": "fx-03-market-share", "text": "Fixture: 'Copilot holds 40% market share to Cursor's 30%' from multi-select usage data.", "cursor_value": 30, "copilot_value": 40, "cursor_survey": "so_2026", "copilot_survey": "so_2026", "metric_kind": "usage", "year_in_text": 2026, "uses_market_share_wording": true}
{"id": "fx-04-year-drift", "text": "Fixture: a 2025 headline that quietly cites the 2026 edition.", "cursor_value": 20, "copilot_value": 21, "cursor_survey": "jb_2026", "copilot_survey": "jb_2026", "metric_kind": "usage", "year_in_text": 2025}
{"id": "fx-05-seats-vs-survey", "text": "Fixture: our paid seats compared with a survey usage rate.", "cursor_value": 25, "copilot_value": 60, "cursor_survey": "seats_export", "copilot_survey": "jb_2026", "metric_kind": "usage"}
{"id": "fx-06-no-source", "text": "Fixture: 'Everyone says Copilot is ahead.'", "metric_kind": "usage"}
{"id": "fx-07-old-edition", "text": "Fixture: an older edition still cited as current.", "cursor_value": 15, "copilot_value": 30, "cursor_survey": "so_2025", "copilot_survey": "so_2025", "metric_kind": "usage", "year_in_text": 2025}
{"id": "fx-08-inside-noise", "text": "Fixture: Copilot 20.5% vs Cursor 20% called a lead.", "cursor_value": 20, "copilot_value": 20.5, "cursor_survey": "fx_complete", "copilot_survey": "fx_complete", "metric_kind": "usage", "year_in_text": 2026, "mentions_product_scope": true}
```

The tests build a tiny in-memory registry rather than reading the TOML file, so they keep passing while you fill the real registry. Each rule gets at least one positive case. The share-wording test also checks the negative case on non-multi-select data, and the runner test checks grades and exit codes. Save this as `tests/test_rules.py`.

``` python
import unittest

from claimlint.models import Claim, Survey
from claimlint.report import exit_code, grade, run
from claimlint.rules import RULES

def reg():
    full = dict(publisher="X", edition_year=2026, metric_kind="usage", multi_select=True,
                denominator="all respondents", sample_size=10000, question_wording="q",
                cursor_option="Cursor", copilot_option="GitHub Copilot")
    return {
        "a": Survey(id="a", **full),
        "b": Survey(id="b", **{** full, "publisher": "Y"}),
        "old": Survey(id="old", **{** full, "edition_year": 2025}),
        "seats": Survey(id="seats", **{** full, "metric_kind": "paid_seats", "multi_select": False}),
        "empty": Survey(id="empty", publisher="X", edition_year=2026),
    }

def ids(claim, rule_id):
    return [f for f in RULES[rule_id](claim, reg())]

class RuleTests(unittest.TestCase):
    def test_no_source(self):
        self.assertEqual(len(ids(Claim(id="c", text="t"), "R01-no-source")), 1)

    def test_unknown_survey(self):
        c = Claim(id="c", text="t", cursor_survey="nope", copilot_survey="a")
        self.assertEqual(len(ids(c, "R02-unknown-survey")), 1)

    def test_year_mismatch(self):
        c = Claim(id="c", text="t", cursor_survey="a", copilot_survey="a", year_in_text=2025)
        self.assertEqual(len(ids(c, "R03-year-mismatch")), 1)

    def test_cross_survey(self):
        c = Claim(id="c", text="t", cursor_survey="a", copilot_survey="b")
        self.assertEqual(len(ids(c, "R04-cross-survey")), 1)

    def test_missing_metadata(self):
        c = Claim(id="c", text="t", cursor_survey="empty", copilot_survey="empty")
        self.assertEqual(len(ids(c, "R05-missing-metadata")), 1)

    def test_share_wording_needs_multi_select(self):
        c = Claim(id="c", text="t", cursor_survey="a", copilot_survey="a", uses_market_share_wording=True)
        self.assertEqual(len(ids(c, "R06-share-wording")), 1)
        c2 = Claim(id="c", text="t", cursor_survey="seats", copilot_survey="seats", uses_market_share_wording=True)
        self.assertEqual(ids(c2, "R06-share-wording"), [])

    def test_metric_mismatch(self):
        c = Claim(id="c", text="t", cursor_survey="seats", copilot_survey="a")
        self.assertEqual(len(ids(c, "R07-metric-mismatch")), 1)

    def test_stale_edition(self):
        c = Claim(id="c", text="t", cursor_survey="old", copilot_survey="old")
        self.assertEqual(len(ids(c, "R09-stale-edition")), 1)

    def test_no_sample(self):
        c = Claim(id="c", text="t", cursor_survey="empty", copilot_survey="empty")
        self.assertEqual(len(ids(c, "R10-no-sample")), 1)

    def test_noise_gap(self):
        close = Claim(id="c", text="t", cursor_survey="a", copilot_survey="a", cursor_value=20, copilot_value=20.5)
        wide = Claim(id="c", text="t", cursor_survey="a", copilot_survey="a", cursor_value=10, copilot_value=40)
        self.assertEqual(len(ids(close, "R11-noise-gap")), 1)
        self.assertEqual(ids(wide, "R11-noise-gap"), [])

class RunnerTests(unittest.TestCase):
    def test_grade_and_exit_code(self):
        bad = Claim(id="bad", text="t")
        good = Claim(id="good", text="t", cursor_survey="a", copilot_survey="a",
                     cursor_value=10, copilot_value=40, mentions_product_scope=True, year_in_text=2026)
        report = run([bad, good], reg())
        self.assertEqual(grade(report.for_claim("bad")), "D")
        self.assertEqual(grade(report.for_claim("good")), "A")
        self.assertEqual(exit_code(report, "error"), 1)
        self.assertEqual(exit_code(run([good], reg()), "info"), 0)

if __name__ == "__main__":
    unittest.main()
python3 -m unittest discover -s tests -t .
...........
----------------------------------------------------------------------
Ran 11 tests in 0.001s

OK
```

## Reading the Output: What Each Grade Means

Run the full linter and keep only the grade lines. With the registry still mostly blank, every claim that cites a real survey carries registry warnings underneath its grade.

```
python3 -m claimlint | grep -E '^\[|checked'
[A] fx-01-clean: Fixture: Copilot 40% vs Cursor 10% in the same survey, usage rates, product scope stated.
[D] fx-02-cross-survey: Fixture: Copilot 40% (one survey) beats Cursor 10% (another survey).
[D] fx-03-market-share: Fixture: 'Copilot holds 40% market share to Cursor's 30%' from multi-select usage data.
[D] fx-04-year-drift: Fixture: a 2025 headline that quietly cites the 2026 edition.
[D] fx-05-seats-vs-survey: Fixture: our paid seats compared with a survey usage rate.
[D] fx-06-no-source: Fixture: 'Everyone says Copilot is ahead.'
[C] fx-07-old-edition: Fixture: an older edition still cited as current.
[C] fx-08-inside-noise: Fixture: Copilot 20.5% vs Cursor 20% called a lead.
8 claims checked. Grades: A=1, B=0, C=2, D=5
```

Read the report from the grade down, not from the top. Only `fx-01-clean` reaches A, because only the fixture survey has a complete registry entry. The market-share fixture falls to D on R06 even though both of its numbers come from one survey and one year, which shows that a claim can look tidy and still carry a false premise. The seats-versus-survey fixture collects two errors (R04 and R07) on top of registry warnings, which is what a genuinely muddled comparison looks like.

Keep this reference table nearby when you read a report. It lists every rule, its severity and the mistake it catches.

| Rule | Severity | What it catches | 
|---|---|---|
| R01-no-source | Error | Claim names no survey for either product | 
| R02-unknown-survey | Error | Survey id missing from the registry | 
| R03-year-mismatch | Error | Year in the text differs from the cited edition | 
| R04-cross-survey | Error | Cursor and Copilot numbers come from different sources | 
| R05-missing-metadata | Warning | Registry lacks denominator, wording or option mapping | 
| R06-share-wording | Error | Market-share wording on multi-select data | 
| R07-metric-mismatch | Error | Seats, usage or revenue mixed in one comparison | 
| R08-product-scope | Info | Claim does not state which product surface was measured | 
| R09-stale-edition | Warning | A newer edition exists in the registry | 
| R10-no-sample | Warning | Sample size unknown | 
| R11-noise-gap | Warning | Gap sits inside a rough 95% noise band | 

The grades translate into editorial decisions:

- **A:** no findings. The claim names a source, the registry documents it, and nothing in the rules contradicts the wording. This does not prove the claim true. It proves the claim is checkable.
- **B:** info only, typically the product-scope reminder. Publish after adding one sentence about what the answer option covered.
- **C:** warnings. Fill the registry gaps, confirm the edition choice or compute a proper interval before publishing.
- **D:** at least one error. Rewrite the claim. A different survey, a different verb or a different metric usually fixes it, and sometimes the right answer is to drop the comparison.

For machines, the same data comes out as JSON. This is a single claim from `--format json`, ready for a dashboard or a pull-request comment bot.

```
python3 -m claimlint --format json --only R04-cross-survey
[
  {
    "claim": "fx-02-cross-survey",
    "grade": "D",
    "findings": [
      {
        "claim_id": "fx-02-cross-survey",
        "rule": "R04-cross-survey",
        "severity": "error",
        "message": "Cursor comes from jb_2026 and Copilot from so_2026: different populations, wording and denominators."
      }
    ]
  }
]
```

Finally, the exit codes behave as the CLI promises. A run with errors returns 1 under the default threshold, and `--fail-on warning` and `--fail-on info` also return 1 on this fixture set because it contains warnings and info findings too. An unknown rule id returns 2 and prints a message to stderr. Use 0 as the signal that a claim file is clean.

## Why the Products Behind the Numbers Keep Moving

A linter cannot fix the fact that Cursor and GitHub Copilot change faster than annual surveys can follow. GitHub moved Copilot to usage-based billing on June 1, 2026, replacing premium request units with GitHub AI Credits, and one credit equals $0.01. The individual lineup became Free, Pro, Pro+ and Max, with Business and Enterprise for organizations. The [official plans page](https://github.com/features/copilot/plans) lists the current credit allowances.

| Copilot plan | Monthly price | Monthly included usage | 
|---|---|---|
| Pro | $10 | $15 in total credits | 
| Pro+ | $39 | $70 in total credits | 
| Max | $100 | $200 in total credits | 
| Business | $19 per user | $19 in monthly GitHub AI Credits | 
| Enterprise | $39 per user | $39 in monthly GitHub AI Credits | 

Plan prices took effect June 1, 2026, and annual Pro and Pro+ subscribers stayed on the earlier premium-request system until their plans expired. For a side-by-side of what each tier buys, the [pricing and limits comparison of Claude Code, Cursor and Copilot](https://shattered.io/claude-code-vs-cursor-vs-github-copilot-pricing-limits-2026/) goes deeper. For survey work, the takeaway is narrower: a survey answer that says GitHub Copilot lumps together free users, individual subscribers and enterprise seats, and no 2025 or 2026 percentage lets you split them.

Model availability shifts even faster. According to GitHub’s [November 2026 changelog](https://github.blog/changelog/month/11-2026/page/2/), Gemini 4 Neon became generally available in Copilot on November 18 for Pro+, Max, Business and Enterprise users. GPT-6.2 Astra and GPT-6.2 Sol, plus Microsoft’s MAI Code 2 and MAI Code 2 Flash, arrived on November 17. On November 16 GitHub deprecated several older models across most Copilot experiences, including Claude Opus 4.8, Claude Opus 5 and GPT-5.6 Terra, though Opus 4.8 stayed available to individual annual-plan subscribers. A [comparison of seven AI models in eleven days across Copilot and Cursor](https://shattered.io/github-copilot-vs-cursor-4-models-8-days-2026/) tracks how quickly the lineups swap.

GitHub’s Gemini 4 Carbon release on November 10 and, reportedly, Claude Fable 5.2, covered in the [Pro+ and Max plan breakdown](https://shattered.io/github-copilot-agentic-coding-carbon-fable-5-2-pro-plus-39-max-100-2026/), push in the same direction. Model names, plan prices and product surfaces all moved within weeks. A 2025 survey percentage describes the product as the respondent understood it at the time. It cannot describe a tool whose plans, models and billing model were rewritten afterwards. The registry’s `edition_year` field and rules R03 and R09 exist to keep that distinction visible.

## Common Pitfalls That Break Cursor vs Copilot Share Claims

Seven mistakes account for most of the damage. The linter catches four of them mechanically (the first, third, fourth and fifth). The other three need human judgement.

1. **Treating a blank registry field as fine.** A missing denominator means the percentage has no base. The linter raises R05 so the gap stays visible. Fill it from the official page, never from a roundup that paraphrased it.
2. **Copying figures from blog roundups.** Secondary posts drop the question wording and the filter. Two roundups quoting the same survey can disagree because one used all respondents and the other only those who answered the AI question. Read the original results page.
3. **Letting the headline year drift.** A chart refreshed with the 2026 edition under a 2025 title is the classic case. R03 compares text year to edition year on every run.
4. **Calling overlapping rates market share.** Multi-select rates cannot sum to a market. If you need a pie, you need a single-choice question or a seat export, and you need to say so.
5. **Mixing seats, usage and revenue.** Paid seats measure purchasing, usage rates measure behaviour. Keep each on its own side, as R07 enforces.
6. **Reading grade A as proof.** A clean grade means the claim is checkable. A self-selected survey sample can still mislead, so report the population in the sentence that carries the number.
7. **Confusing popularity with quality.** A tool can lead on usage and trail on output. If readers want to know which one writes better code, point them to a[head-to-head benchmark of Cursor and GitHub Copilot](https://shattered.io/benchmark-cursor-vs-github-copilot-2026/) rather than a survey rate.

Notice how little any of these mistakes depends on the actual numbers. That is the reason a rule-based check works at all: it tests the structure of the claim, which fails far more often than the arithmetic does.

## Troubleshooting: 10 Failures and Their Fixes

1. **ModuleNotFoundError: No module named ‘claimlint’.** You ran the command from the wrong folder. Change into`share-claim-linter` , the folder that contains`claimlint/` , and run it again.
2. **ModuleNotFoundError: No module named ‘tomllib’.** Your interpreter is older than 3.11. Install Python 3.11 or newer, or run the project with the newer binary explicitly, for example`python3.12 -m claimlint` .
3. **tomllib.TOMLDecodeError: Expected ‘]’ at the end of a table declaration.** A table header lost its closing bracket. The error names the line and column, so open`registry/surveys.toml` at that spot and restore`[so_2026]` .
4. **ValueError: … bad claim record: Expecting property name enclosed in double quotes.** A JSON line has a trailing comma or single quotes. JSON Lines forbids both. Remove the comma after the last field and use double quotes.
5. **ValueError: … got an unexpected keyword argument ‘cursor_pct’.** A claim uses a field the dataclass does not define. Rename it to`cursor_value` or add the field to`Claim` and to the rules that need it.
6. **TypeError: ‘>’ not supported between instances of ‘int’ and ‘str’.** A registry year was written as a quoted string, as in`edition_year = "2026"` . Remove the quotes so TOML reads an integer.
7. **FileNotFoundError: No such file or directory: registry/surveys.toml.** The default paths are relative to the current directory. Pass`--registry` and`--claims` with absolute paths when you run the tool from elsewhere.
8. **Every claim shows R02-unknown-survey.** The survey ids in the claims file do not match the table names in the registry. Ids are case-sensitive, so`JB_2026` and`jb_2026` are different surveys.
9. **Exit code is 1 but the output looks fine.** The default threshold is error. Info and warning findings do not trip it, but any D-grade claim does. Scroll up to find the claim with the ERROR line, or add`--fail-on warning` to see the stricter result.
10. **unknown rule ids: R99 and exit code 2.** The`--only` flag got an id that does not exist. Run`python3 -m claimlint --list-rules` to see all eleven valid ids.

## Advanced Tips for Stricter Claim Checks

**Gate pull requests.** Wrap the unit tests and the linter in one script and call it from whatever CI you use. Use the warning threshold for published pages and the error threshold for drafts, so authors get a hard stop only on the mistakes that always matter.

``` bash
#!/bin/sh
set -e
python3 -m unittest discover -s tests -t .
python3 -m claimlint --fail-on warning
```

If your team already runs agents in pipelines, the [headless Cursor CLI in GitHub Actions](https://shattered.io/cursor-cli-github-actions-headless-agent-2026/) setup shows one way to wire them in, and a drafted claim list could feed this linter for grading. Keep the human in the loop for the registry, though. An agent that fills in denominators from memory reintroduces the exact error the registry exists to prevent.

**Add per-edition rules as the surveys change.** The rule decorator makes extension cheap. Good candidates are a rule that warns when the population field says self-selected and the claim uses words such as typical or average developer, and a rule that flags claims whose answer-option label differs between two editions of the same survey. Option labels change, and a renamed label breaks year-over-year comparisons without any visible sign.

**Version the registry like code.** Commit it, and review changes to denominators in pull requests. When a publisher issues a correction or a revised dataset, the diff shows which claims need a second look.

**Pair the linter with real intervals.** R11 is a screen. Replace it with a Wilson interval check once your claims carry enough data, and keep R10 so missing sample sizes still surface. Teams that publish many tool comparisons can also collect the passing claims into a topic hub, such as the [coding and developer tools section](https://shattered.io/category/software/), so readers find the vetted numbers in one place.

## The Complete Project and One-Command Run

The finished tree contains ten files and about 400 lines of code. Nothing outside the standard library is imported.

```
share-claim-linter/
  claimlint/
    __init__.py
    __main__.py
    cli.py
    models.py
    report.py
    rules.py
  claims/
    claims.jsonl
  registry/
    surveys.toml
  tests/
    __init__.py
    test_rules.py
```

To run everything from a clean checkout, execute the two commands below. The tests run first and the linter second, and the final line of the report summarizes the grades.

```
python3 -m unittest discover -s tests -t .
python3 -m claimlint --fail-on warning
```

On the fixture set the unit tests print `OK` after 11 tests, and the linter ends with `8 claims checked. Grades: A=1, B=0, C=2, D=5` and exits with code 1. The nonzero exit is expected here, because the fixtures are built to fail. Replace the fixtures with your own claims, fill the registry from the official pages, and the same command becomes a pass-or-fail check on your next article.

Start with one survey. Document its denominator, wording and answer labels, point three real claims at it, and watch the warnings drop. Adding the second survey then surfaces the cross-survey comparisons nobody noticed.

## FAQ: Cursor vs GitHub Copilot Share Claims

**Which survey shows who leads, Cursor or GitHub Copilot?**

Neither survey reports a market share. Each reports usage among its own respondents, and a Cursor vs Copilot gap from one survey applies only to that survey’s population. Read the product rows on the official results page, record the denominator, and quote the number with its population attached.

**Can I put the 2025 Stack Overflow number next to the 2026 JetBrains number?**

No. They come from different publishers, different years, different populations and probably different denominators. Rule R04 blocks the cross-survey part and rule R03 blocks the year mix. Compare each publisher’s two editions to each other instead, after checking that the answer labels did not change.

**Why does the linter treat market-share wording as an error?**

Survey questions about tools let respondents choose several, so the rates overlap. A share implies slices of a whole. Use the phrase usage rate for survey data, and save market share for single-choice questions or complete seat and revenue data.

**Does a grade of A mean the claim is true?**

No. It means the claim is checkable: the source exists, the registry documents it, and nothing in the rules contradicts the wording. A self-selected sample can still skew the underlying number, so say who was surveyed in the sentence itself.

**How do I add a third survey?**

Add a table to `registry/surveys.toml` with a new id, then fill every field from the survey’s methodology page. Reference the id from claims. R09 automatically compares editions that share a publisher name, so use the same spelling for every edition.

**Does the linter need an internet connection or an API key?**

No. It reads two local files and the standard library. That is deliberate. A check that depends on live services can fail for reasons unrelated to the claim, and it is harder to run inside a locked-down CI runner.

**Can it handle Copilot plan tiers or Cursor plans separately?**

Not by default, because the surveys do not split them. If your own data does, as a seat export does, add each tier as its own registry entry with the paid-seats metric and keep it out of survey comparisons. Rule R07 then stops the two kinds of numbers from mixing.
