cd /news/ai-tools/cursor-vs-copilot-seat-audit-12-step… · home › topics › ai-tools › article
[ARTICLE · art-172250] src=shattered.io ↗ pub= topic=ai-tools verified=true sentiment=· neutral

Cursor vs Copilot Seat Audit: 12 Steps, 75 Min

No verified, dated dataset measures Cursor against GitHub Copilot on seat share or active-developer share as of November 19, 2026, according to a Shattered audit of published figures. The audit shows Stack Overflow's 2025 Developer Survey numbers — 17.9% of respondents using Cursor as a development IDE and 67.9% of 8,323 respondents who answered that question having used GitHub Copilot — rest on different denominators, so placing 18% beside 68% does not establish a market lead. The audit instead offers a roughly 200-line standard-library Python project that joins a Copilot seat export, a Cursor member export and a team roster in 12 steps over about 75 minutes to report assigned share, active share, utilization, overlap, idle spend, orphan seats and cost per active developer.

recommendation

Audit AI-assistant seats locally by joining Copilot and Cursor exports with your roster to surface idle spend and orphan seats before renewal; published survey rates like 17.9% versus 67.9% use different denominators and cannot size your team's usage.

more in playbook: Controlling LLM cost
by read37 min views2 publishedNov 19, 2026
Cursor vs Copilot Seat Audit: 12 Steps, 75 Min
Image: Shattered (auto-discovered)

Stack Overflow’s 2025 developer survey put Cursor at 18% of developers and GitHub Copilot at 68% of developers who use out-of-the-box AI assistants, according to the survey’s press release. Those two figures look like a market-share verdict for the Cursor vs Copilot fight. They are not one. The first counts everyone who answered, the second counts only a subset, and neither says a word about how many people on your team open the tool on a Tuesday.

As of November 19, 2026, no verified, dated dataset measures Cursor against Copilot on seat share or active-developer share. The vendors publish growth claims, the survey publishes usage rates, and nobody publishes the one ratio a team lead needs at renewal time. A public-survey share audit shows how to read the published numbers. The project below answers a different question: what share do the two tools hold inside your own organization, and what does each active developer cost?

The build is a standard-library Python project (about 200 lines) that joins a Copilot seat export, a Cursor member export, and your roster. It reports assigned share, active share, utilization, overlap, idle spend, orphan seats, and cost per active developer. Twelve steps, about 75 minutes, no paid services, and no data leaves your machine.

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

Why Published Cursor vs Copilot Share Numbers Cannot Settle Your Seat Decision #

Every public number in this market counts something different. That is the whole problem. A share figure only means something when numerator and denominator are both stated, and most headlines state neither.

Take the Stack Overflow data. The 2025 survey reports that 17.9% of respondents used Cursor as a development IDE. It also reports that 67.9% of 8,323 respondents who answered the relevant question had used GitHub Copilot. The press materials then add a third framing: 68% of developers using out-of-the-box AI assistants selected Copilot. Stack Overflow wrote in its press release for that survey:

“In the 2025 Stack Overflow Developer Survey, 18% of developers reported using Cursor, while 68% of developers using out-of-the-box AI assistants selected GitHub Copilot.”

Read that sentence twice. Cursor’s 18% is a share of all developers. Copilot’s 68% is a share of one filtered group. Stack Overflow’s own September 30, 2026 retrospective on the 2025 findings repeats the 68% figure with the same filter. Putting 18% beside 68% and calling the gap a market lead mixes two denominators. For a method to compare survey rates fairly, the Stack Overflow survey walkthrough in pandas covers the weighting questions in detail.

Source Reported figure What the denominator is What it cannot tell you
Stack Overflow 2025 survey 17.9% used Cursor as a development IDE Survey respondents Seats, spend, or frequency of use
Stack Overflow 2025 survey 67.9% used GitHub Copilot 8,323 respondents who answered that question Whether they still use it today
Stack Overflow 2025 press release 68% chose Copilot Developers using out-of-the-box AI assistants Share among all developers
GitHub, May 2026 140,000 organizations use Copilot Organizations, not developers Developers per organization

The vendors add their own units. GitHub said Copilot served 140,000 organizations, nearly triple the number a year earlier, with overall growth above 100% year over year, in a May 2026 post about its Gartner Magic Quadrant placement. That counts organizations. A ten-person startup and a 40,000-seat bank each add one. Cursor’s enterprise page claims use by 64% of Fortune 500 companies, which is a marketing claim about logos, not about developers. OpenAI reportedly counts more than 5 million weekly active Codex users, a third unit again (weekly actives on a different product).

Four sources, four denominators: respondents, filtered respondents, organizations, and Fortune 500 logos. None converts into the number that drives your budget. Sampling error also hides inside every survey percentage, and a team of 40 developers is a tiny sample on its own.

Your own exports have none of these problems. They are a census, not a sample. You know the headcount, you know who holds a seat, and both vendors record when each seat was last used.

Prerequisites and Versions for the Seat Audit #

The project needs almost nothing. It runs on a laptop, reads three CSV files, and writes a markdown report. Budget about 75 minutes if you already have admin access to both tools, and add a day of waiting if you need someone else to approve exports.

Requirement Version or access Why you need it
Python 3.10 or newer Standard library only, no pip installs
Operating system Linux, macOS, or Windows with WSL Any shell that runs Python works
GitHub access Read-only token, org owner or billing manager rights Lists Copilot seat assignments
GitHub REST API version Not listed Pins the response format
Cursor access Team admin rights Provides members and last-active dates
Roster CSV with email, GitHub login, team Defines the headcount denominator
Disk Under 10 MB CSV files and one report

Time budget by phase: Phase 1 (define metrics) takes 10 minutes, Phase 2 (collect exports) takes 25, Phase 3 (join and count) takes 20, and Phase 4 (price, report, test) takes 20. The remaining time goes to reading the output.

