Hands-on Copilot: Writing Stata in VS Code

From the do-file editor to AI-assisted coding

Minghong Shen · Postdoctoral Fellow, NYU Shanghai

Workshop on AI in Social Science Research

July 22, 2026

Meet Copilot

How do you write Stata today?

Stata’s built-in do-file editor

• Little to no autocomplete
• Every variable, macro, and result typed by hand
• Stata 15 and earlier: not even command completion
• Forgot an option? Back to help

Where we’re moving today

• VS Code ＋ a Stata extension
• Syntax highlighting and snippets
• GitHub Copilot inline completions
• Send code to Stata with one keystroke

The pain of writing Stata is rarely the statistics. It’s the typing, over and over.

Open by naming the pain they actually feel. Most Stata users on Windows are on the built-in do-file editor with little or no autocomplete - and on Stata 15 or earlier there is none at all. Frame today’s first tool (Copilot) as the gentlest possible upgrade, not a leap. We will get to the big leap (agents) in the main talk.

Three tiers: chat → autocomplete → agent

We start at ② autocomplete. You still control every line; you just type faster.

Later today: ③ agents. One sentence, and it reads the data, writes the code, and delivers results.

This is the spine of the whole lecture. Three tiers of AI assistance, increasing in autonomy. Copilot completes the line you are already writing - you stay in control of every keystroke. Chat explains and drafts. Agents do the whole job end to end. We deliberately start at tier 1 because it is the smallest behavior change for a Stata user, and it sets up the contrast that motivates the rest of the talk. Mirrors the “do not climb the ladder, jump” slide later.

What is GitHub Copilot?

What it is

• AI inline completion inside your editor
• Grey “ghost text”; press Tab to accept
• Guesses from the context around your cursor
• Lives in VS Code; you never leave the editor

How it differs from a chatbot

• Chatbot: switch to a browser tab and ask
• Copilot: picks up right where you’re typing
• No context switch; it completes as you go
• Free for verified students and teachers

In short: Copilot is predictive text for code. You start the line, it finishes it; you decide, and Tab seals it.

Keep this concrete. Copilot is autocomplete on steroids - grey ghost text appears as you type, Tab accepts it. The mental model “predictive text for code” lands well: everyone already lets their phone finish their sentences. Mention the free education license (GitHub Education for students and teachers) so cost is not a barrier - they can all get it.

Comments as prompts

The trick: write one comment that says what you want; Copilot follows with the command.

You type a Stata comment → Copilot suggests the rest (grey ghost text; Tab to accept):

▌

▌⇥ Tab to accept

The more specific the comment, the better the completion. Name the variables, options, and if/in conditions you want.

This is the single most useful Copilot habit for Stata: comment-as-prompt. Write a clear Stata comment describing the step, and the completion follows. Demo this live if possible. Emphasize that specificity in the comment (naming the variable, the option you want, the row/col percent) steers the suggestion. This is also a good moment to foreshadow the honesty slide: the suggestion is a draft, not gospel.

Getting the most out of Copilot

Six core techniques

①　Comment first Write one comment saying what you want, then let it complete.

②　State the goal up top A header comment on the file’s purpose gives Copilot the big picture.

③　Take small steps One line at a time: accept, then write the next comment.

④　Show an example Put an “input → output” sample in the comment; it will follow suit.

⑤　Name things clearly Long names are fine. Cryptic names are not.

⑥　Open related files Copilot reads your open tabs to understand the context.

These six are GitHub’s own documented best practices for steering inline completions (Best Practices page + “how to write better prompts” blog). The throughline: you are giving the model context and structure. Comment-as-prompt and naming are the two that pay off fastest. Decompose (3) is the habit most people miss - accept one line, then write the next comment, rather than expecting a whole function at once. The neighboring-tabs trick (6) is non-obvious and worth a beat: open your data dictionary or a sibling script and suggestions improve. Bottom rule: always review before accepting.

Choosing your statistics language

The same comment-as-prompt trick works best in languages with plenty of training data:

R · dplyr

▌

▌

Python · pandas

▌

▌

This slide demonstrates the techniques where Copilot is genuinely strong - R and Python. Both blocks come from a single intent comment; Copilot completes idiomatic dplyr and pandas. Say plainly that completions are non-deterministic, so “you will get something like this”. The orange box is deliberate foreshadowing: hold this feeling of fluency, because the Stata limitations slide later will contrast against it. This is also where you acknowledge that some of the audience also use R or Python - the techniques transfer, the editor is the same.

