Review of Key Points from 2026-D2

Conference Agenda:https://www.d2conf.com/

Typically, the official slides are shared about a month later, with no livestream or recording provided.

With dozens of sessions running at the same time in a single day, you’re bound to miss a lot. I selected speakers with strong professional depth; the following are only the sessions I attended and found worth revisiting.

Before we start, let me briefly introduce the current JavaScript ecosystem. I’ve found that even many professional front-end developers are not very familiar with the ecosystem they work in, or are still stuck with the understanding they had when they first entered the field. Today’s main players are Vercel, VoidZero, Bun, Biome, and others. I asked ChatGPT to generate an ASCII diagram, and it captures the idea quite well, so I’m sharing it here for reference.

┌──────────────────────────────────────────────────────────────────────┐
│                         JavaScript Ecosystem                         │
└──────────────────────────────────────────────────────────────────────┘

                               ┌──────────────┐
                               │   Developers │
                               └──────┬───────┘
                                      │
                                      ▼
┌──────────────────────────────────────────────────────────────────────┐
│ ① AI / Coding Entry Layer                                            │
│----------------------------------------------------------------------│
│ Cursor / Claude Code / Copilot / Windsurf / Zod                      │
│                                                                      │
│ Functions:                                                           │
│ - Code generation                                                    │
│ - Agent workflows                                                    │
│ - In-IDE interaction                                                 │
└──────────────────────────────────────────────────────────────────────┘
                                      │
                                      ▼
┌──────────────────────────────────────────────────────────────────────┐
│ ② Framework / Application Layer                                      │
│----------------------------------------------------------------------│
│ React / Vue / Svelte / Solid                                         │
│ Next.js / Nuxt / Remix / Astro                                       │
│                                                                      │
│ Representative companies / projects:                                 │
│ - Vercel  → Next.js                                                  │
│ - NuxtLabs → Nuxt                                                    │
│ - Vue / Evan You ecosystem                                           │
└──────────────────────────────────────────────────────────────────────┘
                                      │
                                      ▼
┌──────────────────────────────────────────────────────────────────────┐
│ ③ Toolchain Layer  ← The most intense competition right now           │
│----------------------------------------------------------------------│
│ Bundler / Dev Server / Compiler / Linter / Formatter / Test          │
│                                                                      │
│ Main players:                                                        │
│ - Vite / Rollup / Rolldown        → VoidZero camp                    │
│ - Turbopack                        → Vercel                          │
│ - Rspack                           → ByteDance                       │
│ - Webpack                          → core infrastructure from the old era│
│ - Biome                            → lint / format                   │
│ - esbuild                          → high-performance build primitive │
│ - SWC / OXC                        → compilation infrastructure       │
│                                                                      │
│ This is where it decides:                                            │
│ - Local development experience                                        │
│ - Build speed                                                        │
│ - Configuration model                                                │
│ - Whether AI can directly operate the engineering system             │
└──────────────────────────────────────────────────────────────────────┘
                                      │
                                      ▼
┌──────────────────────────────────────────────────────────────────────┐
│ ④ Runtime Layer                                                      │
│----------------------------------------------------------------------│
│ Node.js / Bun / Deno / Browser / Edge Runtime                        │
│                                                                      │
│ Main players:                                                        │
│ - Node.js Foundation / OpenJS                                        │
│ - Bun                                                                 │
│ - Deno                                                                │
│ - Vercel Edge Runtime                                                 │
│ - Cloudflare Workers                                                  │
└──────────────────────────────────────────────────────────────────────┘
                                      │
                                      ▼
┌──────────────────────────────────────────────────────────────────────┐
│ ⑤ Deploy / Cloud / Delivery Layer                                    │
│----------------------------------------------------------------------│
│ Vercel / Netlify / Cloudflare / AWS / Azure / GCP                    │
│                                                                      │
│ Functions:                                                           │
│ - Deployment                                                         │
│ - Hosting                                                            │
│ - Edge delivery                                                      │
│ - Serverless / AI App Runtime                                        │
└──────────────────────────────────────────────────────────────────────┘

I.Vite+: an integrated JavaScript toolchain — Evan You

The push to rewrite front-end tooling in Rust continues. Writing front-end infrastructure in Rust has basically become an industry consensus, except for the TSC.

Tool type	Older generation (JavaScript)	New generation (Rust)
Scaffolding	Vue CLI / Create React App	Vite 8
Bundling tool	Webpack (with ts-loader) / Rollup	Rolldown
TypeScript build	tsup (based on esbuild)	tsdown
Code linting	ESLint	Oxlint
Code formatting	Prettier	Oxfmt
Test framework	Jest	Vitest

Vite+ unifies the many configuration files in the toolchain into a single file, simplifying setup.

Why does his work matter? Why does the AI era need a unified and efficient toolchain?

The core point is this: writing code is no longer the bottleneck. AI needs to constantly check and validate its own code. If you cannot give AI a clean and efficient toolchain, it will hinder major gains in productivity in the future.

He ended by briefly mentioning products currently in internal testing at VoidZero. The focus is on automated deployment and end-to-end type safety across the full stack. It feels like they are moving into cloud services, in line with Vercel’s direction.

II.Google A2UI - LLM Generated UI for Agents & A2A——Jennie

A quick sense of Google’s influence:

This talk introduced A2UI, which solves the problem of dynamically generating UI for users. Beyond A2UI, there are many other approaches.