Three rules before you start. First, keep the project folder outside any shared repository, because the CSV files contain employee identifiers. Second, ask HR or your privacy officer whether per-person activity data may be processed for license management. Third, use a read-only token. The audit never needs write access.

You also need to decide what active means before you see any numbers. Writing that definition down first stops the common failure where a team picks the window that makes its favorite tool look best.

Phase 1: Define the Metrics Before You Touch Data #

Seat audits go wrong at the definition stage far more often than in the code. These three steps take ten minutes and save an argument later.

Step 1: Write down the seven numbers

Every metric below uses your headcount as the common denominator, which is the fix for the survey problem above. Copy this table into your project notes.

Metric Formula What it answers
Assigned share Matched seats / headcount How widely licensed is each tool?
Active share Developers active in the window / headcount How widely used is each tool?
Utilization Active developers / seats How much of what you pay for gets used?
Idle spend (Seats minus active) x seat price What does unused capacity cost per month?
Cost per active developer (Seat spend + variable spend) / active What does one working user really cost?
Overlap Developers active on both tools Are you paying twice for the same people?
Orphan seats Seats with no roster match Who holds a seat but does not work here?

Assigned share and active share are the internal versions of the market-share numbers you cannot find publicly. Utilization and cost per active developer are the numbers that decide renewals.

Step 2: Fix the as-of date and the activity window

Pick one as-of date and one window length, then freeze both in a config file. This project uses November 19, 2026 and a 30-day window. A developer counts as active when the tool’s last-activity date falls on or after the cutoff, which is 30 days before the as-of date. The boundary is inclusive, and a test later proves it.

A 30-day window suits most teams. A window that spans late-November holidays or a company shutdown understates activity for every tool equally, so compare the same window across tools and across months. Never compare a 30-day Copilot number with a 90-day Cursor number.

Step 3: Create the project layout and config

Make the folder and the config file. The prices in the config are placeholders, not list prices. Replace them with the per-seat amounts on your own invoices, after discounts and annual billing.

mkdir -p seat-audit/data seat-audit/tests seat-audit/out
cd seat-audit
python3 --version
printf 'data/\nout/\n' > .gitignore

The config maps each tool to its input file, the column that identifies a person, the column holding the last-active date, and an optional column for variable spend. Mapping columns in config instead of in code matters because export formats change.

{
  "as_of": "2026-11-19",
  "window_days": 30,
  "min_group_size": 5,
  "roster": "data/roster.csv",
  "tools": {
    "copilot": {
      "file": "data/copilot_seats.csv",
      "key": "github_login",
      "roster_key": "github_login",
      "last_active": "last_activity_at",
      "variable_usd": "variable_usd",
      "seat_usd_per_month": 20.0
    },
    "cursor": {
      "file": "data/cursor_members.csv",
      "key": "email",
      "roster_key": "email",
      "last_active": "last_seen",
      "variable_usd": "api_spend_usd",
      "seat_usd_per_month": 30.0
    }
  }
}

Variable spend deserves its own column because both products now meter usage beyond the seat. GitHub began moving Copilot usage to GitHub AI Credits on June 1, 2026, and its pricing page states that 1 AI credit equals $0.01. Pro, Pro+, and Max list monthly total credits of $15, $70, and $200 respectively. Cursor’s newer plans bill third-party models (Claude, GPT, and Gemini) at API list prices from prepaid credit on Premium and above, according to a November 14, 2026 pricing breakdown. A seat price alone no longer predicts a bill, which is why the project tracks both parts. For the plan-by-plan view of limits, see the pricing and limits comparison of Claude Code, Cursor, and Copilot.

Phase 2: Collect the Copilot and Cursor Exports #

Three CSV files feed the audit: Copilot seats, Cursor members, and the roster. Collect them in this order, because the roster decides which identifiers to look for in the other two.

Step 4: Build the roster

The roster is your headcount denominator, so it should list everyone who could plausibly hold a seat and nobody else. Export it from your identity provider or HR system with three columns: email, github_login, and team. Exclude people on long leave only if you also exclude them from billing conversations. Keep contractors in the roster if they hold seats, tagged with their own team name.

Two details trip people up. GitHub logins and emails are different identifiers, so the roster carries both. And the roster must be current. A stale roster turns every departed employee into an orphan seat and every new hire into a developer with no seat.

If you want to dry-run the pipeline before touching real data, this generator writes a synthetic 57-person team with a fixed random seed, so your output matches the sample later in this article.

import csv
import random
from datetime import date, timedelta

random.seed(7)
AS_OF = date(2026, 11, 19)
TEAMS = {"platform": 14, "payments": 12, "mobile": 10, "data": 9, "growth": 8, "security": 4}

roster, copilot, cursor = [], [], []
n = 0
for team, size in TEAMS.items():
    for _ in range(size):
        n += 1
        email = f"dev{n:02d}@example.com"
        login = f"dev{n:02d}-gh"
        roster.append({"email": email, "github_login": login, "team": team})
        if random.random() < 0.85:
            gap = random.choice([1, 2, 3, 5, 8, 12, 20, 29, 45, 70])
            copilot.append({
                "github_login": login,
                "last_activity_at": (AS_OF - timedelta(days=gap)).isoformat() + "T09:30:00Z",
                "variable_usd": round(random.choice([0, 0, 0, 4.5, 11.0, 27.5]), 2),
            })
        if random.random() < 0.55:
            gap = random.choice([0, 1, 2, 4, 6, 9, 15, 25, 33, 60])
            cursor.append({
                "email": email.upper() if n % 7 == 0 else email,
                "last_seen": (AS_OF - timedelta(days=gap)).isoformat(),
                "api_spend_usd": round(random.choice([0, 0, 8.25, 19.0, 64.4, 140.0]), 2),
            })

