{"slug": "cursor-vs-copilot-funnel-in-duckdb-12-steps-70-min", "title": "Cursor vs Copilot Funnel in DuckDB: 12 Steps, 70 Min", "summary": "JetBrains' May-to-July 2026 survey wave found GitHub Copilot work use among professional developers fell to 21% from 29% in January 2026, while Cursor dropped to 12% from 18%, even as Cursor awareness rose to 75% from 69%. The figures, published as percentages without a raw respondent file, anchor a 12-step, roughly 70-minute DuckDB tutorial that builds a provenance-tagged ledger of survey numbers with seven passing tests and SQL views for conversion and wave-over-wave change. The project treats survey percentages as respondent shares rather than market share, and flags that Copilot's 39% figure for use inside JetBrains IDEs has a different denominator from the other rows.", "body_md": "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.\n\nStack Overflow’s 2026 survey, its 16th, gathered [more than 30,000 responses from 169 countries](https://stackoverflow.co/company/press/archive/stack-overflow-annual-developer-survey-ai-trust-conditional) 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.\n\nReaders who want to crunch the Stack Overflow raw file instead can follow the [pandas walkthrough of the Stack Overflow survey data](https://shattered.io/cursor-vs-copilot-stack-overflow-survey-pandas-12-steps-2026/). 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.\n\nDon't miss new tech stories on Google\n\nAdd Shattered once in the Google app and our stories show up in your news suggestions.\n\n[Add now](https://www.google.com/preferences/source?hl=en&q=https%3A%2F%2Fshattered.io%2F)\n\n## Cursor vs Copilot Adoption: What the Survey Numbers Measure\n\nSurvey 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.\n\nThe published numbers are still useful once you label them correctly. Here is every figure the project stores, with the wave it came from.\n\n| Metric | GitHub Copilot | Cursor | Wave | \n|---|---|---|---|\n| Work use | 29% | 18% | JetBrains, January 2026 | \n| Work use | 21% | 12% | JetBrains, May to July 2026 | \n| Awareness | no confirmed figure | 69% | JetBrains, January 2026 | \n| Awareness | 79% | 75% | JetBrains, May to July 2026 | \n| Copilot users who also use it inside JetBrains IDEs | 39% | not applicable | JetBrains, May to July 2026 | \n\nTwo 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.\n\nJetBrains 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](https://blog.jetbrains.com/research/2026/05/developer-ecosystem-survey-2026-take-part-in-one-of-the-largest-developer-studies/) 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.\n\nVendor-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.\n\nThe 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](https://shattered.io/cursor-vs-github-copilot-market-share-audit-12-steps-2026/) is the right tool when you need numbers about your company rather than the industry.\n\n## Prerequisites With Versions\n\nThe project needs very little. Everything runs locally, nothing calls an API, and no key or account is involved.\n\n- **Python 3.11 or newer.** The run shown here used Python 3.12.3 on Linux.\n- **DuckDB 2.0 line, installed from PyPI.** The run used DuckDB 2.0.1. Install it with pip inside a virtual environment.\n- **pytest** , current release from PyPI, for the test suite in Step 10.\n- **A shell and a text editor.** Any terminal on Linux, macOS or Windows with WSL works.\n- **Basic SQL.** You should be comfortable reading SELECT, GROUP BY and a window function.\n\nThe 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](https://www.duckdb.org/2026/11/03/bringing-local-analytics-to-the-quants-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.\n\nYou 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.\n\nThe 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.\n\n## Steps 1 and 2: Create the Project and the Wave Ledger\n\nThe 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.\n\n### Step 1: Create the project folder and install DuckDB\n\nMake 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.\n\n```\nmkdir funnel && cd funnel\npython3 -m venv .venv\n. .venv/bin/activate\npip install duckdb pytest\nmkdir data sql\npython -c \"import duckdb, sys; print(sys.version.split()[0], duckdb.__version__)\"\n```\n\nExpected output on the machine used for this run:\n\n```\n3.12.3 2.0.1\n```\n\nIf 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.\n\n### Step 2: Write the wave ledger\n\nCreate `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.\n\n```\nwave_id,wave_order,wave_label,tool,metric,value_pct,source\njb-2026-01,1,January 2026,copilot,use_at_work,29,JetBrains Research 2026-08-19\njb-2026-01,1,January 2026,cursor,use_at_work,18,JetBrains Research 2026-08-19\njb-2026-01,1,January 2026,cursor,aware,69,JetBrains Research 2026-08-19\njb-2026-05,2,May-July 2026,copilot,use_at_work,21,JetBrains Research 2026-08-19\njb-2026-05,2,May-July 2026,copilot,aware,79,JetBrains Research 2026-08-19\njb-2026-05,2,May-July 2026,copilot,surface_jetbrains_ide,39,JetBrains Research 2026-08-19\njb-2026-05,2,May-July 2026,cursor,use_at_work,12,JetBrains Research 2026-08-19\njb-2026-05,2,May-July 2026,cursor,aware,75,JetBrains Research 2026-08-19\n```\n\nA 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.\n\nThe `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](https://shattered.io/cursor-vs-copilot-share-claim-linter-python-12-steps-2026/), which grades prose claims by population and metric type before anyone quotes them.\n\n## Steps 3 and 4: Schema Guardrails and Loading\n\nSpreadsheets 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.\n\n### Step 3: Define the schema with constraints\n\nCreate `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.\n\n```\nCREATE OR REPLACE TABLE waves (\n    wave_id     VARCHAR NOT NULL,\n    wave_order  INTEGER NOT NULL,\n    wave_label  VARCHAR NOT NULL,\n    tool        VARCHAR NOT NULL CHECK (tool IN ('copilot', 'cursor')),\n    metric      VARCHAR NOT NULL CHECK (metric IN ('aware', 'use_at_work', 'surface_jetbrains_ide')),\n    value_pct   DOUBLE  NOT NULL CHECK (value_pct BETWEEN 0 AND 100),\n    source      VARCHAR NOT NULL,\n    PRIMARY KEY (wave_id, tool, metric)\n);\n```\n\nAdding 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.\n\n### Step 4: Load the CSV with read_csv\n\nCreate `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.\n\n``` python\nfrom pathlib import Path\n\nROOT = Path(__file__).parent\n\ndef build(con, csv_path=ROOT / \"data\" / \"waves.csv\"):\n    con.execute((ROOT / \"sql\" / \"schema.sql\").read_text())\n    con.execute(\n        \"INSERT INTO waves SELECT * FROM read_csv(?, header = true)\",\n        [str(csv_path)],\n    )\n    for path in sorted((ROOT / \"sql\").glob(\"[0-9]*.sql\")):\n        con.execute(path.read_text())\n```\n\nThe `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:\n\n``` python\npython - <<'EOF'\nimport duckdb\nfrom db import build\n\ncon = duckdb.connect()\nbuild(con)\nprint(con.execute(\"SELECT count(*) FROM waves\").fetchone())\nEOF\n(8,)\n```\n\nEight 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:\n\n```\n_duckdb.ConstraintException: Constraint Error: CHECK constraint failed on table \"waves\" with expression CHECK((value_pct BETWEEN 0 AND 100))\n```\n\nRevert 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.\n\n## Steps 5 to 7: Funnel, Trend and Lead Views\n\nThree 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](https://shattered.io/cursor-vs-copilot-seat-audit-cost-per-active-developer-12-steps/), the same view-per-question layout keeps the queries readable.\n\n### Step 5: Compute the awareness-to-use funnel\n\nCreate `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.\n\n```\nCREATE OR REPLACE VIEW funnel AS\nSELECT\n    wave_id,\n    wave_order,\n    wave_label,\n    tool,\n    max(value_pct) FILTER (WHERE metric = 'aware')       AS aware_pct,\n    max(value_pct) FILTER (WHERE metric = 'use_at_work') AS use_pct,\n    round(100 * max(value_pct) FILTER (WHERE metric = 'use_at_work')\n              / nullif(max(value_pct) FILTER (WHERE metric = 'aware'), 0), 1) AS conversion_pct,\n    max(value_pct) FILTER (WHERE metric = 'aware')\n      - max(value_pct) FILTER (WHERE metric = 'use_at_work') AS gap_pts\nFROM waves\nGROUP BY wave_id, wave_order, wave_label, tool;\n```\n\nThe `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:\n\n``` python\npython -c \"\nimport duckdb\nfrom db import build\ncon = duckdb.connect()\nbuild(con)\nprint(con.sql('SELECT wave_id, tool, aware_pct, use_pct, conversion_pct, gap_pts FROM funnel ORDER BY wave_id, tool'))\n\"\n┌────────────┬─────────┬───────────┬─────────┬────────────────┬─────────┐\n│  wave_id   │  tool   │ aware_pct │ use_pct │ conversion_pct │ gap_pts │\n│  varchar   │ varchar │  double   │ double  │     double     │ double  │\n├────────────┼─────────┼───────────┼─────────┼────────────────┼─────────┤\n│ jb-2026-01 │ copilot │      NULL │    29.0 │           NULL │    NULL │\n│ jb-2026-01 │ cursor  │      69.0 │    18.0 │           26.1 │    51.0 │\n│ jb-2026-05 │ copilot │      79.0 │    21.0 │           26.6 │    58.0 │\n│ jb-2026-05 │ cursor  │      75.0 │    12.0 │           16.0 │    63.0 │\n└────────────┴─────────┴───────────┴─────────┴────────────────┴─────────┘\n```\n\nRead 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.\n\n### Step 6: Add wave-over-wave trends with a window function\n\nCreate `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.\n\n```\nCREATE OR REPLACE VIEW trend AS\nSELECT\n    *,\n    use_pct - lag(use_pct) OVER w AS use_delta_pts,\n    round(100 * (use_pct - lag(use_pct) OVER w) / lag(use_pct) OVER w, 1) AS use_delta_rel_pct,\n    aware_pct - lag(aware_pct) OVER w AS aware_delta_pts,\n    round(conversion_pct - lag(conversion_pct) OVER w, 1) AS conversion_delta_pts\nFROM funnel\nWINDOW w AS (PARTITION BY tool ORDER BY wave_order);\n```\n\nPercentage 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.\n\n```\n┌─────────┬───────────────┬───────────────────┬─────────────────┬──────────────────────┐\n│  tool   │ use_delta_pts │ use_delta_rel_pct │ aware_delta_pts │ conversion_delta_pts │\n│ varchar │    double     │      double       │     double      │        double        │\n├─────────┼───────────────┼───────────────────┼─────────────────┼──────────────────────┤\n│ copilot │          NULL │              NULL │            NULL │                 NULL │\n│ copilot │          -8.0 │             -27.6 │            NULL │                 NULL │\n│ cursor  │          NULL │              NULL │            NULL │                 NULL │\n│ cursor  │          -6.0 │             -33.3 │             6.0 │                -10.1 │\n└─────────┴───────────────┴───────────────────┴─────────────────┴──────────────────────┘\n```\n\nThe 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.\n\n### Step 7: Measure Copilot’s lead\n\nCreate `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.\n\n```\nCREATE OR REPLACE VIEW lead AS\nSELECT\n    wave_id,\n    wave_order,\n    wave_label,\n    max(use_pct) FILTER (WHERE tool = 'copilot') AS copilot_use,\n    max(use_pct) FILTER (WHERE tool = 'cursor')  AS cursor_use,\n    max(use_pct) FILTER (WHERE tool = 'copilot')\n      - max(use_pct) FILTER (WHERE tool = 'cursor') AS lead_pts,\n    round(max(use_pct) FILTER (WHERE tool = 'copilot')\n        / nullif(max(use_pct) FILTER (WHERE tool = 'cursor'), 0), 2) AS copilot_to_cursor\nFROM funnel\nGROUP BY wave_id, wave_order, wave_label;\n┌───────────────┬─────────────┬────────────┬──────────┬───────────────────┐\n│  wave_label   │ copilot_use │ cursor_use │ lead_pts │ copilot_to_cursor │\n│    varchar    │   double    │   double   │  double  │      double       │\n├───────────────┼─────────────┼────────────┼──────────┼───────────────────┤\n│ January 2026  │        29.0 │       18.0 │     11.0 │              1.61 │\n│ May-July 2026 │        21.0 │       12.0 │      9.0 │              1.75 │\n└───────────────┴─────────────┴────────────┴──────────┴───────────────────┘\n```\n\nCopilot 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.\n\n## Steps 8 and 9: Guardrails, Report and Export\n\nViews 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.\n\n### Step 8: Refuse to report incomplete waves\n\nThe `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.\n\nThe 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.\n\n### Step 9: Print the report and export CSVs\n\nCreate `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.\n\n``` python\n#!/usr/bin/env python3\nimport argparse\nimport sys\nfrom pathlib import Path\n\nimport duckdb\n\nfrom db import build\n\nROOT = Path(__file__).parent\n\ndef check(con):\n    problems = []\n    waves = [r[0] for r in con.execute(\n        \"SELECT DISTINCT wave_id FROM waves ORDER BY 1\").fetchall()]\n    for wave in waves:\n        for tool in (\"copilot\", \"cursor\"):\n            n = con.execute(\n                \"SELECT count(*) FROM waves WHERE wave_id = ? AND tool = ? \"\n                \"AND metric = 'use_at_work'\", [wave, tool]).fetchone()[0]\n            if n == 0:\n                problems.append(f\"{wave}: no use_at_work row for {tool}\")\n    return problems\n\ndef bar(value, scale=2.0):\n    return \"#\" * int(round(value / scale)) if value is not None else \"n/a\"\n\ndef fmt(x, suffix=\"\"):\n    if x is None:\n        return \"n/a\"\n    return f\"{x:.1f}{suffix}\" if suffix else f\"{x:g}\"\n\ndef report(con):\n    print(\"FUNNEL (percent of respondents, as published)\")\n    print(f\"{'wave':<15}{'tool':<9}{'aware':>7}{'use':>6}{'conv':>8}{'gap':>7}\")\n    rows = con.execute(\n        \"SELECT wave_label, tool, aware_pct, use_pct, conversion_pct, gap_pts \"\n        \"FROM funnel ORDER BY wave_order, tool\").fetchall()\n    for label, tool, aware, use, conv, gap in rows:\n        print(f\"{label:<15}{tool:<9}{fmt(aware):>7}{fmt(use):>6}\"\n              f\"{fmt(conv, '%'):>8}{fmt(gap):>7}\")\n\n    print(\"\\nTREND (change from the previous wave)\")\n    print(f\"{'wave':<15}{'tool':<9}{'use pts':>8}{'use rel%':>10}\"\n          f\"{'aware pts':>11}{'conv pts':>10}\")\n    rows = con.execute(\n        \"SELECT wave_label, tool, use_delta_pts, use_delta_rel_pct, \"\n        \"aware_delta_pts, conversion_delta_pts FROM trend \"\n        \"WHERE use_delta_pts IS NOT NULL ORDER BY wave_order, tool\").fetchall()\n    for label, tool, d_use, d_rel, d_aw, d_conv in rows:\n        print(f\"{label:<15}{tool:<9}{fmt(d_use):>8}{fmt(d_rel):>10}\"\n              f\"{fmt(d_aw):>11}{fmt(d_conv):>10}\")\n\n    print(\"\\nLEAD (Copilot over Cursor, work use)\")\n    print(f\"{'wave':<15}{'copilot':>9}{'cursor':>8}{'lead pts':>10}{'ratio':>8}\")\n    for label, cp, cu, lead, ratio in con.execute(\n            \"SELECT wave_label, copilot_use, cursor_use, lead_pts, copilot_to_cursor \"\n            \"FROM lead ORDER BY wave_order\").fetchall():\n        print(f\"{label:<15}{fmt(cp):>9}{fmt(cu):>8}{fmt(lead):>10}{fmt(ratio):>8}\")\n\n    print(\"\\nWORK USE BARS (1 # = 2 points)\")\n    for label, tool, use in con.execute(\n            \"SELECT wave_label, tool, use_pct FROM funnel \"\n            \"ORDER BY wave_order, tool\").fetchall():\n        print(f\"{label:<15}{tool:<9}{bar(use)}\")\n\ndef export(con, out_dir):\n    out_dir.mkdir(exist_ok=True)\n    for name in (\"funnel\", \"trend\", \"lead\"):\n        target = out_dir / f\"{name}.csv\"\n        con.execute(f\"COPY (SELECT * FROM {name}) TO '{target}' (HEADER, DELIMITER ',')\")\n        print(f\"wrote {target}\")\n\ndef main(argv=None):\n    parser = argparse.ArgumentParser(description=\"Awareness-to-adoption funnel\")\n    parser.add_argument(\"--csv\", default=str(ROOT / \"data\" / \"waves.csv\"))\n    parser.add_argument(\"--export\", action=\"store_true\")\n    args = parser.parse_args(argv)\n\n    con = duckdb.connect()\n    build(con, args.csv)\n    problems = check(con)\n    if problems:\n        print(\"REFUSING TO REPORT:\", *problems, sep=\"\\n  \", file=sys.stderr)\n        return 1\n    report(con)\n    if args.export:\n        export(con, ROOT / \"out\")\n    return 0\n\nif __name__ == \"__main__\":\n    sys.exit(main())\n```\n\nRun it:\n\n```\npython funnel.py --export\nFUNNEL (percent of respondents, as published)\nwave           tool       aware   use    conv    gap\nJanuary 2026   copilot      n/a    29     n/a    n/a\nJanuary 2026   cursor        69    18   26.1%     51\nMay-July 2026  copilot       79    21   26.6%     58\nMay-July 2026  cursor        75    12   16.0%     63\n\nTREND (change from the previous wave)\nwave           tool      use pts  use rel%  aware pts  conv pts\nMay-July 2026  copilot        -8     -27.6        n/a       n/a\nMay-July 2026  cursor         -6     -33.3          6     -10.1\n\nLEAD (Copilot over Cursor, work use)\nwave             copilot  cursor  lead pts   ratio\nJanuary 2026          29      18        11    1.61\nMay-July 2026         21      12         9    1.75\n\nWORK USE BARS (1 # = 2 points)\nJanuary 2026   copilot  ##############\nJanuary 2026   cursor   #########\nMay-July 2026  copilot  ##########\nMay-July 2026  cursor   ######\n```\n\nThe export flag also writes three files:\n\n```\nwrote ./out/funnel.csv\nwrote ./out/trend.csv\nwrote ./out/lead.csv\n```\n\nThe 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.\n\n## Steps 10 and 11: Tests and Reading the Output\n\nA 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.\n\n### Step 10: Write the tests\n\nCreate `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.\n\n``` python\nimport duckdb\nimport pytest\n\nimport db\nimport funnel\n\nHEADER = \"wave_id,wave_order,wave_label,tool,metric,value_pct,source\\n\"\n\ndef make(tmp_path, rows):\n    path = tmp_path / \"waves.csv\"\n    path.write_text(HEADER + \"\\n\".join(rows) + \"\\n\")\n    con = duckdb.connect()\n    db.build(con, path)\n    return con\n\nGOOD = [\n    \"w1,1,One,copilot,use_at_work,30,t\",\n    \"w1,1,One,copilot,aware,80,t\",\n    \"w1,1,One,cursor,use_at_work,15,t\",\n    \"w1,1,One,cursor,aware,60,t\",\n]\n\ndef test_conversion_is_use_over_aware(tmp_path):\n    con = make(tmp_path, GOOD)\n    got = dict(con.execute(\"SELECT tool, conversion_pct FROM funnel\").fetchall())\n    assert got == {\"copilot\": 37.5, \"cursor\": 25.0}\n\ndef test_missing_awareness_gives_null_not_zero(tmp_path):\n    con = make(tmp_path, [r for r in GOOD if \"copilot,aware\" not in r])\n    row = con.execute(\n        \"SELECT conversion_pct FROM funnel WHERE tool = 'copilot'\").fetchone()\n    assert row == (None,)\n\ndef test_trend_uses_previous_wave_per_tool(tmp_path):\n    rows = GOOD + [\n        \"w2,2,Two,copilot,use_at_work,24,t\",\n        \"w2,2,Two,cursor,use_at_work,15,t\",\n    ]\n    con = make(tmp_path, rows)\n    got = dict(con.execute(\n        \"SELECT tool, use_delta_pts FROM trend WHERE wave_id = 'w2'\").fetchall())\n    assert got == {\"copilot\": -6, \"cursor\": 0}\n\ndef test_percentage_over_100_is_rejected(tmp_path):\n    with pytest.raises(duckdb.ConstraintException):\n        make(tmp_path, GOOD + [\"w1,1,One,cursor,aware,140,t\"])\n\ndef test_unknown_metric_is_rejected(tmp_path):\n    with pytest.raises(duckdb.ConstraintException):\n        make(tmp_path, GOOD + [\"w1,1,One,cursor,satisfaction,50,t\"])\n\ndef test_check_flags_wave_missing_a_tool(tmp_path):\n    con = make(tmp_path, [r for r in GOOD if \"cursor,use_at_work\" not in r])\n    assert funnel.check(con) == [\"w1: no use_at_work row for cursor\"]\n\ndef test_lead_ratio(tmp_path):\n    con = make(tmp_path, GOOD)\n    assert con.execute(\"SELECT copilot_to_cursor FROM lead\").fetchone() == (2.0,)\npython -m pytest -v\ntest_funnel.py::test_conversion_is_use_over_aware PASSED\ntest_funnel.py::test_missing_awareness_gives_null_not_zero PASSED\ntest_funnel.py::test_trend_uses_previous_wave_per_tool PASSED\ntest_funnel.py::test_percentage_over_100_is_rejected PASSED\ntest_funnel.py::test_unknown_metric_is_rejected PASSED\ntest_funnel.py::test_check_flags_wave_missing_a_tool PASSED\ntest_funnel.py::test_lead_ratio PASSED\n============================== 7 passed in 0.34s ===============================\n```\n\nThe 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.\n\n### Step 11: Read the output without overclaiming\n\nNow that the pipeline works, decide what you are allowed to say. The derived numbers, all computed from the published figures above, are these.\n\n| Derived metric | GitHub Copilot | Cursor | \n|---|---|---|\n| Work use change, January to May-July 2026 | 29% to 21% | 18% to 12% | \n| Awareness change over the same period | not computable | +6 points | \n| Conversion, January 2026 | not computable | Not listed | \n| Conversion, May to July 2026 | 26.6% | 16.0% | \n| Lead in work use, January to May-July | Ahead: 29% to 21% | Behind: 18% to 12% | \n\nSafe 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.\n\nSeveral 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](https://shattered.io/cursor-vs-copilot-margin-of-error-wilson-interval-12-steps-2026/) 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.\n\n## Step 12: Add the Next Wave in Five Minutes\n\nThe 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.\n\n### Step 12: Append rows, rerun, review the diff\n\nOpen `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.\n\n```\nNEXT_WAVE_ID,3,NEXT_LABEL,copilot,use_at_work,NN,SOURCE\nNEXT_WAVE_ID,3,NEXT_LABEL,cursor,use_at_work,NN,SOURCE\nNEXT_WAVE_ID,3,NEXT_LABEL,copilot,aware,NN,SOURCE\nNEXT_WAVE_ID,3,NEXT_LABEL,cursor,aware,NN,SOURCE\n```\n\nReplace 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.\n\nTreat 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.\n\nWatch 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.\n\n## Why the Waves Move: Copilot and Cursor Release Events\n\nSurvey 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.\n\n| Date | Tool | Event | \n|---|---|---|\n| Not listed | Cursor | Composer 2 released, priced at $0.50 per million input tokens and $2.50 per million output tokens | \n| 2026-07-28 | Cursor | Cursor Start plan launched in India at ₹649 a month | \n| 2026-10-28 | Copilot | Connected Copilot cloud experience announced across Web, Mobile, App, CLI, VS Code, Slack and Microsoft Teams | \n| 2026-11-03 | Cursor | Claude Sonnet 5.5 added to the Cursor model catalog | \n| 2026-11-16 | Copilot | GitHub deprecated several models across most Copilot experiences | \n| 2026-11-17 | Copilot | GPT-6.2 Astra and GPT-6.2 Sol became generally available, and MAI Code 2 became available | \n| 2026-11-18 | Copilot | Gemini 4 Neon became generally available for Pro+, Max, Business and Enterprise | \n| 2026-11-23 | Copilot | Billing for cloud sandbox usage begins | \n\nCursor’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](https://github.com/features/copilot/plans) 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](https://github.blog/changelog/month/11-2026/page/3/) 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.\n\nThe 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](https://shattered.io/github-copilot-vs-cursor-4-models-8-days-2026/) would fit entirely inside one survey window. For price comparisons on the same products, the [pricing breakdown for Claude Code, Cursor and Copilot](https://shattered.io/claude-code-vs-cursor-vs-github-copilot-pricing-limits-2026/) sets the plans side by side.\n\nOne 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.\n\n## Common Pitfalls\n\nEight mistakes account for most wrong conclusions drawn from Cursor vs Copilot adoption data. Each one has bitten real dashboards.\n\n1. **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.\n2. **Merging surveys.** JetBrains and Stack Overflow ask different people different questions. Keep each in its own wave id and never average across them.\n3. **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.\n4. **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.\n5. **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.\n6. **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` .\n7. **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 to[migrating Cursor rules from Copilot](https://shattered.io/cursor-rules-migrate-github-copilot-2026/) explains how teams keep both tools working during a move.\n8. **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.\n\nA 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.\n\n## Troubleshooting\n\nNine problems cover nearly every failure seen while building and testing this project. The error text below is copied from real runs.\n\n- **No module named duckdb.** The message is`ModuleNotFoundError: No module named 'duckdb'` . The virtual environment is not active. Run`. .venv/bin/activate` and retry.\n- **File not found on load.** DuckDB reports`IO Error: No files found that match the pattern` followed by the path. Run the script from the project root, or pass an absolute path with`--csv` .\n- **Percent sign in a value.** A cell such as 40% raises`Conversion Error: CSV Error on Line: 2` with`Could not convert string \"40%\" to 'DOUBLE'` . Store plain numbers. The column name already says percent.\n- **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.\n- **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 in`sql/schema.sql` .\n- **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.\n- **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.\n- **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.\n- **No module named numpy.** Calling`fetchdf()` or`.df()` needs numpy and pandas. Use`fetchall()` as the scripts here do, or install pandas deliberately.\n\nIf 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.\n\n## Advanced Tips\n\nOnce the base project runs cleanly, five extensions add real analytical value without bloating the code.\n\n### Join events to waves with an ASOF join\n\nDuckDB’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.\n\n```\nCREATE OR REPLACE TABLE wave_windows (wave_id VARCHAR, wave_end DATE);\nINSERT INTO wave_windows VALUES\n    ('jb-2026-01', DATE '2026-01-31'),\n    ('jb-2026-05', DATE '2026-07-31');\n\nCREATE OR REPLACE TABLE events (event_date DATE, tool VARCHAR, event VARCHAR);\nINSERT INTO events VALUES\n    (DATE '2026-03-19', 'cursor',  'Composer 2 released'),\n    (DATE '2026-07-28', 'cursor',  'Cursor Start launched in India'),\n    (DATE '2026-10-28', 'copilot', 'Connected Copilot cloud experience announced'),\n    (DATE '2026-11-03', 'cursor',  'Claude Sonnet 5.5 added'),\n    (DATE '2026-11-17', 'copilot', 'GPT-6.2 Astra and Sol generally available'),\n    (DATE '2026-11-18', 'copilot', 'Gemini 4 Neon generally available');\n\nSELECT e.event_date, e.tool, e.event, w.wave_id\nFROM events e\nASOF LEFT JOIN wave_windows w ON e.event_date <= w.wave_end\nORDER BY e.event_date;\n```\n\nRun it through a short Python loop that executes each statement and prints the final one. The output:\n\n```\nevent_date  tool     event                                         wave_id\n2026-03-19  cursor   Composer 2 released                           jb-2026-05\n2026-07-28  cursor   Cursor Start launched in India                jb-2026-05\n2026-10-28  copilot  Connected Copilot cloud experience announced  None\n2026-11-03  cursor   Claude Sonnet 5.5 added                       None\n2026-11-17  copilot  GPT-6.2 Astra and Sol generally available     None\n2026-11-18  copilot  Gemini 4 Neon generally available             None\n```\n\nThe 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](https://shattered.io/benchmark-cursor-vs-github-copilot-2026/) is the natural companion when the question shifts from what developers report to what each assistant does on your code.\n\n### Add more tools\n\nJetBrains’ 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.\n\n### Query a raw survey file the same way\n\nIf 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.\n\n```\nSELECT trim(tool) AS tool, count(*) AS respondents\nFROM (\n    SELECT unnest(string_split(your_tool_column, ';')) AS tool\n    FROM read_csv('survey.csv')\n)\nGROUP BY 1\nORDER BY respondents DESC;\n```\n\nCheck 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.\n\n### Store sample sizes when they exist\n\nAdd 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.\n\n### Run it on a schedule\n\nA 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.\n\n## The Complete Project\n\nThe final layout is small enough to hold in your head, and every file in it was written in the steps above.\n\n```\nfunnel/\n  data/waves.csv        8 rows, 7 columns\n  sql/schema.sql        table, CHECK constraints, primary key\n  sql/10_funnel.sql     awareness, work use, conversion, gap\n  sql/20_trend.sql      lag() deltas per tool\n  sql/30_lead.sql       Copilot lead in points and ratio\n  sql/events.sql        optional ASOF join of launches to waves\n  db.py                 build(): schema, load, numbered views\n  funnel.py             guard, report, CSV export\n  test_funnel.py        7 pytest tests\n```\n\nTwo commands run everything from the project root, with the virtual environment active:\n\n```\npython funnel.py --export\npython -m pytest -q\n.......                                                                  [100%]\n7 passed in 0.36s\n```\n\nThe 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](https://shattered.io/category/software/) section collects the rest of the assistant and IDE coverage.\n\n## FAQ\n\n### Is GitHub Copilot or Cursor more widely used, according to the surveys?\n\nIn 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.\n\n### Why did both tools lose work-use share between waves?\n\nThe 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.\n\n### Did Stack Overflow’s 2026 survey publish a Cursor vs Copilot number?\n\nI 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.\n\n### Why use DuckDB instead of a spreadsheet or pandas?\n\nDuckDB 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.\n\n### Which DuckDB version should I install?\n\nUse 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.\n\n### Is the conversion ratio a real adoption rate?\n\nNo. 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.\n\n### How often should I update the ledger?\n\nWhenever 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.\n\n### Can the same project track Claude Code or other tools?\n\nYes. 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.", "url": "https://wpnews.pro/news/cursor-vs-copilot-funnel-in-duckdb-12-steps-70-min", "canonical_source": "https://shattered.io/cursor-vs-copilot-adoption-funnel-duckdb-12-steps-2026/", "published_at": "2026-11-21 01:43:06+00:00", "updated_at": "2026-11-21 02:13:58.778222+00:00", "lang": "en", "topics": ["ai-tools", "developer-tools", "ai-products"], "entities": ["JetBrains", "GitHub Copilot", "Cursor", "DuckDB", "Stack Overflow", "Visual Studio Code", "Shattered"], "also_reported_by": [], "takeaway": "Store each published survey percentage with its wave and instrument in a DuckDB ledger with constraints that reject bad entries, keeping the unconfirmed January 2026 Copilot awareness cell empty and separating the 39% JetBrains-IDE figure, which has a different denominator, so waves are never averag", "recommendation": null, "alternates": {"html": "https://wpnews.pro/news/cursor-vs-copilot-funnel-in-duckdb-12-steps-70-min", "markdown": "https://wpnews.pro/news/cursor-vs-copilot-funnel-in-duckdb-12-steps-70-min.md", "text": "https://wpnews.pro/news/cursor-vs-copilot-funnel-in-duckdb-12-steps-70-min.txt", "jsonld": "https://wpnews.pro/news/cursor-vs-copilot-funnel-in-duckdb-12-steps-70-min.jsonld"}}