AI-Native IDE Engineering

What you'll learn

AI has changed what an IDE is. Ghost-text completion, chat that edits your files, and agents that run your tests now ship in every serious editor. Most developers use these features; very few can build them, debug them, measure them or secure them.

This course teaches you to build an AI-native development environment yourself. You start at the bottom of the stack (how an editor stores text, how a language server talks to it) and work upward to a complete, local-first AI coding assistant:

• Editor foundations: text buffers (piece tables, ropes), rendering and latency budgets, the process model of a modern IDE, and building an editor shell with Monaco and a hardened Electron app.
• Language intelligence: the Language Server Protocol (you write a server from scratch) and tree-sitter's incremental parsing.
• The VS Code platform: extension architecture, contribution points, webviews, Workspace Trust, testing and packaging.
• AI features, engineered properly: fill-in-the-middle (FIM) inline completion with debounce, cancellation and caching; context engineering under a token budget; chat with applyable edits; and a tool-using coding agent with approvals.
• The Model Context Protocol (MCP): write a server from scratch for the current stateless protocol (2026-07-28) and with the official SDK.
• Evaluation: FIM benchmarks built from your own repository, unbiased pass@k, latency percentiles, acceptance and retention metrics, and what SWE-bench-style agent benchmarks do and don't tell you.
• Security and shipping: prompt injection through repository content, Trojan Source and invisible characters, secrets, auto-run tasks, MCP supply chain, the OWASP LLM Top 10 (2025), and distributing an extension responsibly.

Everything runs locally against Ollama or llama.cpp: no code leaves the student's machine, and no cloud account or API key is needed. Every lab also has an offline mode (scripted agents, baselines, mock servers), so it works on any laptop and in air-gapped classrooms.

Learning outcomes

By the end of the course, you can:

1. Explain the architecture of a modern IDE (text model, rendering, extension host, language servers, process isolation) and its latency budgets.
2. Implement an editor text buffer and an editor shell, and justify their data-structure and security choices.
3. Build a Language Server from scratch and integrate tree-sitter for structural code understanding.
4. Develop, test and package a VS Code extension with commands, webviews, settings, and Workspace Trust support.
5. Engineer fill-in-the-middle inline completion that is fast, cancellable, cached and restrained.
6. Assemble model context under a token budget (prefix/suffix, definitions, similar snippets, repo-level FIM) and prove its value with ablations.
7. Design chat and edit workflows whose changes are applied reliably (search/replace, diffs, fuzzy matching) and reviewed by the user.
8. Build a tool-using coding agent and MCP servers with least privilege, approvals, sandboxing and checkpoints.
9. Evaluate coding assistants offline (exact match, edit similarity, parse rate, pass@k) and online (acceptance, retention, latency), with sound statistics.
10. Threat-model and harden an AI IDE against prompt injection, malicious repositories, secret leakage and supply-chain risks, and ship it responsibly.

Who it's for

• Software engineers who want to build AI developer tools, IDE plugins or internal coding assistants
• Platform and developer-experience (DevEx) teams rolling out AI coding tools who need to evaluate, secure and customize them
• Tool builders working on editors, language servers or code intelligence
• Graduates of RNK-LLM-301 (local models) and RNK-RAG-401 (retrieval) who want to apply both to code

Prerequisites

Solid programming in Python and working knowledge of JavaScript/TypeScript; git; command line. Helpful: RNK-LLM-301 or equivalent experience running local models. No ML training background needed.

Equipment and software

The full setup guide, with verification steps, is in your learning materials when you enroll.

Format and study time

42 guided hours (10 modules × ~4 h + capstone demo day) plus ~15 h capstone build. Instructor-led cohort (10 sessions), 5-day intensive, or self-paced with office hours.

Each scheduled class below states its own format, every meeting date and time, and its time zone.

What a seat includes

Curriculum

1. 01
   Anatomy of an IDE: text buffers, rendering & latency

   4 h · Lab: A piece table with undo, line index and a benchmark report
2. 02
   Building the editor shell: Monaco, Electron & security

   4 h · Lab: A working mini editor (browser + hardened desktop app)
3. 03
   Language intelligence: LSP from scratch & tree-sitter

   4 h · Lab: A language server for .tasks files with two new features
4. 04
   The VS Code extension platform

   4 h · Lab: The RNK Copilot Lab extension running, with an LSP client and a new command
5. 05
   Inline completion: fill-in-the-middle, engineered

   4 h · Lab: Ghost-text completion with latency measurements
6. 06
   Context engineering for code

   4 h · Lab: A context assembler + an ablation showing what each source adds
7. 07
   Chat, edits & applying changes safely

   4 h · Lab: A chat panel whose edits apply reliably and reviewably
8. 08
   Coding agents & the Model Context Protocol

   4 h · Lab: An approval-gated agent + an MCP server used by a real client
9. 09
   Evaluating AI coding features

   4 h · Lab: An evaluation report comparing two models or configurations
10. 10
    Security, privacy & shipping

    4 h · Lab: A threat model, a hardened extension and a release checklist
11. ★
    Capstone demo day

    2 h · Lab: Capstone project

Assessment and completion

Simply opening a lesson or a video never counts as completing an assessment. Completion is recorded only when the published requirements are met and your instructor has confirmed the result.

Course policies

• Late work: −10% per day for up to 3 days; one free 48-hour extension per student.
• Hardware fairness: grading never rewards faster hardware. Labs are graded on method, correctness and explanation. A student without a capable machine can complete every lab with the mock server, the classroom model server or smaller models.
• AI assistants: allowed, with disclosure in each report. You must be able to explain every line you submit. Fabricated measurements or transcripts are academic misconduct.
• Security: the malicious samples in labs/security/samples/ are for analysis only. Never disable Workspace Trust for them, never run their tasks, and never point course agents at real credentials. Don't expose lab servers beyond 127.0.0.1 (or the classroom LAN, when the instructor provides an authenticated server).
• Licenses: use only models and code whose licenses you accept; note them in reports.
• Accessibility: all materials are searchable PDF documents (Markdown sources available on request); accommodations on request (extra time, alternative lab formats, screen-reader-friendly slide exports).

Upcoming classes