copilot.append({"github_login": "former-contractor-gh", "last_activity_at": "2026-08-02T10:00:00Z", "variable_usd": 0})
cursor.append({"email": "[email protected]", "last_seen": "never", "api_spend_usd": 0})

def dump(path, rows):
    with open(path, "w", newline="", encoding="utf-8") as fh:
        w = csv.DictWriter(fh, fieldnames=list(rows[0]))
        w.writeheader()
        w.writerows(rows)

dump("data/roster.csv", roster)
dump("data/copilot_seats.csv", copilot)
dump("data/cursor_members.csv", cursor)
print(len(roster), len(copilot), len(cursor))

Step 5: Export Copilot seats with a read-only token

GitHub’s REST API lists Copilot seat assignments per organization, and each seat record includes the assignee’s login and a last-activity timestamp. The script below paginates through the list and writes a CSV. It reads the token from an environment variable, never from a file, and it sends the pinned API version header.

#!/usr/bin/env python3
"""Export Copilot seat assignments for one org to CSV (read-only)."""
import csv
import json
import os
import sys
import urllib.error
import urllib.request

API = "https://api.github.com/orgs/{org}/copilot/billing/seats?per_page=100&page={page}"

def fetch_page(org, page, token):
    req = urllib.request.Request(
        API.format(org=org, page=page),
        headers={
            "Authorization": f"Bearer {token}",
            "Accept": "application/vnd.github+json",
            "X-GitHub-Api-Version": "2022-11-28",
        },
    )
    try:
        with urllib.request.urlopen(req, timeout=30) as resp:
            return json.load(resp)
    except urllib.error.HTTPError as err:
        sys.exit(f"GitHub returned {err.code} for page {page}: {err.reason}")

def main(org, out_path):
    token = os.environ.get("GITHUB_TOKEN")
    if not token:
        sys.exit("Set GITHUB_TOKEN to a read-only token first.")
    rows, page = [], 1
    while True:
        seats = fetch_page(org, page, token).get("seats", [])
        if not seats:
            break
        for seat in seats:
            rows.append({
                "github_login": seat["assignee"]["login"].lower(),
                "last_activity_at": seat.get("last_activity_at") or "never",
                "last_activity_editor": seat.get("last_activity_editor") or "",
                "plan_type": seat.get("plan_type") or "",
                "variable_usd": 0,
            })
        page += 1
    with open(out_path, "w", newline="", encoding="utf-8") as fh:
        w = csv.DictWriter(fh, fieldnames=list(rows[0]) if rows else ["github_login"])
        w.writeheader()
        w.writerows(rows)
    print(f"wrote {len(rows)} seats to {out_path}")

if __name__ == "__main__":
    if len(sys.argv) != 3:
        sys.exit("usage: fetch_copilot.py ORG OUTPUT.csv")
    main(sys.argv[1], sys.argv[2])

Run it with GITHUB_TOKEN=... python3 fetch_copilot.py your-org data/copilot_seats.csv. GitHub’s documentation lists the token scopes the endpoint accepts, so check the current page and choose the narrowest read-only option. A seat that has never been used comes back with an empty activity field, which the script writes as never.

Packaging is shifting here. According to GitHub’s plans page and documentation, enterprise packaging is moving toward a unified GitHub Enterprise plus AI-credit model rather than a separate Copilot subscription. If your licenses come through an enterprise account, the organization endpoint may not show every seat, so fall back to the billing export in your enterprise settings and map its columns in the config. Teams weighing Copilot against an agent-first rival instead of Cursor can adapt the same audit to the pairing in GitHub Copilot vs Claude Code.

Step 6: Export Cursor members and map the columns

Cursor’s team dashboard is the source for member data. If your plan exposes a member or usage export, download it. If it only shows a table, copy the table into a spreadsheet and save it as CSV. Column names differ by plan and change over time, so this project never hard-codes them. Open the file, find the column that holds each person’s email and the column that holds the last-active date, and put those names in config.json.

Dates must arrive in ISO format (2026-11-18). If the export uses another format, convert the column in your spreadsheet before saving. Add an API spend column if your export has one, or leave the variable_usd mapping out and the audit treats variable spend as zero for that tool.

Check the file’s first rows before moving on. A header with a leading blank, a date column full of relative text such as 2 days ago, or a members list that includes pending invitations will each distort the counts, and it is faster to fix them now than to explain them later.

Phase 3: Join, Count, and Classify Developers #

The core logic is three functions. Each one is small enough to read in a minute, and each one does exactly one job.

Step 7: Load the files and normalize identifiers

The s read each CSV, lowercase every identifier, and parse dates. Lowercasing fixes the most common cause of false orphans: an export that writes [email protected][email protected]utf-8-sig strips the invisible byte-order mark that Excel adds to CSV files, which otherwise corrupts the first column name. If a person appears twice in one export, the keeps the latest activity date.

#!/usr/bin/env python3
"""Seat audit: Cursor vs Copilot from your own exports."""
import argparse
import csv
import json
from datetime import date, datetime, timedelta
from pathlib import Path

TOOLS = ("copilot", "cursor")

def parse_day(raw):
    raw = (raw or "").strip()
    if not raw or raw.lower() in {"never", "null", "none", "n/a"}:
        return None
    return datetime.fromisoformat(raw.replace("Z", "+00:00")).date()

def credits_to_usd(credits, usd_per_credit=0.01):
    return round(float(credits) * usd_per_credit, 2)

def load_roster(path):
    with open(path, newline="", encoding="utf-8-sig") as fh:
        rows = list(csv.DictReader(fh))
    for row in rows:
        row["team"] = (row.get("team") or "").strip() or "unassigned"
    return rows