Accept, cycle, chat: the shortcuts

Action	Shortcut (Windows)
Accept suggestion	Tab
Dismiss	Esc
Accept next word	Ctrl + →
Next / previous suggestion	Alt + ]　·　Alt + [
Trigger a suggestion	Alt + \
Open completions panel (several options)	Ctrl + Enter
Inline chat	Ctrl + I

Try it: write a comment → watch the grey completion → press the keys below (each click demos one key).

▌

▌

⇥ Tab: accept line ␛ Esc: dismiss Ctrl + →: one word

When one completion isn’t enough, inline chat (Ctrl + I) ＋ slash commands give you targeted operations:
/explain · /fix · /tests · /doc.

Keybindings are Windows defaults, verified against GitHub and VS Code docs. The two people forget: Ctrl+Right accepts just the next word (keep the good half, re-steer the rest), and the Alt-bracket pair cycles alternatives because the first suggestion is not always best. Do NOT promise a separate accept-next-line key - it is not a documented default. Inline chat is the escape hatch: when ghost text is not enough, Ctrl+I opens chat in place, and slash commands scope the request. Frame autocomplete as “flow” and inline chat as “targeted operations”.

Setup: VS Code + Stata

Why VS Code instead of Stata’s own editor?

Stata’s built-in autocomplete has long been weak, and it depends heavily on your version:

Stata version	Built-in completion	What it completes
≤ 15	None	Nothing at all
16 – 18	Partial	Commands / keywords / brackets; no variable names
19 / StataNow	Fairly full	Commands ＋ variables ＋ macros ＋ stored results

VS Code ＋ Copilot levels the field: whether you run Stata 14 or Stata 19, you get inline AI completion.

This table is the core justification for the whole VS Code detour, and it is honest. Native autocomplete did not exist before Stata 16; 16-18 only complete commands and keywords, not variable names; only Stata 19 / StataNow does the full thing. Many in the room are on older versions. The pitch: VS Code + Copilot gives AI completion on ANY version, including old ones - which the Stata Automation bridge (next slide) makes possible.

Three-step setup (Windows)

1

Install VS Code ＋ a Stata extension. We recommend Stata All in One (highlighting ＋ completion ＋ run ＋ data browser), or the lighter vscode-stata / stataRun.

2

Register Stata’s Automation interface (once, so VS Code can send code to Stata):

Create a shortcut to StataMP-64.exe and append /Register to the target:
"C:\Program Files\Stata18\StataMP-64.exe" /Register
Right-click → Run as administrator (once is enough)

← This uses Stata’s long-standing Automation API, so it works on older versions too.

3

Enter the Stata executable path in the extension settings. For example, C:\Program Files\Stata18\StataMP-64.exe (older versions often live in Program Files (x86)).

Three steps, Windows-specific. Step 2 is the one people get stuck on and the one worth doing slowly: the /Register trick registers Stata’s COM Automation server so VS Code can push code into a running Stata. It must be run as administrator once. Stress that this is StataCorp’s own long-standing Automation API (not an AI thing), which is precisely why it works on Stata 14/15/16 too. Step 3: the extension needs the exact exe path; old versions live under Program Files (x86), and MP/SE/IC is chosen by which exe you point at.

Make .do files Stata ＋ install Copilot

Tell VS Code that .do means Stata

Add this to settings.json:

"files.associations": {
  "*.do": "stata",
  "*.ado": "stata"
}

Once the language is recognized as Stata, highlighting, completion, and Copilot’s context all work properly.

Install GitHub Copilot and sign in

1. Search the Extensions panel for GitHub Copilot and install it
2. Sign in with your GitHub account (students and teachers: claim free access via GitHub Education)
3. Open a .do file and start typing → watch for grey text

Tab accepts, Esc dismisses, Alt+] shows the next suggestion.

Two finishing touches. First, file association: Copilot scopes its context off the editor’s language ID, so if .do is not recognized as Stata the suggestions get worse. The settings.json snippet fixes it globally. Second, install the Copilot extension and sign in - remind them of the free education license again. If demoing live, just switch to the real VS Code here.

Running code: sending your .do to Stata

Action	vscode-stata	stataRun
Run selection / current line	Shift + Enter	Shift + Ctrl + S
Run whole file	Ctrl + Shift + D	Shift + Ctrl + A
Run from cursor down	–	Shift + Ctrl + D

