Microsoft Build 2026 Day 2 LIVE | GitHub Copilot, VS Code, and more

Key Concepts

• GitHub Copilot App: An agent-native desktop experience designed for outcome-focused development, allowing users to manage multiple agents and workflows outside of a traditional code editor.
• Agent Skills: A standardized, reusable way to package expertise, instructions, and workflows for AI agents, mapping to the Software Development Lifecycle (SDLC).
• GitHub Copilot SDK: A stable (GA) toolkit available in multiple languages (Node, Python, Go, .NET, Rust, Java) that allows developers to integrate the Copilot agent runtime into custom applications.
• Phi-3.5/Code Flash: Microsoft’s first coding-specific model built from scratch, optimized for speed, efficiency, and agent trajectories within the GitHub Copilot ecosystem.
• TypeScript Native (TS Go): A rewrite of the TypeScript compiler in Go, offering up to 10x faster build times and multi-core utilization.
• Foundry Toolbox: A governance and management layer for agents that handles authentication, tool routing, and token optimization across various tool protocols (MCP, OpenAPI, etc.).
• Agent Window: A dedicated VS Code interface for managing multiple agent sessions across different workspaces and remote environments.

---

1. GitHub Copilot Ecosystem & Tools

• GitHub Copilot App: Unlike an editor or CLI, this is a desktop experience focused on "outcome-focused" work. It allows users to background code and focus on results (e.g., checking if a feature works). It is recommended to run 3–4 agents simultaneously to avoid losing track of tasks.
• GitHub Copilot CLI: Now supports multi-session management via slash new and slash sessions. It features "YOLO mode" (bypassing approvals) and voice-to-text prompting via the VS Code Speech extension.
• SDK & Performance: The SDK runtime is being rewritten in Rust to reduce memory footprint from ~120MB to sub-10MB, significantly improving performance for native applications.

2. Agent Skills & Frameworks

• Methodology: Agent skills act as a "bag of magic tricks" or dotfiles for AI. They follow a pattern: Overview, Rationalization (why/why not use), Red Flags, and Verification.
• SDLC Mapping: Skills are categorized by SDLC phases: Define, Plan, Build, Verify, Review, and Ship.
• Implementation: Skills are loaded on-demand to save tokens. Users can use "Refine" to turn vague ideas into concrete specs, "Plan" to break down tasks, and "Verify" to run automated tests (e.g., Playwright).

3. Model Optimization & Governance

• Phi-3.5/Code Flash: A 137B parameter model (5B active parameters via Mixture of Experts) trained specifically on GitHub Copilot agent trajectories. It features "adaptive solution length" training to prevent unnecessary verbosity.
• Foundry Toolbox: Solves the "context bloat" problem. Instead of exposing 50+ tools to an LLM, Toolbox uses a "Tool Search" (BM25 algorithm) to expose only the two most relevant meta-tools, significantly reducing token usage and cost.
• Governance: Toolbox allows for centralized application of guardrails, ensuring security policies are applied consistently across all agent tool invocations.

4. TypeScript Compiler Rewrite

• The Problem: The original TypeScript compiler was self-hosted in JavaScript, which is single-threaded and memory-intensive, leaving ~97% of modern CPU power unused.
• The Solution: Porting the compiler to Go allows for shared-memory parallelism.
• Results: A 10x speed improvement in non-incremental builds (e.g., reducing a 97-second build to 10 seconds). It is currently available as a native preview extension.

5. Developer Workflow & Best Practices

• Multi-Model Strategy: Use smaller, cheaper models (e.g., Flash) for planning and larger, more capable models (e.g., Opus/GPT-5.5) for implementation and code review.
• Deterministic Gates: There is a strong industry push for "deterministic gates" in AI coding—automated checks for security and quality that prevent agents from pushing vulnerable code.
• Voice Mode: Encouraged as a way to "pace and think" while prompting, effectively acting as a modern dictation tool for complex agent tasks.

Synthesis/Conclusion

The development landscape is shifting from "writing code" to "building agentic workflows." The core takeaway is that developers should stop treating AI as a simple code-completion tool and start treating it as a system to be architected. By utilizing Agent Skills for reusable logic, Foundry Toolbox for governance, and native-compiled tools (like the new TypeScript compiler), developers can achieve significantly higher productivity while maintaining quality and security. The focus is moving toward "outcome-focused" development, where the human's role is to define the intent, verify the output, and manage the orchestration of multiple specialized agents.