def load_seats(path, spec):
    seats = {}
    with open(path, newline="", encoding="utf-8-sig") as fh:
        for row in csv.DictReader(fh):
            key = (row.get(spec["key"]) or "").strip().lower()
            if not key:
                continue
            seat = {
                "last_active": parse_day(row.get(spec["last_active"])),
                "variable_usd": float(row.get(spec.get("variable_usd", ""), "") or 0),
            }
            old = seats.get(key)
            if old and old["last_active"] and (
                not seat["last_active"] or old["last_active"] > seat["last_active"]
            ):
                seat["last_active"] = old["last_active"]
            seats[key] = seat
    return seats

Step 8: Join seats to people and flag activity

The join walks the roster once. For each person and each tool it looks up the seat, records whether the seat exists, and records whether the last activity falls inside the window. Seats that no roster row claims become orphans, and their variable spend travels with them so it still shows up in the total.

def join(roster, seats_by_tool, cfg):
    as_of = date.fromisoformat(cfg["as_of"])
    cutoff = as_of - timedelta(days=cfg["window_days"])
    rows, matched = [], {t: set() for t in TOOLS}
    for person in roster:
        row = {"email": person["email"], "team": person["team"]}
        for tool in TOOLS:
            key = (person.get(cfg["tools"][tool]["roster_key"]) or "").strip().lower()
            seat = seats_by_tool[tool].get(key) if key else None
            if seat:
                matched[tool].add(key)
            last = seat["last_active"] if seat else None
            row[f"{tool}_seat"] = seat is not None
            row[f"{tool}_active"] = bool(last and last >= cutoff)
            row[f"{tool}_variable_usd"] = seat["variable_usd"] if seat else 0.0
        rows.append(row)
    orphans = {}
    for tool in TOOLS:
        keys = sorted(set(seats_by_tool[tool]) - matched[tool])
        orphans[tool] = {
            "count": len(keys),
            "variable_usd": sum(seats_by_tool[tool][k]["variable_usd"] for k in keys),
            "keys": keys,
        }
    return rows, orphans

Two design choices matter. The cutoff comparison uses greater-than-or-equal, so a developer whose last activity landed exactly 30 days before the as-of date still counts. And the function returns orphans separately instead of dropping them, because an orphan seat is both a cost leak and a security finding.

Step 9: Summarize shares, overlap, and team splits

The summary function turns per-person rows into the metrics from Step 1. The overlap block classifies every developer into one of four groups: active on both tools, Copilot only, Cursor only, or no AI activity. The share-of-AI-users figures divide by developers active on at least one tool, which is the closest internal analogue to the survey’s filter on developers who use AI assistants. Reporting both views side by side (headcount denominator and AI-user denominator) shows exactly how much the choice of denominator moves the answer.

def summarize(rows, orphans, cfg):
    n = len(rows)
    out = {"headcount": n, "tools": {}}
    for tool in TOOLS:
        price = cfg["tools"][tool]["seat_usd_per_month"]
        matched = sum(r[f"{tool}_seat"] for r in rows)
        extra = orphans[tool]["count"] if orphans else 0
        extra_var = orphans[tool]["variable_usd"] if orphans else 0.0
        active = sum(r[f"{tool}_active"] for r in rows)
        seats = matched + extra
        variable = sum(r[f"{tool}_variable_usd"] for r in rows) + extra_var
        total = seats * price + variable
        out["tools"][tool] = {
            "seats": seats,
            "orphan_seats": extra,
            "assigned_share": round(matched / n, 4) if n else 0.0,
            "active": active,
            "active_share": round(active / n, 4) if n else 0.0,
            "utilization": round(active / seats, 4) if seats else 0.0,
            "idle_seats": seats - active,
            "idle_spend_usd": round((seats - active) * price, 2),
            "seat_spend_usd": round(seats * price, 2),
            "variable_spend_usd": round(variable, 2),
            "total_spend_usd": round(total, 2),
            "cost_per_active_usd": round(total / active, 2) if active else None,
        }
    both = sum(r["copilot_active"] and r["cursor_active"] for r in rows)
    cop_only = sum(r["copilot_active"] and not r["cursor_active"] for r in rows)
    cur_only = sum(r["cursor_active"] and not r["copilot_active"] for r in rows)
    any_active = both + cop_only + cur_only
    out["overlap"] = {
        "both_active": both,
        "copilot_only": cop_only,
        "cursor_only": cur_only,
        "any_active": any_active,
        "no_ai_activity": n - any_active,
        "copilot_share_of_ai_users": round((both + cop_only) / any_active, 4) if any_active else 0.0,
        "cursor_share_of_ai_users": round((both + cur_only) / any_active, 4) if any_active else 0.0,
    }
    return out

def by_team(rows, cfg):
    groups = {}
    for r in rows:
        groups.setdefault(r["team"], []).append(r)
    floor = cfg["min_group_size"]
    big = {t: g for t, g in groups.items() if len(g) >= floor}
    small = [r for t, g in groups.items() if len(g) < floor for r in g]
    if small:
        big["Other (small teams)"] = small
    if "Other (small teams)" in big and len(big["Other (small teams)"]) < floor:
        del big["Other (small teams)"]
    return {t: summarize(g, None, cfg) for t, g in sorted(big.items())}

The team breakdown enforces a privacy floor. Any team with fewer than min_group_size people is merged into an Other bucket, and if that bucket is still too small it is dropped. Otherwise a four-person team’s report would reveal exactly who is using what. The floor also protects you from reading noise as signal. Percentages from five or six people swing by 15 to 20 points when a single person changes habits, a problem the margin-of-error walkthrough for Cursor vs Copilot quantifies with confidence intervals.

Phase 4: Price the Seats, Write the Report, and Test It #

The last three steps turn counts into money, money into a readable report, and the report into something you can trust.

Step 10: Apply the cost model

Cost lives inside summarize: seats times the configured price, plus variable spend, divided by active developers. Idle spend multiplies the idle seat count by the seat price. When a tool has zero active developers, cost per active returns None and the report prints n/a instead of dividing by zero or showing a misleading zero.