The code runs in a real Stata window alongside, so results, graphs, and r()/e() behave exactly as usual. Shortcuts vary by extension; check the one you installed.

The run-code loop is what makes VS Code a real Stata front end rather than just a text editor. Select lines, hit the key, they execute in the actual Stata window - same results, same graphs, same stored results. Keybindings differ by extension (vscode-stata vs stataRun), so tell them to check whichever they installed. This is a good live-demo beat: run a line and show it land in Stata.

Hands-on: World Values Survey

The data: World Values Survey

World Values Survey

• Cross-national, repeated survey of values and attitudes
• Trust, religion, political participation, gender norms…
• Wave 7 covers 60＋ countries and territories
• One of the most widely used cross-national datasets in social science

Where our data lives

D:\Data\WVS\
  └─ WVS_Wave7.dta

⚠ Before the demo: put the real .dta in this folder and check the file and variable names (the code on the next slides uses placeholder names).

Goal: use Copilot in VS Code to take WVS through cleaning → description → regression, all in Stata.

Introduce WVS briefly for anyone unfamiliar - it is a staple cross-national values survey, Wave 7 covers 60-plus societies. Be transparent about the data path: the file lives at D:. IMPORTANT reminder to self - that folder is currently empty; drop the real .dta in and confirm the actual variable names before the live demo, because the next two slides use Wave-7 placeholder names (Q57, Q71, B_COUNTRY, etc.) that may differ in your extract.

Copilot writes the cleaning ＋ descriptives

Three moves on one slide: a comment yields a command, a few keystrokes complete a line, and context suggests the next step (WVS Wave 7 placeholder variable names):

▌

▌

▌

▌

▌

▌

▌

▌

Walk this top to bottom as a live demo if you can. Three habits on this slide: (1) comment drives the command, (2) type a few chars and Copilot completes the line, (3) Copilot suggests the next line from context (no comment). Q57 = “most people can be trusted”, recoded to 0/1; B_COUNTRY = country; Q262 = age; Q275 = education. These are Wave-7 conventional names - confirm against your actual file. Run each block with Shift+Enter so they see results land in Stata.

Copilot writes the regression

A logit of institutional trust. The second line flips the script: you write the command, Copilot writes the comment (placeholder variables):

▌

▌

▌

▌

▌

▌

Second demo block: a logit of confidence in government on sex, age, education, with country fixed effects and survey weights, plus average marginal effects of education. Mostly comment-driven; the middle line flips it - type the logit, Copilot writes the comment. Deliberately end on the orange warning box - it tees up the honesty slide. Do not oversell the output; if running live, glance at whether the signs are plausible and say “we will verify this”.

Copilot’s limits

Where Copilot falls short on Stata

Why it struggles with Stata

• Stata code is scarce in training data (few do-files are public)
• Stata has no language server, so it can only guess from text
• It invents commands and mixes in SAS / R syntax
• The more obscure the command, the more likely it fails

Real failures

• Asked for a weighted variance, it made up a nonexistent pwvariance command
• It borrows function names from other languages
• Coefficients and options are right only some of the time

Sources: Ozier (World Bank), Goldsmith-Pinkham, and other public tests

The iron rule: Copilot gives you a draft, not an answer. Run and check every line yourself.

This is the honest heart of the segment, and it is what makes the talk credible rather than hype. Two reasons Copilot is weak at Stata: training-data scarcity (few do-files are public) and the absence of a Stata language server, so it pattern-matches text with no structural code intelligence. The pwvariance anecdote (Owen Ozier’s World Bank post) is the memorable example - it invents a command that does not exist, and bleeds in SAS/R syntax. Goldsmith-Pinkham, an economist, says plainly “Stata was really not very good with Copilot.” The iron rule: drafts, not answers - always verify.

From chat and autocomplete to agents

Chat · ChatGPT / Claude explain errors and suggest approaches.

Autocomplete · Copilot writes with you; you press every Tab.

Agent · Claude Code reads the data, writes the code, and delivers results for you.

The seam slide. Restate the three tiers and the key distinction: with Copilot you still drive every line (you press each Tab); chat explains; agents do the whole job for you. Copilot makes you type faster - agents mean you barely type. End here and hand straight off to the AI agents deck, which is the rest of the two-hour lecture. This is the natural pivot from “AI helps me code” to “AI does the research task”.