A desktop monitor displays a database workflow, SQL code, spreadsheet, and analytics chart in a modern office.
JetBrains says GitHub Copilot's work use fell from 29% in January 2026 to 21% in May to July 2026. The same report has Cursor falling from 18% to 12%. Those are published percentages, with no raw respondent file behind them, so a spreadsheet is a poor fit. A small DuckDB project works better. It keeps a ledger of published figures, rejects bad entries with constraints, and uses SQL views to compute funnel ratios, wave-over-wave change and Copilot's lead. A Shattered tutorial builds exactly that in 12 steps. Its author puts the effort at about 70 minutes and roughly 200 to 250 lines of Python, SQL and CSV. This piece walks through the build and checks the numbers against primary and secondary sources.

A desktop monitor displays a database workflow, SQL code, spreadsheet, and analytics chart in a modern office. What the numbers measure, and what they don't​

These figures are survey results, not market share. JetBrains's own methodology note says its "professional developers" are respondents in coding-related job roles. The survey ran from May to July 2026 and drew more than 15,000 professional developers worldwide.

The figures the tutorial stores:

MetricCopilotCursorWave
Work use29%18%January 2026
Work use21%12%May to July 2026
Awarenessnot stored69%January 2026
Awareness79%75%May to July 2026
Copilot users also using it in JetBrains IDEs39%n/aMay to July 2026

The 39% row has a different denominator from the rest, because it counts Copilot users rather than all respondents. JetBrains says 39% of Copilot users run it, among other surfaces, in JetBrains IDEs. That row should never sit beside work-use percentages in a chart.

A gap worth flagging​

The tutorial leaves January Copilot awareness blank because its author couldn't confirm a figure. Secondary coverage of JetBrains's January AI Pulse survey does cite one. Second Talent reports 76% of developers had heard of Copilot, 69% of Cursor, 57% of Claude Code and 27% of Codex. I only saw this in secondary coverage, not in the JetBrains post the tutorial uses. If you can verify it at the JetBrains source, add it as a row. Until then, leaving the cell empty is the honest choice, and the tutorial's design handles that well.

What the ledger leaves out​

The ledger tracks only two tools. The same JetBrains report says 90% of professional developers use AI coding agents at work at least weekly, and 68% use them daily. It also reports that Claude Code is used at work by roughly 39% of professional developers, up from 18% in January. That is about twice Copilot's figure. A Copilot-versus-Cursor ledger is a valid narrow exercise, but it is not the whole market. The tutorial's advice to add a tool only once a source publishes a figure for it is sound.

The 12 steps, condensed​

Steps 1 and 2: project and ledger.

  • You need Python 3.11 or newer, DuckDB and pytest. The author ran Python 3.12.3 and DuckDB 2.0.1.
  • Data goes in a long-format CSV with the columns wave_id, wave_order, wave_label, tool, metric, value_pct, source.
  • Each row is one published fact. The tutorial's ledger has eight rows.
  • wave_order is an integer you control, so publication dates and fieldwork dates don't get confused.

Steps 3 and 4: schema and load.

  • A waves table uses CHECK constraints to allow only known tools (copilot, cursor) and known metrics (aware, use_at_work, surface_jetbrains_ide).
  • A third CHECK keeps value_pct between 0 and 100.
  • A composite primary key on wave, tool and metric blocks duplicates.
  • DuckDB's documentation covers CHECK, NOT NULL and composite primary keys, so the guardrails rest on documented features.
  • db.py creates the table, loads the CSV with read_csv, then runs numbered SQL files in name order.
  • The author recommends an in-memory connection, so the CSV is the only source of truth.

Steps 5 to 7: three views.

  • funnel uses max(...) FILTER (WHERE metric = ...) to pivot the long ledger. It computes use ÷ aware as a conversion ratio, guarded by nullif, plus a gap in points.
  • trend uses lag() over a window partitioned by tool and ordered by wave. It reports both point change and relative change.
  • lead collapses the tools into one row per wave and reports Copilot's lead in points and as a ratio.
  • A missing awareness value stays NULL all the way through, never a silent zero.

Steps 8 and 9: guard and report.

  • A check() function requires a work-use row for both tools in every wave. It exits with status 1 otherwise, which turns a data mistake into a red CI build.
  • It deliberately does not require awareness.
  • The script prints funnel, trend, lead and crude text bars, and can export each view with COPY.

Steps 10 and 11: tests and interpretation.

  • Seven pytest tests cover conversion math, NULL handling, per-tool windows, rejection of out-of-range values and unknown metrics, the completeness guard, and the lead ratio.
  • Test data uses invented round numbers, so nobody mistakes it for survey data.