The credits_to_usd helper converts Copilot AI credits to dollars at the documented $0.01 per credit, so a usage export that lists credits becomes a variable_usd column with one line of spreadsheet math. A $10 budget covers 1,000 credits, and GitHub’s settings page alerts at 75%, 90%, and 100% of any configured budget, which makes a useful cross-check against your own total.

Keep the seat price honest. If you pay annually, use the effective monthly amount. If you hold a mix of plans, run the audit once per plan and add the results, or extend the config with a per-seat price column. A single blended price hides the difference between a $15-credit seat and a $200-credit seat.

Step 11: Render the report and wire up the command line

The renderer builds a markdown report with the headline table, the overlap paragraph, the orphan list, and the team table. The main function reads the config, runs the pipeline, and writes three files: report.md, summary.json, and orphans.csv.

def pct(x):
    return f"{x * 100:.1f}%"

def usd(x):
    return "n/a" if x is None else f"${x:,.2f}"

def render(summary, teams, orphans, cfg):
    t = summary["tools"]
    o = summary["overlap"]
    lines = [
        f"# Cursor vs Copilot seat audit, as of {cfg['as_of']}",
        "",
        f"Activity window: {cfg['window_days']} days. Headcount in roster: {summary['headcount']}.",
        "",
        "| Metric | Copilot | Cursor |",
        "|---|---|---|",
        f"| Seats (incl. orphans) | {t['copilot']['seats']} | {t['cursor']['seats']} |",
        f"| Assigned share of headcount | {pct(t['copilot']['assigned_share'])} | {pct(t['cursor']['assigned_share'])} |",
        f"| Active developers | {t['copilot']['active']} | {t['cursor']['active']} |",
        f"| Active share of headcount | {pct(t['copilot']['active_share'])} | {pct(t['cursor']['active_share'])} |",
        f"| Seat utilization | {pct(t['copilot']['utilization'])} | {pct(t['cursor']['utilization'])} |",
        f"| Idle seat spend / month | {usd(t['copilot']['idle_spend_usd'])} | {usd(t['cursor']['idle_spend_usd'])} |",
        f"| Total spend / month | {usd(t['copilot']['total_spend_usd'])} | {usd(t['cursor']['total_spend_usd'])} |",
        f"| Cost per active developer | {usd(t['copilot']['cost_per_active_usd'])} | {usd(t['cursor']['cost_per_active_usd'])} |",
        "",
        "## Overlap",
        "",
        f"Active on both: {o['both_active']}. Copilot only: {o['copilot_only']}. "
        f"Cursor only: {o['cursor_only']}. No AI activity: {o['no_ai_activity']}.",
        f"Among developers active on at least one tool, Copilot reaches {pct(o['copilot_share_of_ai_users'])} "
        f"and Cursor reaches {pct(o['cursor_share_of_ai_users'])}.",
        "",
        "## Orphan seats (no roster match)",
        "",
        f"Copilot: {orphans['copilot']['count']}. Cursor: {orphans['cursor']['count']}. "
        "Check these against your offboarding list first.",
        "",
        "## By team (groups under the privacy floor are merged)",
        "",
        "| Team | Headcount | Copilot active | Cursor active | Both |",
        "|---|---|---|---|---|",
    ]
    for name, s in teams.items():
        lines.append(
            f"| {name} | {s['headcount']} | {pct(s['tools']['copilot']['active_share'])} | "
            f"{pct(s['tools']['cursor']['active_share'])} | {s['overlap']['both_active']} |"
        )
    return "\n".join(lines) + "\n"

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--config", default="config.json")
    ap.add_argument("--out", default="out")
    args = ap.parse_args()
    cfg = json.loads(Path(args.config).read_text())
    base = Path(args.config).resolve().parent
    roster = load_roster(base / cfg["roster"])
    seats = {t: load_seats(base / cfg["tools"][t]["file"], cfg["tools"][t]) for t in TOOLS}
    rows, orphans = join(roster, seats, cfg)
    summary = summarize(rows, orphans, cfg)
    teams = by_team(rows, cfg)
    out = Path(args.out)
    out.mkdir(parents=True, exist_ok=True)
    (out / "summary.json").write_text(
        json.dumps({"overall": summary, "teams": teams}, indent=2)
    )
    (out / "report.md").write_text(render(summary, teams, orphans, cfg))
    with open(out / "orphans.csv", "w", newline="", encoding="utf-8") as fh:
        w = csv.writer(fh)
        w.writerow(["tool", "key"])
        for tool in TOOLS:
            for key in orphans[tool]["keys"]:
                w.writerow([tool, key])
    print((out / "report.md").read_text())

if __name__ == "__main__":
    main()

Run it from the project folder:

python3 make_sample.py
python3 seataudit.py --config config.json --out out
cat out/orphans.csv

Step 12: Write tests that pin the edge cases

Six tests cover the places where seat audits quietly go wrong: the inclusive window boundary, a seat one day outside the window, orphan pricing, variable spend in cost per active, the small-team merge, and the credit conversion. Put them in tests/test_seataudit.py.

import unittest
from datetime import date

import seataudit as sa

CFG = {
    "as_of": "2026-11-19",
    "window_days": 30,
    "min_group_size": 2,
    "tools": {
        "copilot": {"roster_key": "github_login", "seat_usd_per_month": 20.0},
        "cursor": {"roster_key": "email", "seat_usd_per_month": 30.0},
    },
}
ROSTER = [
    {"email": "[email protected]", "github_login": "a-gh", "team": "t1"},
    {"email": "[email protected]", "github_login": "b-gh", "team": "t1"},
    {"email": "[email protected]", "github_login": "c-gh", "team": "t2"},
]

def seat(day, var=0.0):
    return {"last_active": date.fromisoformat(day) if day else None, "variable_usd": var}

