VSCode Team Introduces the Five Pillars of Agent-First Development

1. Model – Choosing Depth of Thinking

The model isn’t about “bigger is better” – it’s about “matching the task.”

Copilot offers four levels of thinking depth: Low / Medium / High / Auto

• Low: Mechanical tasks like completion, renaming, formatting – prioritize latency
• Medium: Regular feature development – balance speed and quality
• High: Architecture design, complex bugs, cross-file refactoring – better to be slow and correct
• Auto: Let the system automatically dispatch based on task complexity

The real insight: depth of thinking comes at a cost (time, tokens, user patience). Mature Agent-First users actively “choose the gear” for the task, rather than defaulting to High all the time.

2. Harness – The Action Boundary of the Agent

Harness refers to the runtime environment that defines what the Agent can and cannot do. The Copilot Chat panel is the harness – it determines whether the Agent just “talks” or actually “executes.”

Three modes form a progressive ladder of trust:

• Ask: Conversation only, no file changes – explore, ask questions, learn code
• Plan: List steps, wait for your approval – discuss approaches, high-risk changes
• Agent: Autonomously plan, execute, iterate – well-defined goals that need delivery

Key insight: The progression from Ask → Plan → Agent is a transfer of control from “I lead” to “it leads.” Jumping straight into Agent mode on vague tasks is like letting someone who doesn’t know the situation make decisions for you – loss of control is inevitable.

3. Context – The Agent’s Field of View

The model itself doesn’t know your codebase. Context is the prerequisite for it to do things right.

Copilot acquires context in two ways:

• Automatic: Search workspace, read relevant files
• Manual (more reliable): Explicitly specify with #codebase, #file, #fetch

This is the most underestimated pillar. Most cases of “the Agent messed up the code” stem not from a bad model, but from the Agent never seeing the key file and starting to guess. Providing context explicitly isn’t redundancy – it’s a control variable.

4. Prompt – Precision of Intent

Prompt = Goal + Constraints + Acceptance Criteria.

“Help me add a login feature” vs. “Implement email login using the existing SessionService in the auth/ directory, reuse the LoginForm component, use toast for error messages, and do not introduce new dependencies” – the results are completely different.

Professional users’ prompts typically include:

• What to do (goal)
• Where to do it (scope)
• What not to do (constraints)
• How to define “done” (acceptance)

Vague input only yields generic output.

5. Tools – The Agent’s Hands

Tools are the capabilities the Agent can actually invoke: read files, run commands, search, call APIs, run tests…

More tools mean more power, but also a larger blast radius. The discipline of Agent-First is:

• Give it the tools it needs, and not the ones it doesn’t
• Dangerous operations (delete database, push to main, change production config) should require explicit approval
• The toolchain must be observable – what commands the Agent ran, what files it changed – must be visible and revertible

Overall Framework: Five Dials, Not Five Steps

Poor result = f(Model gear wrong × Harness mode wrong × Context missing × Prompt vague × Tools insufficient or excessive)

The essence of Agent-First Development is acknowledging one thing: The entity writing code is shifting from “human + editor” to “human + Agent + editor.” The human role evolves from “typist” to “model selector, context provider, intent definer, boundary setter.”

VS Code Learn Series Videos
https://youtube.com/playlist?list=PLj6YeMhvp2S4l1_iP4-pS6p7lgyqKo-Ix

@shao__meng: VSCode Team Introduces the Five Pillars of Agent-First Development

1. Model – Choosing Depth of Thinking
   The model isn’t about “bigger is better” – it’s about “matching the task.”
   Copilot offers Low / Medium / High / Auto…
   Channel: @shao__meng
   Source: https://www.youtube.com/playlist?list=PLj6YeMhvp2S4l1_iP4-pS6p7lgyqKo-Ix

Microsoft Developer (@msdev):
The @code team released a new Introduction to Agent-First Development series.

It breaks down these 5 pillars behind great agent results 🧵