Dimension	AG-UI	ChatKit	MCP UI	Vercel AI UI	Google A2UI
Positioning	Front-end state driven	OpenAI-specific	Remote agent rendering	Vertical stack integration	Declarative general-purpose protocol
Core mechanism	Shared client state	Proprietary component library	Sandbox iframe	Shadcn + SDK	JSON rendering description
Signal-to-noise ratio	Extremely high (native performance)	Medium	Medium (cross-domain communication overhead)	High (development efficiency)	Extremely high (style consistency)
Security	High (front end is controlled)	High	Extremely high (environment isolation)	High	Extremely high (code execution prohibited)
Cross-platform compatibility	Weak (requires rewriting the front end)	Weak	Strong (web-first)	Weak (web-first)	Very strong (supports native/Web)

Key characteristic of Google A2UI: UI as structured data

Unlike Vercel, which sends React component fragments directly from the server (code), A2UI insists that the agent never sends code, only JSON descriptions.

• The agent outputs a flattened, streaming JSON set that describes the UI intent (for example,{type: "chart", data: [...]}). The client receives it and renders it using trusted local components preset on the device, such as Angular, Flutter, or Lit.

• This architecture, which separates data from rendering, completely eliminates the risk of malicious scripts generated by an LLM (XSS). It also ensures that the agent’s response can appear with exactly the same visual style on both mobile native apps and web pages.

The underlying logic of AG-UI is: “The agent is only responsible for thinking and decision-making; UI logic must stay on the front end.”

• Shared State mechanism: it establishes a real-time, bidirectional synchronized state object between the agent and the front end. The agent can modify state directly through instructions (for example,state.selectedItems = [...]), and once the front-end framework (React/Vue) detects the state change, it updates local components within milliseconds.

• Action System: front-end developers expose a set of “capability functions” (Actions) to the agent. The agent decides when to call them, but how they execute is entirely defined by the front-end code. This ensures the safety of business logic.

The underlying logic of MCP UI is: “UI should be standardized like an API. Wherever the agent goes, the UI follows.”

• UI as Resource: in the MCP protocol, UI is no longer prewritten front-end code, but a “resource” dynamically provided by the agent. The agent returns a URI through ui:// the protocol, for example ui://analytics-dashboard/v1.

• Host Agnostic: you write one MCP Server, and the UI it provides can be rendered directly in Claude Desktop, ChatGPT, Cursor, or even your own app, without rewriting the front end for each platform. (iframe)

III. The path to Agentic Coding: from model to framework——Cui Zeyu (Mayou), Luo Changwei (Shanguo)

Alibaba has many different AI coding tools, with different teams building their own. It really feels like front-end development ten years ago.

I only listened to two sessions, Qoder and Qwen-Code. Qwen-Code was more interesting — a fork of Gemini CLI,https://github.com/QwenLM/qwen-code.

I only noted down two points; the rest was mostly an introduction. If you’re interested, you can read the repo or try it yourself.

The reason coding matters comes down to this: it is a task scenario with high verifiability. In many tasks, generating content is easy, but verifying correctness is difficult, such as writing articles or making subjective judgments. Coding is the opposite: generation is relatively hard, but results can be quickly verified through compilation, test cases, evaluation systems, and similar methods. This combination — hard to generate but easy to verify — makes coding the ideal optimization target for AI, and it also explains why task value is strongly tied to verifiability.

The core path to improving a model’s coding ability is “three kinds of scaling”: first, data scale, meaning a large volume of code data; second, context scale, meaning support for repo-level and long-horizon understanding, such as 256K context; and third, high-quality data, meaning continuously improving training quality through synthetic data. Together, these three allow the model to keep evolving within a closed loop of verifiable feedback, leading to a qualitative breakthrough in complex engineering tasks.

IV.From context engineering to harness engineering——Zhou Xiao

Among the many speakers, Zhou Xiao stood out for his technical insight, analyzing the problem calmly from first principles.

ByteDance’s Web Infra official account published the transcript,https://mp.weixin.qq.com/s/ERSjcq9YURHvlsdTUv_Paw.

Summary:

AI coding has improved the efficiency of “writing code” by an order of magnitude, but delivery has not sped up, because coding only accounts for 30% of the work. The remaining 70% is testing, troubleshooting, release, and communication. Optimizing only code writing is a classic local optimum: more code means more validation pressure, and people end up more exhausted.

Zhou Xiao builds on the “physical reality” of Transformer autoregression, KV Cache, Prompt Cache, and ReAct: the longer the context, the more expensive prefill becomes, the more diluted attention gets, and the more hallucinations appear; appends are cheap, but mid-stream modifications are expensive. So the essence of context engineering is to protect prefix stability and design prompt structure carefully, rather than blindly stuffing in more information; compress long conversation processes into snapshots/AGENTS.md and offload them to filesystem storage instead of forcing everything into context.

Under this premise, the engineer’s role must shift from “the person who writes code” to “the person who designs the environment and tools”: build a toolchain for the agent that is readable, low-latency, structured in its output, and equipped with pain-point feedback. Traditional human-facing GUIs, logs, and charts are mostly noise to an agent; good tools should be APIs for agents. MCP provides atomic actions, Skills package mature practices into SOPs that can be loaded on demand, and Sub Agents break long tasks into multiple isolated sandboxes that communicate through structured summaries, preventing entropy from spiraling out of control in a single context.

In the closed loop, we should not stop at “the AI writes code and I review it.” Instead, let the agent connect to LSP, testing, and sandbox CLI, prove correctness on its own, then package the change scope, screenshots, and test plan into a report. Humans should review the deliverables, not track every step it took. Spec/Plan, human-machine collaboration, and when to AskUser are all about reducing pointless trial and error and keeping human attention on defining goals and reviewing results.

The core conclusion of the whole piece is this: a model is a function bound by physical constraints, not magic. Once you understand those constraints, an engineer’s real moat is not who writes more lines of code, but who can design a better Harness — one that lets a group of agents and a small number of humans form a controllable, verifiable, and scalable engineering system within limited context and tool capacity.