class SeatAuditTests(unittest.TestCase):
    def test_window_edge_is_inclusive(self):
        seats = {"copilot": {"a-gh": seat("2026-10-20")}, "cursor": {}}
        rows, _ = sa.join(ROSTER, seats, CFG)
        self.assertTrue(rows[0]["copilot_active"])

    def test_one_day_outside_window_is_idle(self):
        seats = {"copilot": {"a-gh": seat("2026-10-19")}, "cursor": {}}
        rows, _ = sa.join(ROSTER, seats, CFG)
        self.assertFalse(rows[0]["copilot_active"])
        self.assertTrue(rows[0]["copilot_seat"])

    def test_orphans_are_counted_and_priced(self):
        seats = {"copilot": {"ghost-gh": seat("2026-11-01", 5.0)}, "cursor": {}}
        rows, orphans = sa.join(ROSTER, seats, CFG)
        s = sa.summarize(rows, orphans, CFG)
        self.assertEqual(orphans["copilot"]["count"], 1)
        self.assertEqual(s["tools"]["copilot"]["total_spend_usd"], 25.0)
        self.assertIsNone(s["tools"]["copilot"]["cost_per_active_usd"])

    def test_cost_per_active_includes_variable_spend(self):
        seats = {
            "copilot": {"a-gh": seat("2026-11-10", 10.0), "b-gh": seat(None)},
            "cursor": {},
        }
        rows, orphans = sa.join(ROSTER, seats, CFG)
        s = sa.summarize(rows, orphans, CFG)["tools"]["copilot"]
        self.assertEqual(s["total_spend_usd"], 50.0)
        self.assertEqual(s["cost_per_active_usd"], 50.0)
        self.assertEqual(s["idle_seats"], 1)

    def test_small_team_is_merged(self):
        rows, _ = sa.join(ROSTER, {"copilot": {}, "cursor": {}}, CFG)
        teams = sa.by_team(rows, CFG)
        self.assertIn("t1", teams)
        self.assertNotIn("t2", teams)

    def test_credit_conversion(self):
        self.assertEqual(sa.credits_to_usd(1000), 10.0)

if __name__ == "__main__":
    unittest.main()

Run the suite with PYTHONPATH=. python3 -m unittest discover -s tests -v. All six should pass in well under a second. If you later change the cost model or the window logic, a failing test tells you before a wrong number reaches a budget meeting.

Sample Output From the Synthetic 57-Person Team #

Running the command on the generated data produces the report below. Every number here comes from synthetic data with a fixed seed and placeholder prices of $20 per Copilot seat and $30 per Cursor seat. Treat them as a demonstration of the format, never as a statement about either product.


Activity window: 30 days. Headcount in roster: 57.

| Metric | Copilot | Cursor |
|---|---|---|
| Seats (incl. orphans) | 55 | 29 |
| Assigned share of headcount | 94.7% | 49.1% |
| Active developers | 44 | 23 |
| Active share of headcount | 77.2% | 40.4% |
| Seat utilization | 80.0% | 79.3% |
| Idle seat spend / month | $220.00 | $180.00 |
| Total spend / month | $1,394.00 | $2,214.10 |
| Cost per active developer | $31.68 | $96.27 |

## Overlap

Active on both: 18. Copilot only: 26. Cursor only: 5. No AI activity: 8.
Among developers active on at least one tool, Copilot reaches 89.8% and Cursor reaches 46.9%.

## Orphan seats (no roster match)

Copilot: 1. Cursor: 1. Check these against your offboarding list first.

## By team (groups under the privacy floor are merged)

| Team | Headcount | Copilot active | Cursor active | Both |
|---|---|---|---|---|
| data | 9 | 77.8% | 33.3% | 3 |
| growth | 8 | 87.5% | 50.0% | 3 |
| mobile | 10 | 80.0% | 50.0% | 4 |
| payments | 12 | 66.7% | 41.7% | 4 |
| platform | 14 | 92.9% | 28.6% | 3 |

Read the output from the top. For each tool, compare its matched seats plus any orphan seats against your headcount to get its assigned share. Then compare active share and utilization. In this synthetic team the two tools are about equally well used per seat, but Cursor costs far more per active developer because its sample variable spend is heavier. That pattern is an artifact of the generator. In a real audit you would check whether the variable spend is concentrated in a few heavy users, since a few people running expensive agent sessions can make a tool look costly while delivering the most value.

The overlap line shows 18 developers active on both tools and 8 with no AI activity at all. Those 8 are the first conversation to have, before anyone debates which tool wins. The share-of-AI-users line is the closest analogue to a market-share number, and it differs sharply from the headcount view. That gap is the denominator effect from the survey section, reproduced inside one small team.

The security team (4 people) does not appear in the team table. That is the privacy floor working as designed: with a floor of 5, a four-person team merges into the Other bucket, which is itself too small and gets dropped.

Usage numbers also say nothing about output quality. When the audit shows a close call, run a controlled task comparison such as the Cursor vs GitHub Copilot benchmark before moving any licenses.

Common Pitfalls #

These seven mistakes account for most wrong audit numbers. Each one is cheap to avoid once you know it exists.

1. Dividing by the wrong denominator. If you divide active developers by seats, you measure utilization. If you divide by headcount, you measure reach. Both are useful, but they answer different questions, and mixing them in one sentence reproduces the survey confusion. Label every percentage with its denominator.

2. Treating an assigned seat as a used seat. A seat stays billable until someone removes it. A seat with an empty or stale last-activity field is spend without usage. The report separates assigned share from active share for this reason.

3. Joining on the wrong identifier. Copilot identifies people by GitHub login, Cursor by email, and your roster by both. Personal GitHub accounts, plus-addressed emails, and mixed-case addresses all create false orphans. If your orphan count looks high, inspect orphans.csv before trusting any other number.

