Developer Productivity

AI-Powered Development

Master VS Code Insider with GitHub Copilot Agent Mode

Learn to configure professional AI development environments with Claude Sonnet 4, MCP servers, and advanced prompting techniques that separate expert developers from basic prompt engineers.

Download VS Code Insider

VS Code Insider Edition

Essential for agentic development capabilities

Why VS Code Insider is Critical

Standard VS Code has limited agentic development features

Standard VS Code Limitations

Limited GitHub Copilot Agent mode features
Restricted MCP server integration
Delayed AI feature releases (3-6 months behind)
Basic chat interface with limited context
No advanced workspace understanding
Missing experimental AI capabilities

Insider Edition Benefits

Full GitHub Copilot Agent mode capabilities
Complete MCP server support
Latest AI features on day one
Advanced workspace context understanding
Multi-step task execution and planning
Access to experimental AI models

Installation Steps:

Download VS Code Insider from the official website
Install alongside your existing VS Code (they run independently)
Install GitHub Copilot extension in Insider
Enable Agent mode in Copilot settings
Configure MCP servers for database integration

Download Insider Agent Mode Docs

Meet GitHub Copilot

Your AI pair programmer that writes, reviews, and optimizes code with you

Agent Mode

Delegate complex tasks and let Copilot analyze, propose edits, run tests, and validate results across multiple files.

Multiple Models

Switch between GPT-5, Claude Sonnet 4, Gemini 2.5 Pro, and more to get the best results for any coding task.

Code Review

Automatic code analysis that uncovers bugs, suggests improvements, and ensures quality before human review.

Free

Get started with GitHub Copilot

50 agent mode requests/month
2,000 code completions/month
Access to Claude Sonnet 3.5, GPT-4.1

Get Started Free

RECOMMENDED

Pro

Setup Steps:

1Sign up for GitHub Copilot (30-day free trial)

2Install the GitHub Copilot extension in VS Code

3Sign in to your GitHub account in VS Code

4Accept the Copilot suggestions and start coding!

Key Benefits:

Write code 55% faster with AI suggestions
Get context-aware code completions
Automatic code review and bug detection
Support for 70+ programming languages

Start Free Trial Install VS Code Extension

Why Claude Sonnet 4 is Critical

Free models are insufficient for professional development

Claude Sonnet 4

Recommended

Cost

$3.00/M input, $15.00/M output (from $10/month plan with 30-day free trial via GitHub Copilot. For light use, this is sufficient. Heavy development (8-10 hours × 5 days/week) may require $39/month plan)

Capabilities

Exceptional coding, complex reasoning, 72.7% SWE-bench

Assessment

State-of-the-art performance for professional development

Claude 3.5 Sonnet (Free)

Cost

Free with GitHub Copilot

Capabilities

Basic coding, limited context, simple tasks only

Assessment

Insufficient for complex agentic development workflows

GPT-4.1 / GPT-5 Mini

Cost

$1.25/M input, $10.00/M output (Available free unlimited in GitHub Copilot)

Capabilities

Good for simple tasks, moderate reasoning

Assessment

Acceptable for basic development, not for complex systems

Critical Investment Decision

The difference between Claude 3.5 (free) and Claude Sonnet 4 is not incremental—it's transformational. Claude Sonnet 4 achieves 72.7% on SWE-bench, making it capable of handling complex, multi-step development tasks that would be impossible with free models.

Professional developers understand: The cost of Claude Sonnet 4 ($3-15/M tokens) is negligible compared to the productivity gains and quality improvements it provides. Free models will limit your capabilities and waste your time on complex projects.

MCP Server Configuration

Connect to MCP servers with natural language commands

Explore MCP Server Registry

Discover and install powerful MCP servers from the official registry

Official MCP Registry

The GitHub MCP Registry contains 40+ official MCP servers from major platforms like GitHub, Microsoft, Azure, MongoDB, Stripe, and more. These servers enable AI agents to interact with real-world APIs and services.

Visit MCP Registry

Recommended MCP Servers for GitHub Copilot

Essential Servers:

GitHub - Official GitHub integration (22K+ stars)
Azure - Azure cloud services integration
Microsoft Learn - Official Microsoft documentation
Playwright - Web browser automation

Popular Tools:

Notion - Notion workspace integration
MongoDB - Database operations
Stripe - Payment processing
Elasticsearch - Search and analytics

Installation Process

1. Browse the Registry:

Visit github.com/mcp to explore all available serversgithub.com/mcp

2. Choose Your Server:

Click on any MCP server to see detailed installation instructions and capabilities

3. One-Click Install:

Most servers provide an "Install" button for easy integration with GitHub Copilot

