JetBrains put GitHub Copilot at 21% work use among surveyed professional developers in its May to July 2026 wave, down from 29% in January 2026. Cursor fell from 18% to 12% across the same stretch. Both tools lost ground, yet Cursorβs awareness climbed from 69% to 75%, so more developers knew the name while fewer reported using it on the job.
Stack Overflowβs 2026 survey, its 16th, gathered more than 30,000 responses from 169 countries and spent most of its energy on AI trust. I found no head-to-head Cursor vs Copilot figure in that coverage, so the usable adoption numbers for the two tools come from JetBrains. They arrive as published percentages with no raw respondent file. That shape of data fits a small DuckDB project better than a spreadsheet: a ledger of published figures, constraints that reject bad entries, and SQL views that compute conversion, wave-over-wave change and the size of Copilotβs lead.
Readers who want to crunch the Stack Overflow raw file instead can follow the pandas walkthrough of the Stack Overflow survey data. The build here handles the opposite case: aggregates only, several waves, provenance on every number. It takes 12 steps and about 70 minutes, comes to roughly 200 lines of Python, SQL and CSV, and ends with seven passing tests and a report you can rerun when the next wave lands.
Don't miss new tech stories on Google
Add Shattered once in the Google app and our stories show up in your news suggestions.
Cursor vs Copilot Adoption: What the Survey Numbers Measure #
Survey percentages are not market share. Market share would need revenue or seat counts for every vendor in the category, and no survey collects that. What a survey gives you is the share of its respondents who say they use a tool, and that share depends on who answered, how the question was worded and which tools sat on the answer list. JetBrains reported its Cursor and Copilot figures for professional developers who use a tool at work, which is a narrower population than everyone who ever tried an assistant.
The published numbers are still useful once you label them correctly. Here is every figure the project stores, with the wave it came from.
| Metric | GitHub Copilot | Cursor | Wave |
|---|---|---|---|
| Work use | 29% | 18% | JetBrains, January 2026 |
| Work use | 21% | 12% | JetBrains, May to July 2026 |
| Awareness | no confirmed figure | 69% | JetBrains, January 2026 |
| Awareness | 79% | 75% | JetBrains, May to July 2026 |
| Copilot users who also use it inside JetBrains IDEs | 39% | not applicable | JetBrains, May to July 2026 |
Two details in that table shape the whole design. The January 2026 Copilot awareness cell is empty on purpose, because I could not confirm a clean figure for it, and a data model has to survive a hole like that without inventing a number. The 39% row has a different denominator from every other row, since it describes Copilot users rather than all respondents. That row matters because it shows Copilot adoption is not the same thing as Visual Studio Code usage, given how many Copilot users work inside JetBrains editors.
JetBrains also publishes a much larger yearly study. Its State of Developer Ecosystem 2026 is the 10th edition and covers 28,945 developers in 198 countries and regions, and JetBrains had put out a public call for participants in its 2026 Developer Ecosystem Survey earlier in the year. That study and the AI-tool waves above are different instruments. The ledger records which one each number came from so the two never get averaged by accident. For context on how widespread AI tooling has become overall, Stack Overflowβs 2025 survey found 84% of respondents using or planning to use AI tools and 51% of professional developers using them daily, though positive sentiment slipped to 60% that year.
Vendor-side claims point in a different direction from survey share. A headline on Cursorβs own site says its recurring revenue doubled in three months to $2 billion. Revenue and workplace-use share measure different things, so a falling survey percentage and a rising revenue claim can both be true. Keeping those metrics in separate columns, with a source on each row, is what stops a tidy chart from implying more than the data supports.
The Cursor vs Copilot funnel itself is simple. Awareness is the share who know a tool exists. Work use is the share who use it on the job. Dividing the second by the first gives a conversion ratio, a quick read on how well a tool turns name recognition into daily use. Because the two figures may not share a denominator, treat that ratio as a comparison device between tools and waves, not as a measured conversion rate. Pitfall one below returns to this. A market share audit of your own seats is the right tool when you need numbers about your company rather than the industry.
Prerequisites With Versions #
The project needs very little. Everything runs locally, nothing calls an API, and no key or account is involved.
- Python 3.11 or newer. The run shown here used Python 3.12.3 on Linux.
- DuckDB 2.0 line, installed from PyPI. The run used DuckDB 2.0.1. Install it with pip inside a virtual environment.
- pytest , current release from PyPI, for the test suite in Step 10.
- A shell and a text editor. Any terminal on Linux, macOS or Windows with WSL works.
- Basic SQL. You should be comfortable reading SELECT, GROUP BY and a window function.
The version choice matters more than it looks. DuckDB 2.0 is the current long-term-support line, and according to the projectβs own release post it is supported until at least October 2027. Community support for the older 1.4 LTS line ended on November 17, 2026, and the project recommends moving to 2.0. The 2.0.1 patch shipped on November 20 with security and maintenance fixes. Its notes also say the Python client no longer needs the pytz package to fetch timestamp-with-time-zone values and that several hangs at exit were fixed, including on Python 3.14. DuckDBβs engineering blog carries a November post on bringing local analytics to the quantβs desktop, the same single-machine use case as this project. The team has also announced DuckDB 2.1.0 for the first half of 2027. It is not released yet, so nothing below depends on it.
You will not install pandas or numpy. DuckDBβs Python client returns plain tuples through fetchall(), and avoiding the dataframe path keeps the dependency list to two packages. Troubleshooting covers the one error you hit if you reach for fetchdf() anyway.
The data side has its own prerequisite. Before you type a number into the ledger, write down where you read it and what population it describes. The JetBrains figures here come from its August 2026 post on AI coding agent adoption, and every row in the sample file carries that source in a column. If you later add Stack Overflow figures, remember its data is licensed under ODbL 1.0 with contents under DbCL 1.0, so check the attribution terms before you republish a derived dataset.
Steps 1 and 2: Create the Project and the Wave Ledger #
The first two steps set up an isolated Python environment and the one data file the rest of the project reads. Keep the data in long format, one row per published fact, because that layout absorbs new tools, new metrics and new waves without changing a single line of SQL.
Step 1: Create the project folder and install DuckDB
Make a folder, create a virtual environment inside it and install the two packages. The version check at the end confirms which interpreter and DuckDB build you are about to trust.
mkdir funnel && cd funnel
python3 -m venv .venv
. .venv/bin/activate
pip install duckdb pytest
mkdir data sql
python -c "import duckdb, sys; print(sys.version.split()[0], duckdb.__version__)"
Expected output on the machine used for this run:
3.12.3 2.0.1
If you see a DuckDB version that starts with 1, pip resolved an older wheel, usually because the virtual environment inherited a stale cache or an old pin. Upgrade with pip install --upgrade duckdb and check again.
Step 2: Write the wave ledger
Create data/waves.csv. Each row records one percentage for one tool in one wave, plus the waveβs order, its label and its source. The file below holds every number from the table earlier and nothing else.
wave_id,wave_order,wave_label,tool,metric,value_pct,source
jb-2026-01,1,January 2026,copilot,use_at_work,29,JetBrains Research 2026-08-19
jb-2026-01,1,January 2026,cursor,use_at_work,18,JetBrains Research 2026-08-19
jb-2026-01,1,January 2026,cursor,aware,69,JetBrains Research 2026-08-19
jb-2026-05,2,May-July 2026,copilot,use_at_work,21,JetBrains Research 2026-08-19
jb-2026-05,2,May-July 2026,copilot,aware,79,JetBrains Research 2026-08-19
jb-2026-05,2,May-July 2026,copilot,surface_jetbrains_ide,39,JetBrains Research 2026-08-19
jb-2026-05,2,May-July 2026,cursor,use_at_work,12,JetBrains Research 2026-08-19
jb-2026-05,2,May-July 2026,cursor,aware,75,JetBrains Research 2026-08-19
A few choices are worth explaining. The wave_order column is an integer rather than a date because a survey wave spans months and the publication date differs from the field dates. Ordering by an integer you control avoids arguing about which date counts. The source column has no commas on purpose, since an unquoted comma would shift every column to its right. The January 2026 Copilot awareness row simply does not exist. Absence is honest, and Step 5 shows how SQL turns it into a visible NULL instead of a silent zero.
The surface_jetbrains_ide row is stored but never used in the funnel math. Keeping it in the ledger preserves a real published number, and the schema in Step 3 lists it as its own metric so nothing can confuse it with work use. The same discipline appears in a claim linter for Cursor and Copilot share statements, which grades prose claims by population and metric type before anyone quotes them.
Steps 3 and 4: Schema Guardrails and #
Spreadsheets accept anything you type. A database table can refuse the typo that would otherwise corrupt a chart a month from now. Spend ten minutes here and you will save an afternoon later.
Step 3: Define the schema with constraints
Create sql/schema.sql. The CHECK clauses encode three rules: only known tools, only known metrics, and every percentage between 0 and 100. The primary key makes it impossible to store two values for the same wave, tool and metric.
CREATE OR REPLACE TABLE waves (
wave_id VARCHAR NOT NULL,
wave_order INTEGER NOT NULL,
wave_label VARCHAR NOT NULL,
tool VARCHAR NOT NULL CHECK (tool IN ('copilot', 'cursor')),
metric VARCHAR NOT NULL CHECK (metric IN ('aware', 'use_at_work', 'surface_jetbrains_ide')),
value_pct DOUBLE NOT NULL CHECK (value_pct BETWEEN 0 AND 100),
source VARCHAR NOT NULL,
PRIMARY KEY (wave_id, tool, metric)
);
Adding a third tool later means editing one list in this file, which is deliberate friction. A new tool name should arrive through a reviewed change, not through a stray row. DuckDB enforces CHECK and PRIMARY KEY constraints at insert time, so a bad row fails loudly at load.
Step 4: Load the CSV with read_csv
Create db.py. Its build function creates the table, inserts the CSV and then runs every numbered SQL file in the sql folder in name order. The numbered files do not exist yet, so for now the loop does nothing. Steps 5 to 7 add them.
from pathlib import Path
ROOT = Path(__file__).parent
def build(con, csv_path=ROOT / "data" / "waves.csv"):
con.execute((ROOT / "sql" / "schema.sql").read_text())
con.execute(
"INSERT INTO waves SELECT * FROM read_csv(?, header = true)",
[str(csv_path)],
)
for path in sorted((ROOT / "sql").glob("[0-9]*.sql")):
con.execute(path.read_text())
The INSERT ... SELECT * FROM read_csv(...) pattern relies on the CSV columns appearing in the same order as the table columns, which is why the header in Step 2 matches the schema line for line. DuckDB sniffs types from the file and casts the integer percentages to DOUBLE on insert. Run a quick check from the project folder:
python - <<'EOF'
import duckdb
from db import build
con = duckdb.connect()
build(con)
print(con.execute("SELECT count(*) FROM waves").fetchone())
EOF
(8,)
Eight rows in, eight rows counted. To see the guardrails work, change one percentage to a value above the allowed range and rerun. The load stops with a constraint error, and nothing partial reaches the report:
_duckdb.ConstraintException: Constraint Error: CHECK constraint failed on table "waves" with expression CHECK((value_pct BETWEEN 0 AND 100))
Revert the value before you continue. An in-memory connection, duckdb.connect() with no path, rebuilds the whole database from the CSV on every run. That keeps the CSV as the single source of truth and means there is never a stale database file to doubt.
Steps 5 to 7: Funnel, Trend and Lead Views #
Three SQL views turn the ledger into answers. Each lives in its own numbered file, so db.py loads them in order and each view can build on the one before it. If you run your own seat numbers through a seat audit that prices each active developer, the same view-per-question layout keeps the queries readable.
Step 5: Compute the awareness-to-use funnel
Create sql/10_funnel.sql. It pivots the long ledger into one row per wave and tool, with awareness, work use, the conversion ratio and the gap between the two.
CREATE OR REPLACE VIEW funnel AS
SELECT
wave_id,
wave_order,
wave_label,
tool,
max(value_pct) FILTER (WHERE metric = 'aware') AS aware_pct,
max(value_pct) FILTER (WHERE metric = 'use_at_work') AS use_pct,
round(100 * max(value_pct) FILTER (WHERE metric = 'use_at_work')
/ nullif(max(value_pct) FILTER (WHERE metric = 'aware'), 0), 1) AS conversion_pct,
max(value_pct) FILTER (WHERE metric = 'aware')
- max(value_pct) FILTER (WHERE metric = 'use_at_work') AS gap_pts
FROM waves
GROUP BY wave_id, wave_order, wave_label, tool;
The FILTER (WHERE ...) clause lets one GROUP BY pick different metrics out of the same rows, which is DuckDBβs tidy alternative to a chain of CASE expressions. NULLIF(..., 0) guards the division against a zero awareness figure. When awareness is missing, max(...) FILTER returns NULL and every expression built on it returns NULL too, so the January Copilot conversion cell stays empty rather than showing a misleading number. Check the view:
python -c "
import duckdb
from db import build
con = duckdb.connect()
build(con)
print(con.sql('SELECT wave_id, tool, aware_pct, use_pct, conversion_pct, gap_pts FROM funnel ORDER BY wave_id, tool'))
"
ββββββββββββββ¬ββββββββββ¬ββββββββββββ¬ββββββββββ¬βββββββββββββββββ¬ββββββββββ
β wave_id β tool β aware_pct β use_pct β conversion_pct β gap_pts β
β varchar β varchar β double β double β double β double β
ββββββββββββββΌββββββββββΌββββββββββββΌββββββββββΌβββββββββββββββββΌββββββββββ€
β jb-2026-01 β copilot β NULL β 29.0 β NULL β NULL β
β jb-2026-01 β cursor β 69.0 β 18.0 β 26.1 β 51.0 β
β jb-2026-05 β copilot β 79.0 β 21.0 β 26.6 β 58.0 β
β jb-2026-05 β cursor β 75.0 β 12.0 β 16.0 β 63.0 β
ββββββββββββββ΄ββββββββββ΄ββββββββββββ΄ββββββββββ΄βββββββββββββββββ΄ββββββββββ
Read the rows once before moving on. Cursor had 69% awareness and 18% work use in January, then 75% awareness and 12% work use in May to July. Copilot shows 79% awareness and 21% work use in the later wave, and its January awareness cell is NULL, as designed. The gap_pts column shows how many percentage points sit between knowing a tool and using it at work.
Step 6: Add wave-over-wave trends with a window function
Create sql/20_trend.sql. A named window partitions by tool and orders by wave_order, and lag() pulls the previous waveβs value into the current row. The view reports both the change in percentage points and the relative change.
CREATE OR REPLACE VIEW trend AS
SELECT
*,
use_pct - lag(use_pct) OVER w AS use_delta_pts,
round(100 * (use_pct - lag(use_pct) OVER w) / lag(use_pct) OVER w, 1) AS use_delta_rel_pct,
aware_pct - lag(aware_pct) OVER w AS aware_delta_pts,
round(conversion_pct - lag(conversion_pct) OVER w, 1) AS conversion_delta_pts
FROM funnel
WINDOW w AS (PARTITION BY tool ORDER BY wave_order);
Percentage points and relative percent answer different questions. Copilot fell from 29% to 21%, and Cursor fell from 18% to 12%. Cursorβs relative drop from its own starting level is larger, while Copilotβs drop is larger in points. A reader who sees only the point change concludes Copilot fell harder. A reader who sees only the relative change concludes Cursor did. The view carries both so the report can show both.
βββββββββββ¬ββββββββββββββββ¬ββββββββββββββββββββ¬ββββββββββββββββββ¬βββββββββββββββββββββββ
β tool β use_delta_pts β use_delta_rel_pct β aware_delta_pts β conversion_delta_pts β
β varchar β double β double β double β double β
βββββββββββΌββββββββββββββββΌββββββββββββββββββββΌββββββββββββββββββΌβββββββββββββββββββββββ€
β copilot β NULL β NULL β NULL β NULL β
β copilot β -8.0 β -27.6 β NULL β NULL β
β cursor β NULL β NULL β NULL β NULL β
β cursor β -6.0 β -33.3 β 6.0 β -10.1 β
βββββββββββ΄ββββββββββββββββ΄ββββββββββββββββββββ΄ββββββββββββββββββ΄βββββββββββββββββββββββ
The first wave for each tool has NULL deltas because it has no predecessor. The report in Step 9 filters those rows out. The aware_delta_pts column is NULL for Copilot because January awareness is missing, and a missing number must not turn into a delta.
Step 7: Measure Copilotβs lead
Create sql/30_lead.sql. It collapses the two tools into one row per wave and computes two versions of the lead: the difference in points and the ratio.
CREATE OR REPLACE VIEW lead AS
SELECT
wave_id,
wave_order,
wave_label,
max(use_pct) FILTER (WHERE tool = 'copilot') AS copilot_use,
max(use_pct) FILTER (WHERE tool = 'cursor') AS cursor_use,
max(use_pct) FILTER (WHERE tool = 'copilot')
- max(use_pct) FILTER (WHERE tool = 'cursor') AS lead_pts,
round(max(use_pct) FILTER (WHERE tool = 'copilot')
/ nullif(max(use_pct) FILTER (WHERE tool = 'cursor'), 0), 2) AS copilot_to_cursor
FROM funnel
GROUP BY wave_id, wave_order, wave_label;
βββββββββββββββββ¬ββββββββββββββ¬βββββββββββββ¬βββββββββββ¬ββββββββββββββββββββ
β wave_label β copilot_use β cursor_use β lead_pts β copilot_to_cursor β
β varchar β double β double β double β double β
βββββββββββββββββΌββββββββββββββΌβββββββββββββΌβββββββββββΌββββββββββββββββββββ€
β January 2026 β 29.0 β 18.0 β 11.0 β 1.61 β
β May-July 2026 β 21.0 β 12.0 β 9.0 β 1.75 β
βββββββββββββββββ΄ββββββββββββββ΄βββββββββββββ΄βββββββββββ΄ββββββββββββββββββββ
Copilot led Cursor 29% to 18% in January and 21% to 12% in May to July. The lead narrowed in points, while the ratio between the two widened. Both statements are true, and they are not in tension. Cursorβs base was smaller, so an equal-sized drop in absolute terms would have meant a bigger relative loss. This is the main reason the lead view reports both numbers. A single headline figure picks a side before you have looked at the data, so the view reports both and lets the reader choose.
Steps 8 and 9: Guardrails, Report and Export #
Views produce numbers. A script decides whether those numbers are safe to print. The guard in Step 8 stops a half-filled wave from producing a lead calculation that quietly compares different things.
Step 8: Refuse to report incomplete waves
The check function in funnel.py verifies that every wave has a work-use row for both tools. If a wave is missing one, the script prints the problem to standard error and exits with status 1. Exit codes matter once you wire the script into a scheduled job or a pull request check, because a non-zero status is what turns a data mistake into a red build.
The rule is intentionally narrow. It does not demand awareness figures, since the real January data lacks one for Copilot. It demands work use because the lead view cannot mean anything without it. You can tighten the rule later, but start with the minimum that prevents a wrong comparison.
Step 9: Print the report and export CSVs
Create funnel.py. It builds the database, runs the guard, prints four sections (funnel, trend, lead and a text bar chart) and optionally exports each view as a CSV through DuckDBβs COPY statement.
#!/usr/bin/env python3
import argparse
import sys
from pathlib import Path
import duckdb
from db import build
ROOT = Path(__file__).parent
def check(con):
problems = []
waves = [r[0] for r in con.execute(
"SELECT DISTINCT wave_id FROM waves ORDER BY 1").fetchall()]
for wave in waves:
for tool in ("copilot", "cursor"):
n = con.execute(
"SELECT count(*) FROM waves WHERE wave_id = ? AND tool = ? "
"AND metric = 'use_at_work'", [wave, tool]).fetchone()[0]
if n == 0:
problems.append(f"{wave}: no use_at_work row for {tool}")
return problems
def bar(value, scale=2.0):
return "#" * int(round(value / scale)) if value is not None else "n/a"
def fmt(x, suffix=""):
if x is None:
return "n/a"
return f"{x:.1f}{suffix}" if suffix else f"{x:g}"
def report(con):
print("FUNNEL (percent of respondents, as published)")
print(f"{'wave':<15}{'tool':<9}{'aware':>7}{'use':>6}{'conv':>8}{'gap':>7}")
rows = con.execute(
"SELECT wave_label, tool, aware_pct, use_pct, conversion_pct, gap_pts "
"FROM funnel ORDER BY wave_order, tool").fetchall()
for label, tool, aware, use, conv, gap in rows:
print(f"{label:<15}{tool:<9}{fmt(aware):>7}{fmt(use):>6}"
f"{fmt(conv, '%'):>8}{fmt(gap):>7}")
print("\nTREND (change from the previous wave)")
print(f"{'wave':<15}{'tool':<9}{'use pts':>8}{'use rel%':>10}"
f"{'aware pts':>11}{'conv pts':>10}")
rows = con.execute(
"SELECT wave_label, tool, use_delta_pts, use_delta_rel_pct, "
"aware_delta_pts, conversion_delta_pts FROM trend "
"WHERE use_delta_pts IS NOT NULL ORDER BY wave_order, tool").fetchall()
for label, tool, d_use, d_rel, d_aw, d_conv in rows:
print(f"{label:<15}{tool:<9}{fmt(d_use):>8}{fmt(d_rel):>10}"
f"{fmt(d_aw):>11}{fmt(d_conv):>10}")
print("\nLEAD (Copilot over Cursor, work use)")
print(f"{'wave':<15}{'copilot':>9}{'cursor':>8}{'lead pts':>10}{'ratio':>8}")
for label, cp, cu, lead, ratio in con.execute(
"SELECT wave_label, copilot_use, cursor_use, lead_pts, copilot_to_cursor "
"FROM lead ORDER BY wave_order").fetchall():
print(f"{label:<15}{fmt(cp):>9}{fmt(cu):>8}{fmt(lead):>10}{fmt(ratio):>8}")
print("\nWORK USE BARS (1 # = 2 points)")
for label, tool, use in con.execute(
"SELECT wave_label, tool, use_pct FROM funnel "
"ORDER BY wave_order, tool").fetchall():
print(f"{label:<15}{tool:<9}{bar(use)}")
def export(con, out_dir):
out_dir.mkdir(exist_ok=True)
for name in ("funnel", "trend", "lead"):
target = out_dir / f"{name}.csv"
con.execute(f"COPY (SELECT * FROM {name}) TO '{target}' (HEADER, DELIMITER ',')")
print(f"wrote {target}")
def main(argv=None):
parser = argparse.ArgumentParser(description="Awareness-to-adoption funnel")
parser.add_argument("--csv", default=str(ROOT / "data" / "waves.csv"))
parser.add_argument("--export", action="store_true")
args = parser.parse_args(argv)
con = duckdb.connect()
build(con, args.csv)
problems = check(con)
if problems:
print("REFUSING TO REPORT:", *problems, sep="\n ", file=sys.stderr)
return 1
report(con)
if args.export:
export(con, ROOT / "out")
return 0
if __name__ == "__main__":
sys.exit(main())
Run it:
python funnel.py --export
FUNNEL (percent of respondents, as published)
wave tool aware use conv gap
January 2026 copilot n/a 29 n/a n/a
January 2026 cursor 69 18 26.1% 51
May-July 2026 copilot 79 21 26.6% 58
May-July 2026 cursor 75 12 16.0% 63
TREND (change from the previous wave)
wave tool use pts use rel% aware pts conv pts
May-July 2026 copilot -8 -27.6 n/a n/a
May-July 2026 cursor -6 -33.3 6 -10.1
LEAD (Copilot over Cursor, work use)
wave copilot cursor lead pts ratio
January 2026 29 18 11 1.61
May-July 2026 21 12 9 1.75
WORK USE BARS (1 # = 2 points)
January 2026 copilot ##############
January 2026 cursor #########
May-July 2026 copilot ##########
May-July 2026 cursor ######
The export flag also writes three files:
wrote ./out/funnel.csv
wrote ./out/trend.csv
wrote ./out/lead.csv
The bar chart is deliberately crude. Each hash mark is two percentage points, so a reviewer can see in one glance that all four bars shrank or stayed comparable in the second wave without opening a plotting library. The fmt helper prints n/a for NULL, which keeps the missing January awareness visible in every section instead of letting it disappear behind a zero. Because the script uses only the standard library plus DuckDB, you can run it on a locked-down CI runner with nothing else installed.
Steps 10 and 11: Tests and Reading the Output #
A report you cannot test is a report you will eventually stop trusting. Seven short tests pin down the behaviors that matter most: the conversion math, NULL handling, the per-tool window, the two constraint failures, the completeness guard and the lead ratio.
Step 10: Write the tests
Create test_funnel.py. Each test builds a small CSV in a temporary folder, loads it through the same db.build the real script uses and asserts on the result. Test data uses invented round numbers so nobody mistakes it for survey data.
import duckdb
import pytest
import db
import funnel
HEADER = "wave_id,wave_order,wave_label,tool,metric,value_pct,source\n"
def make(tmp_path, rows):
path = tmp_path / "waves.csv"
path.write_text(HEADER + "\n".join(rows) + "\n")
con = duckdb.connect()
db.build(con, path)
return con
GOOD = [
"w1,1,One,copilot,use_at_work,30,t",
"w1,1,One,copilot,aware,80,t",
"w1,1,One,cursor,use_at_work,15,t",
"w1,1,One,cursor,aware,60,t",
]
def test_conversion_is_use_over_aware(tmp_path):
con = make(tmp_path, GOOD)
got = dict(con.execute("SELECT tool, conversion_pct FROM funnel").fetchall())
assert got == {"copilot": 37.5, "cursor": 25.0}
def test_missing_awareness_gives_null_not_zero(tmp_path):
con = make(tmp_path, [r for r in GOOD if "copilot,aware" not in r])
row = con.execute(
"SELECT conversion_pct FROM funnel WHERE tool = 'copilot'").fetchone()
assert row == (None,)
def test_trend_uses_previous_wave_per_tool(tmp_path):
rows = GOOD + [
"w2,2,Two,copilot,use_at_work,24,t",
"w2,2,Two,cursor,use_at_work,15,t",
]
con = make(tmp_path, rows)
got = dict(con.execute(
"SELECT tool, use_delta_pts FROM trend WHERE wave_id = 'w2'").fetchall())
assert got == {"copilot": -6, "cursor": 0}
def test_percentage_over_100_is_rejected(tmp_path):
with pytest.raises(duckdb.ConstraintException):
make(tmp_path, GOOD + ["w1,1,One,cursor,aware,140,t"])
def test_unknown_metric_is_rejected(tmp_path):
with pytest.raises(duckdb.ConstraintException):
make(tmp_path, GOOD + ["w1,1,One,cursor,satisfaction,50,t"])
def test_check_flags_wave_missing_a_tool(tmp_path):
con = make(tmp_path, [r for r in GOOD if "cursor,use_at_work" not in r])
assert funnel.check(con) == ["w1: no use_at_work row for cursor"]
def test_lead_ratio(tmp_path):
con = make(tmp_path, GOOD)
assert con.execute("SELECT copilot_to_cursor FROM lead").fetchone() == (2.0,)
python -m pytest -v
test_funnel.py::test_conversion_is_use_over_aware PASSED
test_funnel.py::test_missing_awareness_gives_null_not_zero PASSED
test_funnel.py::test_trend_uses_previous_wave_per_tool PASSED
test_funnel.py::test_percentage_over_100_is_rejected PASSED
test_funnel.py::test_unknown_metric_is_rejected PASSED
test_funnel.py::test_check_flags_wave_missing_a_tool PASSED
test_funnel.py::test_lead_ratio PASSED
============================== 7 passed in 0.34s ===============================
The most valuable test is test_missing_awareness_gives_null_not_zero. It encodes the decision from Step 2 as an executable rule, so a future refactor that swaps NULL for 0 fails immediately.
Step 11: Read the output without overclaiming
Now that the pipeline works, decide what you are allowed to say. The derived numbers, all computed from the published figures above, are these.
| Derived metric | GitHub Copilot | Cursor |
|---|---|---|
| Work use change, January to May-July 2026 | 29% to 21% | 18% to 12% |
| Awareness change over the same period | not computable | +6 points |
| Conversion, January 2026 | not computable | Not listed |
| Conversion, May to July 2026 | 26.6% | 16.0% |
| Lead in work use, January to May-July | Ahead: 29% to 21% | Behind: 18% to 12% |
Safe statements follow directly. Copilot led Cursor in both waves. Both tools reported lower work use in the later wave. Cursorβs awareness rose while its work use fell, so its conversion ratio dropped by 10.1 points. Unsafe statements follow just as directly. You cannot say Cursor is losing developers, because a survey wave is a snapshot, not a flow. You cannot say Copilot is winning, because the lead is a difference between two noisy percentages. And you cannot explain the decline, since the data contains no cause.
Several explanations compete and the ledger cannot rank them. The question wording or answer list may have changed between waves. JetBrainsβ own analysis covers GitHub Copilot, Cursor, Claude Code, JetBrains AI Assistant, Junie, OpenAI Codex and Google Antigravity, and a respondent who splits time across tools may report a different mix in a different wave. The respondent pool may also have shifted. A Wilson interval margin-of-error tutorial shows how to put a width on differences like these once sample sizes are published. The JetBrains posts used here did not give me per-wave sample sizes, so the ledger has no sample-size column and the report claims no intervals.
Step 12: Add the Next Wave in Five Minutes #
The project earns its keep the day a new figure appears. Whether it comes from JetBrains, from Stack Overflowβs next coverage or from a vendor-neutral study, the routine stays the same, and it never touches SQL.
Step 12: Append rows, rerun, review the diff
Open data/waves.csv and append one row per published number, using the next integer for wave_order. Use a new wave_id that names the survey and period. The template below uses capitalized placeholders on purpose, so a forgotten substitution fails the load instead of passing quietly.
NEXT_WAVE_ID,3,NEXT_LABEL,copilot,use_at_work,NN,SOURCE
NEXT_WAVE_ID,3,NEXT_LABEL,cursor,use_at_work,NN,SOURCE
NEXT_WAVE_ID,3,NEXT_LABEL,copilot,aware,NN,SOURCE
NEXT_WAVE_ID,3,NEXT_LABEL,cursor,aware,NN,SOURCE
Replace the placeholders with the published figures, run python funnel.py and read the new trend rows. The window function now compares wave 3 against wave 2 with no code change. If the new source omits a figure, leave that row out. The guard accepts a missing awareness row but stops a wave without work use for either tool.
Treat the CSV like source code. Commit it, and let the diff show exactly which numbers changed and from which source. Reviewers should check each new row against the original page, not against your summary of it. When a source later revises a figure, change the existing row in place, keep the old value in the commit message and rerun the tests.
Watch for new instruments as well. JetBrainsβ State of Developer Ecosystem 2026 and Stack Overflowβs 2026 survey are the two largest recent datasets, and either may publish tool-level breakdowns. When one does, add it as its own wave_id with a source that names the instrument. Never overwrite a JetBrains wave with a Stack Overflow figure, and never merge them into one column, because their respondent pools, sample sizes and question wording differ.
Why the Waves Move: Copilot and Cursor Release Events #
Survey waves last months, while the products they measure change every few weeks. That mismatch explains part of why one wave looks different from the next, and it is worth recording alongside the percentages. The table lists dated events from the vendorsβ own pages and release notes that fall in or near the period the two JetBrains waves cover.
| Date | Tool | Event |
|---|---|---|
| Not listed | Cursor | Composer 2 released, priced at $0.50 per million input tokens and $2.50 per million output tokens |
| 2026-07-28 | Cursor | Cursor Start plan launched in India at βΉ649 a month |
| 2026-10-28 | Copilot | Connected Copilot cloud experience announced across Web, Mobile, App, CLI, VS Code, Slack and Microsoft Teams |
| 2026-11-03 | Cursor | Claude Sonnet 5.5 added to the Cursor model catalog |
| 2026-11-16 | Copilot | GitHub deprecated several models across most Copilot experiences |
| 2026-11-17 | Copilot | GPT-6.2 Astra and GPT-6.2 Sol became generally available, and MAI Code 2 became available |
| 2026-11-18 | Copilot | Gemini 4 Neon became generally available for Pro+, Max, Business and Enterprise |
| 2026-11-23 | Copilot | Billing for cloud sandbox usage begins |
Cursorβs plan lineup in the sources I checked is Free, Pro and Cursor Start, and its model list spans several providers. Copilotβs pricing now runs on AI credits, where one credit equals $0.01, and GitHubβs plans page lists Copilot Enterprise at $39 per user per month. The same page shows monthly credit allowances of $15 for Pro, $70 for Pro+ and $200 for Max. GitHubβs November 2026 changelog tracks the model launches and retirements in the table. Each of those changes alters what a developer gets for a given seat, which can move survey answers in either direction without any change in loyalty.
The release cadence is the main reason a single wave should never stand alone. A stretch where Copilot and Cursor shipped seven models in 11 days would fit entirely inside one survey window. For price comparisons on the same products, the pricing breakdown for Claude Code, Cursor and Copilot sets the plans side by side.
One more point on dates. The last row of the table, November 23, 2026, is announced but not yet in effect as of November 21. Mark future-dated events the same way in your own notes, so nobody reads a planned change as a completed one.
Common Pitfalls #
Eight mistakes account for most wrong conclusions drawn from Cursor vs Copilot adoption data. Each one has bitten real dashboards.
- Treating the conversion ratio as a measured rate. Dividing work use by awareness assumes both come from the same respondents. If awareness covers everyone surveyed and work use covers only professionals, the ratio mixes populations. Use it to compare tools and waves under the same convention, never to claim that 16.0% of aware developers adopted Cursor.
- Merging surveys. JetBrains and Stack Overflow ask different people different questions. Keep each in its own wave id and never average across them.
- Mixing denominators. The 39% Copilot-in-JetBrains-IDEs figure counts Copilot users, not respondents. The metric allow-list in the schema keeps it out of the funnel math. Resist the urge to add it to a bar chart next to work use.
- Filling gaps with guesses. A missing January awareness figure is information. Estimating it from the other wave turns a gap into a fiction that later readers will quote as fact.
- Mixing points and percent. A drop from 29% to 21% can be described in points or in relative percent. Label every delta with its unit, or a reader will compare a point change with a relative change and conclude nonsense.
- Sorting by publication date. A wave published in August may describe fieldwork that ended in July. Order by the field period you recorded in
wave_order. - Reading tool names as stable products. Plans, models and bundles change, and developers often run both editors side by side. If you are comparing configurations while switching, the guide tomigrating Cursor rules from Copilot explains how teams keep both tools working during a move.
- Assuming the percentages sum to 100. Respondents can use several tools, so work-use shares across tools overlap. A tool at 21% and another at 12% do not leave 67% for everyone else.
A ninth habit helps more than any rule: write the caveat next to the number, not in a footnote. A table cell that reads 21% with its wave label attached travels better than a footnote that gets cropped out of a screenshot.
Troubleshooting #
Nine problems cover nearly every failure seen while building and testing this project. The error text below is copied from real runs.
- No module named duckdb. The message is
ModuleNotFoundError: No module named 'duckdb'. The virtual environment is not active. Run. .venv/bin/activateand retry. - File not found on load. DuckDB reports
IO Error: No files found that match the patternfollowed by the path. Run the script from the project root, or pass an absolute path with--csv. - Percent sign in a value. A cell such as 40% raises
Conversion Error: CSV Error on Line: 2withCould not convert string "40%" to 'DOUBLE'. Store plain numbers. The column name already says percent. - Value outside 0 to 100. You get
CHECK constraint failed on table "waves" with expression CHECK((value_pct BETWEEN 0 AND 100)). Fix the typo, and check whether you entered a fraction where the file expects a whole percentage such as 21. - Unknown tool name. The failure reads
CHECK constraint failed on table "waves" with expression CHECK((tool IN ('copilot', 'cursor'))). Either correct the spelling or, for a genuinely new tool, add it to the list insql/schema.sql. - Duplicate key.
PRIMARY KEY or UNIQUE constraint violation: duplicate key "w1, cursor, aware"means two rows share a wave, tool and metric. Keep the row with the correct source and delete the other. - REFUSING TO REPORT. The guard lists each wave and tool missing a work-use row, for example
w1: no use_at_work row for cursor. Add the row, or remove the incomplete wave until you have the figure. - Conversion shows n/a. That is the design working. The wave has no awareness row for that tool. Add one only if a source publishes it.
- No module named numpy. Calling
fetchdf()or.df()needs numpy and pandas. Usefetchall()as the scripts here do, or install pandas deliberately.
If tests pass but the report looks wrong, print the raw ledger with SELECT * FROM waves ORDER BY wave_order, tool, metric and compare it against the source pages one row at a time. Almost every wrong report traces back to a typo or a mislabeled wave rather than to the SQL.
Advanced Tips #
Once the base project runs cleanly, five extensions add real analytical value without bloating the code.
Join events to waves with an ASOF join
DuckDBβs ASOF join matches each event to the nearest wave window by date, which suits the release-event problem from earlier. The file below assigns each event to the first wave whose window ends on or after the event, and leaves the wave empty for events that came after the last window. The wave end dates are a convention I chose, the last day of each waveβs final field month, so adjust them if your source publishes exact fieldwork dates.
CREATE OR REPLACE TABLE wave_windows (wave_id VARCHAR, wave_end DATE);
INSERT INTO wave_windows VALUES
('jb-2026-01', DATE '2026-01-31'),
('jb-2026-05', DATE '2026-07-31');
CREATE OR REPLACE TABLE events (event_date DATE, tool VARCHAR, event VARCHAR);
INSERT INTO events VALUES
(DATE '2026-03-19', 'cursor', 'Composer 2 released'),
(DATE '2026-07-28', 'cursor', 'Cursor Start launched in India'),
(DATE '2026-10-28', 'copilot', 'Connected Copilot cloud experience announced'),
(DATE '2026-11-03', 'cursor', 'Claude Sonnet 5.5 added'),
(DATE '2026-11-17', 'copilot', 'GPT-6.2 Astra and Sol generally available'),
(DATE '2026-11-18', 'copilot', 'Gemini 4 Neon generally available');
SELECT e.event_date, e.tool, e.event, w.wave_id
FROM events e
ASOF LEFT JOIN wave_windows w ON e.event_date <= w.wave_end
ORDER BY e.event_date;
Run it through a short Python loop that executes each statement and prints the final one. The output:
event_date tool event wave_id
2026-03-19 cursor Composer 2 released jb-2026-05
2026-07-28 cursor Cursor Start launched in India jb-2026-05
2026-10-28 copilot Connected Copilot cloud experience announced None
2026-11-03 cursor Claude Sonnet 5.5 added None
2026-11-17 copilot GPT-6.2 Astra and Sol generally available None
2026-11-18 copilot Gemini 4 Neon generally available None
The two events in the May to July window attach to that wave. Everything from October on carries no wave, which tells you precisely which launches the next survey will be the first to capture. A benchmark of both tools on your own repository is the natural companion when the question shifts from what developers report to what each assistant does on your code.
Add more tools
JetBrainsβ analysis names GitHub Copilot, Cursor, Claude Code, JetBrains AI Assistant, Junie, OpenAI Codex and Google Antigravity. To follow another tool, add its name to the CHECK list in the schema, add rows to the ledger, and generalize the lead view to compare any two tools. Resist adding a tool until a source publishes a figure for it.
Query a raw survey file the same way
If a survey ships a raw CSV with a multi-select column of semicolon-separated tool names, DuckDB can split and count it directly. Replace the file and column names with the real ones from the surveyβs schema file.
SELECT trim(tool) AS tool, count(*) AS respondents
FROM (
SELECT unnest(string_split(your_tool_column, ';')) AS tool
FROM read_csv('survey.csv')
)
GROUP BY 1
ORDER BY respondents DESC;
Check the schema first, because a tool you expect may not appear as an answer option, and a count of zero then means the question never offered it. Also divide by the number of respondents who answered the question, not by the whole file.
Store sample sizes when they exist
Add an optional n column the day a source publishes a per-wave sample size. With it you can compute intervals in SQL and let the report print a range instead of a bare percentage. Leave the column NULL for waves without one, and never back-fill it.
Run it on a schedule
A scheduled job can fetch the CSV from your repository, run python funnel.py --export and fail on exit status 1. Pair it with the seven tests, so a data edit that breaks a rule turns the build red before a reader sees it.
The Complete Project #
The final layout is small enough to hold in your head, and every file in it was written in the steps above.
funnel/
data/waves.csv 8 rows, 7 columns
sql/schema.sql table, CHECK constraints, primary key
sql/10_funnel.sql awareness, work use, conversion, gap
sql/20_trend.sql lag() deltas per tool
sql/30_lead.sql Copilot lead in points and ratio
sql/events.sql optional ASOF join of launches to waves
db.py build(): schema, load, numbered views
funnel.py guard, report, CSV export
test_funnel.py 7 pytest tests
Two commands run everything from the project root, with the virtual environment active:
python funnel.py --export
python -m pytest -q
....... [100%]
7 passed in 0.36s
The whole Cursor vs Copilot tracker weighs about 250 lines including the CSV and the optional events file. It runs in well under a second, needs no network and rebuilds the database from the CSV on every run, so the data file is the only thing you ever back up. For more tooling beyond this one comparison, the Coding and Dev Tools section collects the rest of the assistant and IDE coverage.
FAQ #
Is GitHub Copilot or Cursor more widely used, according to the surveys?
In the JetBrains waves used here, GitHub Copilot was used at work by 21% of surveyed professional developers in May to July 2026, down from 29% a year earlier, while Cursor was at 12%, down from 18% in January 2026. Copilot stayed ahead of Cursor despite its decline. That is a survey of developers, not a market share measurement, and it reflects JetBrainsβ respondents.
Why did both tools lose work-use share between waves?
The data does not say. Possible factors include changes in question wording, a different respondent mix and developers spreading time across more tools, but the ledger cannot confirm any of them. Treat the drop as a prompt for questions rather than a finding.
Did Stack Overflowβs 2026 survey publish a Cursor vs Copilot number?
I found no directly comparable figure in the coverage I could check. The 2026 survey, its 16th edition, reported on more than 30,000 responses from 169 countries and emphasized AI trust, including that only 6.6% were prepared to trust AI for important decisions.
Why use DuckDB instead of a spreadsheet or pandas?
DuckDB enforces constraints at load, handles pivots and window functions in plain SQL and runs in-process with no server. The result is a small, testable project whose only dependencies are DuckDB and pytest.
Which DuckDB version should I install?
Use the 2.0 line. It is the current long-term-support release, supported until at least October 2027, and the tests here ran on 2.0.1. Community support for the 1.4 LTS line ended on November 17, 2026.
Is the conversion ratio a real adoption rate?
No. It divides two published percentages that may not share a denominator, so it is a consistent comparison device, not a measured rate. Use it to compare tools and waves, and say so wherever you show it.
How often should I update the ledger?
Whenever a source publishes a new wave. Append rows, run the report and read the diff. Updating on a calendar without new data only adds noise.
Can the same project track Claude Code or other tools?
Yes. Add the tool name to the schemaβs CHECK list, add its published rows to the ledger and extend the lead view if you want a head-to-head. Only add a tool once a source publishes a figure for it.