4. Ignoring variable spend. A seat price tells you the floor, not the bill. With Copilot usage metered in AI credits and Cursor billing third-party models at API list prices on higher tiers, two teams on the same plan can have very different invoices. Include the variable column or state clearly that your cost-per-developer figure is a floor.

5. Comparing different windows. A 30-day Copilot figure next to a 90-day Cursor figure favors whichever tool got the longer window. Freeze one window in the config and apply it to every tool.

6. Publishing per-person data. The audit exists to size licenses, not to rank people. Report at team level, keep the privacy floor, and keep the row-level join out of slide decks. If a manager asks who is not using a tool, point them to the license-reclamation process instead of a name list.

7. Trusting list prices. Your negotiated rate, annual discount, and promotional credits change the real cost. Pull the numbers from invoices, and recheck them after every plan change. Cursor’s recent restructuring is a good example, as the state-of-play section below explains.

Troubleshooting Seat Audit Problems #

Most failures show up as a Python traceback or as a number that looks too good. This table maps the ten symptoms people hit most often to their causes and fixes.

Symptom Likely cause Fix
KeyError naming a column such as email Config column name does not match the export header, or the file has a byte-order mark Open the CSV, copy the exact header into config.json, and keep the utf-8-sig
ValueError: Invalid isoformat string Dates arrive as 11/18/2026 or as relative text Convert the column to ISO year-month-day dates in a spreadsheet before saving
fetch_copilot.py exits with an authentication error Token missing, expired, or lacking the needed scope Create a fresh read-only token and confirm the endpoint’s accepted scopes in GitHub’s docs
fetch_copilot.py exits with an authorization or not-found error Token not authorized for the org’s SSO, wrong org name, or Copilot billed at enterprise level Authorize the token for SSO, check the org slug, or use the enterprise billing export
Every seat shows as an orphan roster_key points at the wrong roster column, or identifiers differ in form Compare one login or email in the roster and the export by eye and fix the config mapping
Active count is zero for a tool people clearly use as_of date set in the past, window too short, or last-activity fields empty Check the newest date in the export against as_of and widen the window if needed
Cost per active developer prints n/a No developer was active in the window Verify date parsing, then confirm the window and the as_of date
A team is missing from the team table The team has fewer people than min_group_size Keep the floor, or lower it only with written approval from your privacy owner
Total spend differs from the invoice Placeholder prices, proration, discounts, or variable spend not exported Replace config prices with invoice amounts and add the variable column
Copilot seat count is lower than billing shows Seats managed through an enterprise account are not in the organization list Export from the enterprise billing page and map its columns

When none of these fits, print the first five rows of each loaded dictionary in an interactive Python session. A wrong key shape is visible within seconds.

Advanced Tips for Better Cursor vs Copilot Audits #

The base project answers one snapshot question. These upgrades turn it into a monitoring habit.

Schedule it. Run the audit on the first of each month and keep the summary.json files. Three months of trend lines beat one dramatic snapshot, and they reveal whether a drop in active share is a real decline or a holiday dip. If your team already automates agents in CI, the walkthrough on running Cursor’s CLI in GitHub Actions shows the pattern for scheduled jobs. Keep the CSV exports out of the repository, and upload only the aggregate summary as an artifact. Pin the action versions to the current majors or to commit SHAs when you adapt this.

name: seat-audit
on:
  schedule:
    - cron: "0 6 1 * *"
  workflow_dispatch:
permissions:
  contents: read
jobs:
  audit:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"
      - name: Fetch Copilot seats
        env:
          GITHUB_TOKEN: ${{ secrets.COPILOT_READ_TOKEN }}
        run: python3 fetch_copilot.py your-org data/copilot_seats.csv
      - name: Run audit
        run: python3 seataudit.py --config config.json --out out
      - uses: actions/upload-artifact@v4
        with:
          name: seat-audit-summary
          path: out/summary.json
          retention-days: 90

Add a third tool. The TOOLS tuple and the config drive everything, so adding another assistant takes one config block and one tuple entry. OpenAI’s own rate card estimates Codex at roughly $100 to $200 per developer per month on average, with real cost varying by model, concurrent instances, automations, and fast mode, which makes it a good candidate for the variable-spend column.

Weight by depth of use. A last-activity date says a developer touched the tool, not how much. If an export offers request counts or agent sessions, add a second threshold such as active on at least eight separate days, and report light users and heavy users separately. Light users often justify a cheaper plan, and heavy users often justify an upgrade.

Run multiple windows. Compute 7-day, 30-day, and 90-day active shares in one pass. A tool with strong 90-day reach and weak 7-day reach is losing people. The reverse pattern signals a recent rollout that is still ramping.

Reclaim idle seats on a schedule. Send each team owner the list of seats idle for 60 days, with a two-week notice before removal. Reclaiming idle seats is the highest-return action in the whole project, and it needs no debate about which tool is better.

Chart the denominator drift. Store headcount alongside every snapshot. A share that falls because hiring outpaced seat purchases tells a different story from one that falls because developers stopped logging in.

Keeping the Audit Data Safe #

Seat exports look harmless, but they are employee activity records with names and timestamps. Treat them like any other HR-adjacent dataset.

Start with access. Keep the working folder on an encrypted disk, restrict it to the two or three people running the audit, and add data/ and out/ to .gitignore on day one. A token with read-only scope limits the damage if the script ever leaks, and storing it in an environment variable keeps it out of config files and commits.

Next, limit what leaves the project. The report shows team-level percentages and an orphan list. Share the report, not the row-level join. If you need to circulate the orphan list, send it only to the IT and security owners who handle offboarding.

Orphan seats deserve a security review, not just a billing one. A seat held by someone who left the company is a live account tied to your tenant. In the synthetic sample, the audit flags one former contractor’s Copilot login and one alumni address on Cursor. In a real organization, each orphan should trigger the same offboarding checklist you use for other SaaS accounts.