4. Configure in VS Code:

Add the server configuration to your .vscode/mcp.json file

GitHub MCP Server Spotlight

The GitHub MCP Server is the most popular server (22K+ stars) that enables AI agents to:

Read and analyze GitHub repositories
Manage issues and pull requests
Search code across repositories
Automate GitHub workflows
Access repository metadata and statistics

Install GitHub Server

.vscode/mcp.json Configuration

Step-by-step setup of MCP servers in VS Code Insider

Complete Setup Instructions

1Create Project Folder

Create a new folder on your system (e.g., "aiagents") where you'll test MCP functionality

2Open VS Code Insider

Launch Visual Studio Code Insider (not regular VS Code)

3Open Your Folder

File → Open Folder → Select your "aiagents" folder

4Create MCP Configuration

Create a new file: .vscode/mcp.json

MCP Configuration File

Create this file in your project's .vscode directory

.vscode/mcp.json

.vscode/mcp.json

5Add Roll Dice Configuration

Paste the Roll Dice JSON configuration into your mcp.json file and save

6Start MCP Server

After saving, you'll see a "Start" button appear in the JSON file - click it to activate the MCP server

Security Best Practices

Never hardcode API keys in mcp.json
Use environment variables with ${} syntax
Add .env to .gitignore
Use read-only tokens when possible
Review all AI-generated database operations before execution

Roll Dice MCP Server Configuration:

Roll Dice MCP Server

Simple Setup: This is a demo MCP server that requires no authentication. Perfect for testing MCP functionality in VS Code without complex setup.

Roll Dice MCP Server Configuration

Complete MCP server configuration for VS Code

.vscode/mcp.json

{
  "servers": {
    "rolldice": {
      "type": "http",
      "url": "https://rolldice.ausbizconsulting.com.au/api/mcp"
    }
  }
}

Natural Language Commands You Can Use:

Roll Dice MCP Server:

"Roll a 6-sided die"
"Roll two d20 dice"
"Roll 3d6 for ability scores"
"Roll a d100 for percentile"
"Roll 4d6 and drop the lowest"
"Roll dice for damage: 2d8+3"

Testing Your MCP Setup

1. Open GitHub Copilot Chat:

Make sure you're in Agent mode and using an agentic LLM (GPT-4.1 or Claude Sonnet 4)

2. Test with a simple command:

Test MCP Integration

Simple command to test if MCP server is working

chat-command

use roll dice mcp tool to roll dice of 6

3. Expected Result:

The AI should use the MCP tool to roll a 6-sided die and return the result

Important: Ensure you're using Claude Sonnet 4 or GPT-4.1 in Agent mode for optimal MCP integration

Test Roll Dice Server MCP Protocol Docs

Advanced Prompting Best Practices

Design-first approach vs. prompt-to-code

Professional vs. Amateur Approach

The difference between expert developers and prompt engineers

Amateur: Prompt-to-Code

Direct "build me X" requests
No architectural planning
Immediate code generation
Frequent refactoring needed
Security and scalability afterthoughts
Inconsistent patterns

Professional: Design-First

Comprehensive technical documentation
Architecture and system design
Security and performance planning
Stakeholder requirement gathering
Implementation roadmap
Consistent, maintainable code

Why Design-First Approach Works:

Better Planning:

Identifies edge cases early
Prevents architectural debt
Ensures scalability

Higher Quality:

Consistent code patterns
Built-in security measures
Performance optimization

Faster Development:

Less refactoring needed
Clear implementation path
Reduced debugging time

Advanced Prompt Template

Professional technical documentation prompt

Professional Technical Documentation Prompt

Advanced prompt template for comprehensive project planning

prompt-template.txt

Create a comprehensive technical design document for [YOUR_PROJECT_DESCRIPTION] before writing any code.

Please include the following sections in your analysis:

## 1. Architecture Overview
- System components and their relationships
- Data flow diagrams
- Technology stack recommendations
- Scalability considerations

## 2. Database Design
- Entity relationship diagrams
- Table schemas with proper indexing
- Data migration strategies
- Performance optimization plans

## 3. API Design
- RESTful endpoint specifications
- Request/response schemas
- Authentication and authorization flows
- Rate limiting and security measures

## 4. Frontend Architecture
- Component hierarchy and state management
- User experience flow
- Responsive design considerations
- Performance optimization strategies

## 5. Security Considerations
- Authentication mechanisms
- Data validation and sanitization
- CORS and security headers
- Vulnerability assessment

## 6. Testing Strategy
- Unit testing approach
- Integration testing plans
- End-to-end testing scenarios
- Performance testing requirements