Step 12: add a wave. Append rows with the next wave_order and rerun. The window function compares the new wave with the previous one, with no SQL changes.

What the arithmetic shows​

These results are arithmetic on the published percentages, not independent survey findings:

  • Copilot fell 8 points (about 27.6% relative). Cursor fell 6 points (about 33.3% relative).
  • Copilot's lead narrowed from 11 points to 9 points. The ratio of the two work-use figures rose from about 1.61 to 1.75.
  • Cursor's use-to-awareness quotient fell from about 26.1% to 16.0%. Copilot's later quotient is about 26.6%.

The point-versus-relative contrast is the best lesson here. Copilot lost more points, Cursor lost more of its own base, and both statements are true. Showing only one picks a side before the reader sees the data.

Caveats​

  • The quotient is not a conversion rate. The two inputs may not share a denominator. Use it to compare tools and waves, not to say 16% of aware developers adopted Cursor.
  • The waves are not a panel. January comes from a different JetBrains instrument. Secondary coverage describes it as the AI Pulse survey of more than 10,000 professionals, against more than 15,000 for the later Developer Ecosystem Survey. The tutorial treats them as consecutive waves, and so does JetBrains's report. They are still not the same respondents followed over time.
  • No intervals. The tutorial found no per-wave sample sizes for the tool figures, so it claims no significance. That restraint is correct. One third-party aggregator cites a 15,509 respondent count for the later wave, but I couldn't tie it to JetBrains's own post. Treat it as unverified.
  • Overlapping shares. Developers use several tools, so shares don't sum to 100. Per-tool adoption rates describe overlapping populations.
  • Cause is unknown. The tutorial lists plausible factors: question wording, respondent mix and developers splitting time across tools. The data can't rank them. JetBrains's report also notes Cursor's steepest decline in China, from 28% to 16%, which a global ledger would hide.

Stack Overflow: the tutorial's claim is too strong​

The tutorial says it found no head-to-head Cursor-versus-Copilot figure in Stack Overflow's 2026 coverage. Stack Overflow's own announcement post does not give one in its highlights. It does say Claude Code (66%) and GitHub Copilot (59%) are the agents of choice among AI users. A secondary aggregator, Command Linux, reports 58.7% past-year use for Copilot and 25.5% for Cursor (n = 12,255). I haven't verified that against Stack Overflow's survey pages. If it holds up, it shows why instruments must stay separate. Past-year use among Stack Overflow respondents and work use among JetBrains professionals are different metrics. Averaging them would be wrong. The tutorial's rule to give each instrument its own wave_id and never merge them in one column applies directly.

DuckDB version notes​

The tutorial recommends the 2.0 line. DuckDB's release calendar backs the key dates. Version 2.0.0 LTS shipped October 21, 2026 with an end-of-life date of October 22, 2027. The same calendar says support for DuckDB 1.4 was extended until November 17, 2026. That date has now passed. The calendar also lists 2.1.0 as planned for the first half of 2027. If python -c "import duckdb; print(duckdb.__version__)" prints a version starting with 1, upgrade before trusting the SQL.

Practical troubleshooting from the tutorial:

  • No module named duckdb: the virtual environment isn't active.
  • Percent sign in a CSV cell: store plain numbers such as 21, not 21%.
  • Constraint error on load: check for a fraction where a whole percentage belongs, or a misspelled tool name.
  • Duplicate key: two rows share a wave, tool and metric, so keep the one with the right source.
  • fetchdf() fails: it needs pandas and numpy, so use fetchall() instead.
  • REFUSING TO REPORT: a wave lacks a work-use row for one tool.

Bottom line​

The code is modest. Its value is the discipline: provenance on every row, NULL instead of invented numbers, and a guard that refuses to compare incomplete waves. The author's 70-minute and sub-second run claims are from their own run, and I haven't reproduced them.

The release-event table, with its vendor pricing and model dates, wasn't corroborated here, so I've left it out. Use the project to hold survey figures you've checked against the source, and keep the caveats beside the numbers.

 

References

  1. Cursor vs Copilot Funnel in DuckDB: 12 Steps, 70 Min shattered.io 2026-11-21T01:43:06+00:00
  2. Release Calendar – DuckDB duckdb.org
  3. Claude Code Overtakes GitHub Copilot: What JetBrains' Survey of 15,000 Developers Says About AI Coding Agents in 2026 - DEV Community dev.to