CppCon 2026

Modern C++ development spans platforms, build systems, and increasingly complex project structures. In this landscape, Visual Studio Code has carved out its distinct position as a lightweight, extensible editor that works where you do, with first-class extensions built on decades of C++ language services and build system integration. This year's update deepens both of those foundations and opens them up to AI-driven workflows powered by GitHub Copilot.

This session walks through what's new across three dimensions of C++ development in Visual Studio Code. For the inner loop, we'll cover practical improvements to everyday compile-test workflows, including CMake target bookmarks and Run Without Debugging. For writing and understanding code, we'll show how the C/C++ extension's language services now surface rich project understanding to GitHub Copilot, giving AI assistance real awareness of your code structure instead of relying on generic pattern matching. For your workflow, we'll demonstrate how AI capabilities compose across different modes of working: inline suggestions for hands-on editing, agent coordination for multi-file refactoring, and CLI sessions for long-running tasks and deeper codebase analysis you can revisit on your own schedule.

Throughout the session, we’ll use real-world C++ problems to demonstrate where these tools meaningfully improve productivity and where they intentionally stay out of your way. Finally, we’ll show you how to inform GitHub Copilot about your team's best practices and scale them across your code through extensibility points like skills, custom instructions, and custom agents.

Tooling Track sessions are sponsored by Optiver.

At scale, writing C++ becomes a different engineering discipline. Problems that appear secondary in smaller systems — dependency boundaries, build graph stability, toolchain inconsistencies, integration latency, ownership, and deployability — become first-order constraints.

In production HFT, a single core infrastructure repository may contain 26+ million lines of C++ across 100K files, organized into 250+ distinct subprojects: exchange gateways, feed handlers, protocol codecs, shared risk libraries, replay frameworks, and strategy infrastructure. That shared foundation is continuously modified, rebuilt, tested, and deployed by engineering teams across five time zones and more than 40 trading teams, each maintaining their own siloed multi-million-line client systems in C++, Rust, and Python.

Under these conditions, many accepted “best practices” simply do not survive contact with reality. Systems must instead evolve toward what might be called a ground state: components reduced to their essential boundaries and responsibilities, abstract enough to support radically different workloads, but precise enough to compose into a coherent whole.

The challenge is not merely writing fast code. It is building systems that remain correct, flexible, and evolvable while operating under constant latency and operational pressure.

This is not a talk about “perfect architecture,” but about the tradeoffs, hard-earned lessons, constraints, and occasional failures through which generations of engineers — myself included — have kept large systems moving forward without stopping the business behind them.

Last year, the title of this talk would have been "AI in a C++ World." That it isn't anymore tells you most of what changed.

A year ago, AI was the visitor we were evaluating. Now, it is the room we work inside, and the question for C++ programmers is no longer whether to take the technology seriously but how to keep doing serious work in its presence.

Another year of using these tools in earnest on production C++ has clarified what works, and given me an actual workflow to point at instead of a set of slogans.

I'm a professional C++ developer, and yet I haven't written a line of code since last November. Not because I've not written any code, but because AI has written every line.

It is not a theoretical presentation, but a working practitioner's report. I'll walk you through the development workflow I now use for serious C++ development.

Along the way I'll cover what C++ developers actually need to know about how LLMs work, what the agentic loop is, and how to get production-quality C++ out of these systems. The tone is practical, but opinionated, though those opinions are based on personal experience.

If you are not yet using AI as another independent member of your development team, or if you think I'm completely off my rocker, then this talk is definitely for you.

Modern coding agents are incredible, but they still struggle with the kind of large, unstructured codebases that are common in C++. There are several techniques and tools that can make them perform much better. Here we show examples and demos of how to get your agent to work better with complex code. The focus is on providing an overview on current techniques and how we’ve found they work best. - Skills, memory and MCP - these have all been hyped hard, we’ll sort through where they are actually useful. - All agents (Claude, Copilot, Codex, Gemini) support these - some better than others. - What a skill is and what it isn’t - How to use persistent memory - Why MCP servers are still needed (but not always) - Context engineering. - Context management keeps changing - we’ve got autocompaction and 1M token windows now, why should we care anymore? - When to “manage” your agent’s context window and when it’s a bad idea - How to understand where context is being spent. - How and why to use subagents - these are almost always available but the capabilities in different frontends are exposed in different ways. - Spec Oriented Development: buzzword, euphemism for vibe coding or the future of programming? - What is it? - What tools exist? Covering options such as SpecKit, Kiro, etc. - Working in parallel with agent teams! - How to get started without having to learn anything (almost)! - Runtime context. - How to give your agent the best possible feedback path so you can stop micromanaging it and leave it to complete longer, more complex tasks. - Techniques including testing, CI integration and recording-based technology