## 7. Deployment Strategy
- Environment configurations
- CI/CD pipeline design
- Monitoring and logging setup
- Rollback procedures

## 8. Questions for Clarification
Please ask me specific questions about:
- Business requirements and constraints
- Performance expectations
- Security requirements
- Integration needs
- Timeline and resource constraints

After we finalize the design document, we can proceed with implementation. This approach ensures we build a robust, scalable solution that meets all requirements.

Advanced Prompting Techniques:

1. Context Layering:

Provide business context, technical constraints, and success criteria upfront.

2. Iterative Refinement:

Ask follow-up questions to clarify requirements before implementation.

3. Constraint Definition:

Specify performance, security, and scalability requirements explicitly.

4. Stakeholder Perspective:

Consider different user roles and their specific needs in the design.

Example Workflow:

1Submit comprehensive design prompt

2Review and refine technical documentation

3Answer clarification questions

4Approve final design document

5Begin implementation with clear roadmap

VS Code Performance Optimization

Essential tips for systems without dedicated GPU/limited RAM

GPU Acceleration & Memory Management

VS Code Insider uses ~500MB RAM for GPU acceleration - optimize for integrated graphics

Integrated Graphics Impact

VS Code Insider GPU process: ~225-500MB RAM usage
Integrated graphics share system RAM (no dedicated VRAM)
High CPU usage in GPU process indicates inefficient rendering
Memory competition between CPU and integrated GPU
Trade-off: Smooth transitions vs. overall system performance

Performance Issues

High memory pressure (>85% RAM usage)
GPU process consuming excessive CPU time
Thermal throttling from integrated graphics load
Reduced multitasking capability

Optimization Benefits

200-500MB RAM savings
Reduced CPU usage and heat generation
Better system responsiveness
Improved battery life on laptops

VS Code Settings Optimization:

VS Code Performance Settings

Optimized settings to reduce GPU and memory usage

settings.json

{
  "disable-hardware-acceleration": true,
  "editor.experimentalWhitespaceRendering": "off",
  "terminal.integrated.gpuAcceleration": "off",
  "editor.smoothScrolling": false,
  "workbench.list.smoothScrolling": false,
  "editor.cursorSmoothCaretAnimation": "off"
}

Extension & Process Management

Monitor and optimize VS Code processes and extensions

Common Memory Consumers:

Heavy Extensions:

PowerShell: ~301MB (language server)
Python/Pylance: ~100MB (IntelliSense)
Live Share: ~25MB (collaboration)
Language servers for unused languages

Process Issues:

Multiple VS Code windows (80MB each)
Extension Host process (200-500MB)
Renderer processes (100-400MB each)
Background utility processes

Optimization Strategies:

1. Extension Audit (Save 200-400MB)

Disable language extensions for unused languages
Use workspace-specific extension profiles
Enable extensions only when needed
Remove duplicate functionality extensions

2. Window Management (Save 80-240MB)

Use VS Code workspaces instead of multiple windows
Close unused editor tabs regularly
Limit concurrent VS Code instances
Use split editors instead of new windows

3. Terminal Optimization

Consider Git Bash over PowerShell for general development:

Git Bash Terminal Configuration

Configure Git Bash as the default terminal to save memory

settings.json

{
  "terminal.integrated.defaultProfile.windows": "Git Bash",
  "terminal.integrated.profiles.windows": {
    "Git Bash": {
      "path": "C:\\\\Program Files\\\\Git\\\\bin\\\\bash.exe",
      "args": [
        "--login"
      ]
    }
  }
}

Git Bash uses ~5-10MB vs PowerShell extension's ~301MB overhead

Expected Performance Gains:

Memory Savings:

GPU acceleration: 200-500MB
Extension optimization: 200-400MB
Process management: 80-240MB
Total: 480-1140MB saved

Performance:

Faster startup times
More responsive editing
Better multitasking
Reduced system heat

System Impact:

Lower CPU usage
Improved battery life
More RAM for other apps
Reduced thermal throttling

Monitoring Commands (Windows)

Check VS Code memory usage

Check VS Code memory usage:

powershell

Get-Process -Name "Code" | Select-Object ProcessName, WorkingSet, CPU

Monitor system memory

Monitor system memory:

powershell

Get-WmiObject -Class Win32_OperatingSystem | Select-Object TotalVisibleMemorySize, FreePhysicalMemory

Ready for Professional AI Development! 🚀

You now have the tools and knowledge to build production-ready applications with AI assistance:

VS Code Insider with Agent mode
Claude Sonnet 4 for complex reasoning
MCP servers for database integration
Design-first development approach
Professional prompting techniques

Try Advanced RAG Workshop Back to Main Workshop