The evolution of dev tools partnership
We're delegating entire workflows.
Team proof points
Everyone contributes code
Everyone is a builder.
The agentic workflow
with the model
software with agents
Plan
/research
Deep, exhaustive understanding — before you write a line of code
Dedicated research agent
Activates a specialized agent that explores your codebase, GitHub projects, and the web — produces a comprehensive Markdown report with citations
Saved artifacts
Reports are saved to your session — share via /share gist research or open in your editor with Ctrl+Y
Thorough, not fast
Designed for exhaustive reporting — architectural diagrams, code references, and cross-module analysis
Sources everything
Pulls from your code, relevant GitHub repos, docs, and the web — always with citations
/plan
Collaborate with the model on a structured plan before any code is generated
Collaborative planning
Copilot analyzes your request, asks clarifying questions, and builds a step-by-step implementation plan — you review and approve before work begins
Scope alignment
Outlines steps, key decisions, dependencies, and alternatives — prevents misunderstandings before they become expensive rework
Structured output
Generates a plan.md with todos, dependencies, and considerations — the blueprint for autopilot execution
Approve before building
Review, edit, or reject the plan — once accepted, Copilot executes with confidence
Clarify intent with the model
Asking questions generates chain-of-thought reasoning and leads to better results
Scope boundaries
"Should this handle both REST and GraphQL endpoints?"
Design decisions
"Redis cache vs. in-memory? This affects the deployment story."
Edge cases
"What happens when the session expires mid-request?"
Better reasoning
Each question forces the model to think deeper — refining its plan before acting
Build
Fleet mode
Break a complex task into parallel subtasks — each managed by its own agent
Auth module
API routes
Test suite
🚀 Parallel execution
Each subagent gets its own isolated context window — no interference, no overlap
📊 Monitor with /tasks
Track progress across all active subagents — pause, reprioritize, or kill as needed
Autopilot mode
Maximum autonomy — the agent drives, you review the result
Auto-approves tool calls
No confirmation dialogs — the agent runs commands, edits files, and retries on errors automatically
Plan → Execute → Verify
Structured todo tracking with dependency management — works through complex multi-step tasks
Self-correcting
Detects failures, reads error output, and tries alternative approaches — not blind retries
Goal-oriented
Keeps working until the task is done or it can't progress without your help
Sub-agents
Isolate context-heavy workflows — each invoked with custom prompts
Explore agent
Fast codebase research — launches parallel search threads with its own context window
Rubber duck agent
Independent critique — catches bugs, logic errors, and blind spots before you ship
Code review agent
Reviews diffs with high signal-to-noise — only surfaces what genuinely matters
Task agent
Runs builds, tests, lints in isolation — returns concise pass/fail summaries
Custom agents
Define your own with custom prompts — project-specific knowledge, tools, and workflows
Verification
Agents should self-validate their own work — not just write the code
It builds your app, runs it, navigates it, and confirms
the user goal is fulfilled — iterating until satisfied.
Scale
Worktrees
Every session gets its own isolated branch and workspace
main
feat/auth
fix/perf-bug
feat/dashboard
🔒 Isolated by default
Each session works in a git worktree — no conflicts between parallel tasks
🚀 Concurrent development
Run multiple sessions on the same repo without stepping on each other
Engineering systems
More PR throughput means your engineering system must be rock-solid
Tests
Unit, performance, E2E — agents generate more code, so your test coverage must scale with them
Builds
Optimized for time — fast CI is the difference between agents shipping in minutes vs. hours
Code review
Human review does not scale — use AI-assisted review to maintain quality at higher throughput
Artifacts
Keep in sync with AI — documentation, product pages, and specs should update alongside code
Issues
Too many to manually triage — you need an AI triage strategy to keep up with volume
Discover
What's next?
Your primary constraint becomes determining what to build next.
Collapsed delivery lifecycles
Features that took weeks now ship in hours — planning and taste become the bottleneck, not execution
More agents than ever to manage
You become the orchestrator — directing, reviewing, and steering a fleet of specialized agents
Multi-model flexibility
Choose the right model for the task — Claude, GPT, Gemini — swap mid-session
VS Code ↔ CLI convergence
Same agent capabilities whether you're in the editor or terminal