Finally, keep the toolchain small. This project installs nothing, so no package can add a surprise dependency. That choice has a security payoff. Cursor itself posted a security notice about malicious versions of an Anthropic Claude Code extension (versions 2.1.312 and 2.1.313) in the Cursor VS Code Extension Marketplace, a reminder that developer tooling is an active supply-chain target. A script with zero third-party packages leaves nothing to compromise.

Set a retention rule too. Delete raw exports after the report is approved, keep only the aggregated summary.json, and write the deletion date in your notes. Activity data you no longer hold cannot leak.

Turning the Numbers Into a Renewal Decision #

A report changes nothing until it triggers a decision. Use simple rules and write them down before the next audit so the thresholds are not negotiable after the fact.

First, fix the waste. Idle seats cost money whichever tool you prefer. If utilization falls below your threshold (many teams pick 60% to 70%), reclaim seats before you renew anything. The idle-spend row gives you the monthly figure to put in the proposal.

Second, check the overlap. Developers active on both tools are paying for two assistants. That is sometimes justified, because one tool may handle inline completion while the other runs longer agent tasks. It is wasteful when both are used the same way. Ask the overlap group which tool they would keep, and weigh the answer more heavily than any survey.

Third, compare cost per active developer with a cost-and-value mindset. A tool that costs more per active developer can still win if it removes review cycles or lets a team ship faster. The audit supplies the cost side. The value side needs an outcome measure such as cycle time or review turnaround, which no seat export can provide.

Fourth, plan switches deliberately. Moving a team from one tool to the other costs configuration time, not just license fees. The guide on migrating from Copilot instructions to Cursor rules lists what carries over and what needs rewriting. Run a two-month pilot with a single team, rerun the audit at the end, and compare active share before and after.

Fifth, set a recheck date. Both vendors have changed packaging within the past few months, so a decision that is right today can be wrong by next quarter. Put the next audit on the calendar when you sign.

Where Cursor and Copilot Stand on November 19, 2026 #

Both products changed quickly this autumn, and the changes affect how you read an audit. Treat what follows as the current state, and check each vendor’s pages before you sign anything.

GitHub added a run of models to Copilot in under ten days. According to GitHub’s November 2026 changelog, Gemini 4 Carbon reached general availability on November 10 and Gemini 4 Hydrogen on November 13. OpenAI’s GPT-6.2 Astra and GPT-6.2 Sol arrived on November 17, alongside MAI Code 2 and MAI Code 2 Flash. Gemini 4 Neon followed on November 18 for Pro+, Max, Business, and Enterprise users, billed at provider list prices under usage-based billing. GitHub also deprecated unspecified Copilot models on November 16. For auditors, the lesson is that usage-based billing makes variable spend a first-class number.

Cursor restructured its plans in the same period. Since October 12, new customers have reportedly bought through a structure called The X Subscription, with Free, Plus at $8 a month, Premium at $30, Super at $100, and Ultra at $200. The older Pro plan at $20 and Pro+ plan at $60 are now treated as legacy offerings, and a pricing breakdown reports that moving from a legacy plan to the new structure cannot be reversed. For your audit, that means a team may hold seats on two different Cursor structures at once, so run the cost model once per plan, as Step 10 suggests.

On the product side, Cursor said cloud agents start three times faster with builds (announced November 10) and added Voice Chat with Agents on November 6 for paid plans with cloud agents enabled. A headline on Cursor’s own blog says its recurring revenue doubled in three months to $2 billion, which is a company claim and not an independent measurement.

Two cautions apply. A report that a tool is growing quickly says nothing about whether your team uses it. And no verified number puts Cursor against Copilot on seat share, so any article that quotes one deserves a hard look at its denominator. The model churn on both sides is covered in the comparison of Copilot and Cursor model releases, and the wider coding and developer tools coverage tracks pricing changes as they land.

Frequently Asked Questions #

Is there a reliable Cursor vs Copilot market share figure? Not as of November 19, 2026. Published numbers use different denominators: survey respondents, filtered respondents, organizations, and company logos. For a decision about your own licenses, your seat exports beat any public statistic.

Which tool costs less per active developer? It depends on your plan mix and usage. The audit computes it from your own seat prices and variable spend. The sample figures in this article come from synthetic data and say nothing about either product.

What counts as an active developer? Anyone whose last-activity date falls inside your chosen window, 30 days in this project. Pick the window before you look at results and apply it to every tool.

Can I run the audit without the GitHub API? Yes. Export Copilot seats from the billing page, save them as CSV, and map the columns in config.json. The API script only saves typing. Enterprise-billed seats often need the billing export anyway.

How often should I rerun it? Monthly is a good default. Rerun it after any plan change, rollout, or reorganization, and keep the summary files so you can chart trends.

Is tracking per-developer activity allowed? That depends on your jurisdiction and your employment policies. Check with HR and your privacy officer before you start, report at team level, apply a privacy floor, and delete raw exports once the report is approved.

Will Cursor’s plan changes break the audit? The code does not care about plan names, only about seats, dates, and prices in the config. If you hold seats on both legacy and new structures, run the cost model per plan and add the totals.

Can the project handle a third assistant? Yes. Add the tool to the TOOLS tuple, add a config block, and extend the report table. The join and summary logic loops over tools instead of naming them.

── more in #ai-tools 4 stories · sorted by recency
── more on @cursor 3 stories trending now
sponsored brought to you by zahid.host 4,200+ EU-deployed projects
reading about agents? ship yours in a single git push.

Run your AI side-project on zahid.host

EU-based hosting, git-push deploys, automatic HTTPS, no cold starts. Free tier with a custom domain — perfect for shipping the agent you just read about.

$git push zahid main
→ Live at https://your-agent.zahid.host ✓
Get free account → Pricing
from €0/mo · no card required
LIVE [news/cursor-vs-copilot-se…] indexed:0 read:37min 2026-11-19 · —