Skip to main content
Mapagam

41 SECTIONS · 908 TOPICS

Ai Assisted Development Roadmap

  1. Comparing Major AI Coding Agents

    1. 1. Comparing GitHub Copilot and Claude Code
    2. Example: GitHub Copilot Usage
    3. Example: Claude Code Usage
    4. 2. Comparing Cursor and Windsurf
    5. Key Differences Summary
    6. Example: Inline Suggestion in Cursor
    7. Example: Refactoring in Windsurf
    8. 3. Comparing Amazon Q Developer and Gemini Code Assist
    9. Example: Code Generation
    10. Comparison Summary
    11. 4. Comparing JetBrains AI Assistant and Codeium
    12. Example: Code Completion in JetBrains AI Assistant
    13. Example: Code Completion in Codeium
    14. Key Differences Summary
    15. 5. Comparing Aider and Cline as CLI-Based Agents
    16. Example: Aider CLI Usage
    17. Example: Cline CLI Usage
    18. Key Differences Summary
    19. 6. Understanding Agent Pricing Tiers
    20. 7. Understanding Context Window Sizes Across Agents
    21. 8. Understanding Underlying Model Providers
    22. 9. Choosing an Agent by IDE Integration
    23. IDE Integration Comparison
    24. Example: Setting up GitHub Copilot in VS Code
    25. 10. Choosing an Agent by Team Size
    26. Comparison Summary
    27. 11. Migrating Between AI Coding Agents
    28. Migration Workflow
    29. Agent Migration Considerations
    30. 12. Running Multiple Agents in Parallel
    31. Example: Configuring Parallel Agent Execution
    32. Best Practices for Parallel Execution

  2. Installing and Configuring GitHub Copilot

    1. 1. Installing Copilot Extension in VS Code
    2. Example: Enabling Copilot in VS Code
    3. 2. Installing Copilot in JetBrains IDEs
    4. Example: Enabling Copilot in IntelliJ IDEA
    5. 3. Signing In with a GitHub Account
    6. Example: GitHub Copilot Login Flow
    7. Authentication Requirements
    8. 4. Activating Copilot Individual Plan
    9. Example: Activating Copilot on GitHub
    10. 5. Activating Copilot Business Plan
    11. Example: Enabling Copilot via GitHub UI
    12. 6. Activating Copilot Enterprise Plan
    13. Example: Enabling Copilot via API
    14. 7. Configuring Copilot Settings
    15. Example: Copilot Settings Configuration
    16. 8. Selecting Copilot Model Backend
    17. Example: Setting Copilot Model Backend
    18. 9. Managing Copilot Seat Licenses
    19. Example: Assigning a Copilot License to a User
    20. Managing Copilot Licenses Summary
    21. 10. Troubleshooting Copilot Sign-In Issues
    22. 11. Disabling Copilot for Specific Languages
    23. Example: Disabling Copilot for Python

  3. Using GitHub Copilot Chat Modes

    1. 1. Using Ask Mode
    2. Example: Asking for Code Explanation
    3. Example: Requesting a Code Fix
    4. 2. Using Edit Mode
    5. Example: Adding Error Handling
    6. 3. Using Agent Mode
    7. Example: Configuring Agent Mode in GitHub Copilot
    8. Agent Mode Capabilities
    9. 4. Switching Between Chat Modes
    10. Example: Switching Chat Modes in GitHub Copilot
    11. 5. Using Inline Chat
    12. Example: Using Inline Chat in VS Code
    13. Key Benefits of Inline Chat
    14. 6. Referencing Files with # Syntax
    15. Example: Referencing a File
    16. Example: Referencing a Line Range
    17. 7. Referencing Symbols with @ Syntax
    18. Example: Using @ to reference a function
    19. 8. Using #selection and #editor Variables
    20. Example: Using #selection to generate documentation
    21. Example: Using #editor to refactor code
    22. 9. Reviewing Chat History
    23. Example: Exporting Chat History
    24. 10. Exporting Chat Sessions
    25. Example: Exporting a Chat Session
    26. 11. Configuring Chat Response Length
    27. Example: Setting Response Length
    28. 12. Creating Custom Chat Modes with .chatmode.md
    29. Example: Creating a custom chat mode configuration
    30. Configuration Options

  4. Using GitHub Copilot Code Completions

    1. 1. Accepting Inline Suggestions
    2. Example: Accepting a Copilot Suggestion
    3. 2. Cycling Through Alternative Suggestions
    4. Example: Cycling Through Suggestions
    5. 3. Using Next Edit Suggestions
    6. Example: Using Next Edit Suggestions
    7. 4. Generating Code from Comments
    8. Example: Generating a Sorting Function
    9. Example: Filtering Even Numbers
    10. 5. Understanding Completion Ranking Factors
    11. 6. Configuring Suggestion Delay
    12. Example: Setting Suggestion Delay in VS Code
    13. 7. Enabling Multi-Line Completions
    14. Example: Enabling Multi-Line Completions in VS Code
    15. 8. Disabling Completions Temporarily
    16. Example: Disabling Copilot in VS Code
    17. 9. Using Ghost Text Navigation
    18. Example: Using Ghost Text Navigation
    19. 10. Understanding Fill-in-the-Middle Completions
    20. Example: Fill-in-the-Middle Completion

  5. Setting Up Claude Code

    1. 1. Installing Claude Code CLI
    2. Example: Verify Installation
    3. 2. Authenticating Claude Code with an API Key
    4. Example: Setting API Key in VS Code
    5. 3. Starting Claude Code Sessions
    6. Example: Starting a Claude Code Session
    7. Example: Listing Active Sessions
    8. Example: Stopping a Session
    9. 4. Configuring Claude Code Permissions
    10. Example: Setting up Claude Code Permissions in VS Code
    11. 5. Using Claude Code in Headless Mode
    12. Example: Running Claude Code in Headless Mode
    13. Headless Mode Configuration
    14. 6. Configuring Claude Code Model Selection
    15. Example: Claude Code Model Configuration
    16. 7. Using Claude Code Slash Commands
    17. Example: Using /explain
    18. Example: Using /fix
    19. 8. Resuming Previous Claude Code Sessions
    20. Example: Resuming a Session via CLI
    21. 9. Configuring Claude Code Output Styles
    22. Example: Setting Output Style to Block
    23. 10. Integrating Claude Code with Terminal Workflows
    24. Example: Setting up Claude Code in Terminal
    25. Integration Summary

  6. Using Claude Projects and Extended Thinking

    1. 1. Creating Claude Projects
    2. Example: Setting up a new Claude project
    3. 2. Uploading Project Knowledge Files
    4. Example: Uploading a Markdown Documentation File
    5. 3. Using Claude Extended Thinking Mode
    6. Example: Activating Extended Thinking Mode
    7. Extended Thinking Mode Capabilities
    8. Extended Thinking vs Standard Mode
    9. 4. Comparing Claude Opus, Sonnet, and Haiku
    10. Example: Model Selection
    11. Summary of Model Characteristics
    12. 5. Using Claude Artifacts for Code Preview
    13. Example: Creating a Claude Artifact
    14. Key Features of Claude Artifacts
    15. 6. Managing Claude Conversation Context
    16. Example: Setting Context Limits in Claude API
    17. Best Practices for Managing Conversation Context
    18. 7. Using Claude Computer Use Features
    19. Example: Using Computer Use Mode
    20. 8. Configuring Claude System Prompts
    21. Example: Setting System Prompt
    22. 9. Understanding Claude Context Window Limits
    23. Example: Token Estimation
    24. Managing Context Window Limits

  7. Configuring Cursor AI

    1. 1. Installing the Cursor Editor
    2. Example: Installing Cursor on macOS via Homebrew
    3. 2. Configuring Cursor Rules Files
    4. Example: Basic Cursor Rules Configuration
    5. Example: Advanced Rule with Replacement
    6. Configuration Tips
    7. 3. Using Cursor Tab Completion
    8. Example: Using Tab Completion
    9. Tab Completion Tips
    10. 4. Using Cursor Composer Mode
    11. Example: Using Natural Language to Generate Code
    12. 5. Using Cursor Chat with Codebase Context
    13. Example: Using Codebase Context in Cursor Chat
    14. Key Capabilities
    15. 6. Configuring Cursor Model Selection
    16. Example: Setting model in Cursor config
    17. 7. Using Cursor Background Agents
    18. Example: Enabling Code Review Agent
    19. 8. Managing Cursor Privacy Settings
    20. Example: Disabling Telemetry
    21. 9. Troubleshooting Cursor Indexing Issues
    22. Example: .cursorignore configuration

  8. Configuring Windsurf and Other AI Editors

    1. 1. Installing the Windsurf Editor
    2. Example: First-Time Setup
    3. 2. Using Windsurf Cascade Mode
    4. Example: Enabling Cascade Mode
    5. 3. Configuring Windsurf Rules Files
    6. Example: Basic Windsurf Rules Configuration
    7. Example: Advanced Rule with Custom Logic
    8. Rule Configuration Summary
    9. 4. Setting Up Amazon Q Developer
    10. Example: Installing Amazon Q in VS Code
    11. Example: Enabling Amazon Q in JetBrains IDEs
    12. 5. Setting Up Gemini Code Assist
    13. Example: AI Configuration in settings.json
    14. 6. Setting Up JetBrains AI Assistant
    15. Example: Enabling AI Assistant in IntelliJ IDEA
    16. 7. Setting Up Codeium
    17. Example: Codeium Configuration in VS Code
    18. 8. Comparing Editor-Native vs Extension-Based Agents
    19. Editor-Native Agents
    20. Extension-Based Agents
    21. Use Cases

  9. Setting Up Aider and Cline for CLI-Based Coding

    1. 1. Installing Aider via pip
    2. Example: Install Aider with default dependencies
    3. 2. Installing Cline as a VS Code Extension
    4. Example: Installing Cline in VS Code
    5. Installation Requirements
    6. 3. Configuring Aider Model Providers
    7. Example: Aider config with OpenAI
    8. 4. Configuring Cline Auto-Approval Settings
    9. Example: Basic Cline Configuration
    10. Auto-Approval Configuration Summary
    11. 5. Using Aider Chat Mode and Edit Mode
    12. Example: Aider Chat Mode Usage
    13. Example: Aider Edit Mode Command
    14. Key Differences Between Chat and Edit Mode
    15. 6. Using Cline Plan and Act Modes
    16. Example: Cline Plan Mode Workflow
    17. Example: Cline Act Mode Execution
    18. Plan and Act Workflow Summary
    19. Plan vs Act Mode Comparison
    20. 7. Managing Aider Git Auto-Commits
    21. Example: Configure Auto-Commits
    22. 8. Comparing Aider and Cline Workflows
    23. Workflow Comparison: Aider vs Cline
    24. Example: Aider CLI Usage
    25. Example: Cline CLI Usage

  10. Writing Custom Instructions Files

    1. 1. Creating a copilot-instructions.md File
    2. Example: Basic copilot-instructions.md
    3. 2. Structuring Instruction File Sections
    4. Example: Basic Instruction File Structure
    5. 3. Writing Coding Style Guidelines
    6. Example: Naming Convention
    7. Example: Code Formatting
    8. 4. Writing Project Context Guidelines
    9. Example: Project Overview
    10. Example: Technical Stack
    11. 5. Writing Testing Requirements
    12. Example: Test Requirement Configuration
    13. 6. Avoiding Instruction Conflicts
    14. Example: Prioritizing Instructions
    15. 7. Testing Instruction Effectiveness
    16. Example: Testing Consistency
    17. Testing Strategy Summary
    18. 8. Versioning Instruction Files
    19. Example: Basic Versioned Instruction File
    20. 9. Sharing Instructions Across Teams
    21. Example: Sharing Instructions in a Team
    22. Best Practices for Sharing Instructions
    23. 10. Combining Global and Local Instructions
    24. Example: Combining Global and Local Instructions
    25. How Instructions Are Merged

  11. Structuring AGENTS.md and CLAUDE.md Files

    1. 1. Understanding the AGENTS.md Standard
    2. Example: AGENTS.md Structure
    3. 2. Structuring CLAUDE.md Files
    4. Example: Basic CLAUDE.md Structure
    5. 3. Documenting Build and Test Commands
    6. Example: Defining Build and Test Commands in Package.json
    7. 4. Documenting Project Architecture
    8. Example: Project Structure Documentation
    9. Architecture Documentation Approaches
    10. 5. Documenting Code Conventions
    11. Example: JSDoc Usage
    12. 6. Referencing Related Documentation Files
    13. Example: Internal Link in Markdown
    14. Example: Image in Documentation
    15. 7. Placing Agent Files at Repository Root
    16. Example: .agent/claude.json
    17. 8. Using Nested Agent Files per Directory
    18. Example: Nested Agent Configuration
    19. Best Practices for Nested Agent Files
    20. 9. Synchronizing Agent Files Across Tools
    21. Example: Synchronizing .agent.json Files
    22. 10. Migrating Between Agent File Formats
    23. Agent File Format Comparison
    24. Migration Steps from AGENTS.md to CLAUDE.md
    25. Example: AGENTS.md to CLAUDE.md Migration

  12. Scoping Path-Specific Instructions

    1. 1. Using applyTo Glob Patterns
    2. Example: Applying AI instructions to JavaScript files only
    3. Example: Applying AI instructions to TypeScript files in a specific directory
    4. 2. Creating .instructions.md Files
    5. Example: Basic .instructions.md Structure
    6. 3. Scoping Instructions to File Types
    7. Example: JavaScript File Scoping
    8. 4. Scoping Instructions to Directories
    9. Example: Directory Scoping Configuration
    10. 5. Combining Path Patterns with Alternation
    11. Example: Combining Path Patterns with Alternation
    12. 6. Setting Instruction Priority Order
    13. Example: Configuring Priority Order
    14. 7. Excluding Files from Instructions
    15. Example: Exclude specific files from AI instructions
    16. 8. Debugging Instruction Matching Issues
    17. Example: Debugging Misaligned Instructions
    18. Debugging Steps

  13. Creating Reusable Prompt Files

    1. 1. Creating .prompt.md Files
    2. Example: Basic .prompt.md File
    3. 2. Defining Prompt Front Matter
    4. Example: Front Matter in YAML
    5. 3. Parameterizing Prompt Templates
    6. Example: Parameterized Prompt Template
    7. 4. Invoking Prompts with Slash Commands
    8. Example: Running a Prompt via Slash Command
    9. 5. Sharing Prompt Files Across Repositories
    10. Example: Using Git Submodules
    11. Example: Publishing to npm
    12. 6. Chaining Multiple Prompt Files
    13. Example: Chaining Prompt Files
    14. Example: Chaining Prompt Files (Continued)
    15. Best Practices for Chaining Prompts
    16. 7. Restricting Tools per Prompt File
    17. Example: Restricting Tools in a Prompt File
    18. 8. Testing Prompt File Outputs
    19. Example: Basic Output Validation
    20. Example: Unit Test with Mocha
    21. Testing Best Practices

  14. Using Slash Commands and Chat Participants

    1. 1. Using Built-In Slash Commands
    2. Example: Using /generate to create a React component
    3. Example: Using /explain to understand a function
    4. 2. Creating Custom Slash Commands
    5. Example: Define a slash command
    6. Example: Register slash command with AI agent
    7. 3. Using Chat Participants
    8. Example: Setting up a chat participant
    9. Key Features of Chat Participants
    10. 4. Registering Custom Chat Participants
    11. Example: Registering a Custom Chat Participant
    12. 5. Using Variables in Chat Commands
    13. Example: Using Variables in a Command
    14. 6. Chaining Slash Commands
    15. Example: Chaining Commands for Code Generation and Fixing
    16. 7. Discovering Available Commands
    17. Example: Using /help to explore commands

  15. Writing Effective Prompts for Coding Agents

    1. 1. Structuring Task-Oriented Prompts
    2. Example: Task-Oriented Prompt
    3. 2. Providing Relevant Context in Prompts
    4. Example: Prompt with Context
    5. 3. Using Few-Shot Examples in Prompts
    6. Example: Code Generation with Few-Shot
    7. Example: Task Completion with Few-Shot
    8. 4. Breaking Down Complex Tasks
    9. Workflow: Decomposing Complex Coding Problems
    10. Best Practices for Task Decomposition
    11. 5. Specifying Output Format Requirements
    12. Example: JSON Output Format
    13. Example: Markdown Output Format
    14. 6. Iterating on Prompt Refinements
    15. Example: Initial vs Refined Prompt
    16. Workflow: Prompt Iteration Process
    17. Key Tips for Prompt Refinement
    18. 7. Avoiding Ambiguous Instructions
    19. Example: Ambiguous vs. Clear Prompt
    20. 8. Using System Prompts Effectively
    21. Example: Effective System Prompt
    22. System Prompt vs User Prompt
    23. Best Practices for Crafting System Prompts
    24. 9. Handling Multi-Turn Prompt Context
    25. Example: Multi-Turn Prompt Flow
    26. Key Considerations for Multi-Turn Prompts

  16. Using Agent Mode for Autonomous Coding

    1. 1. Enabling Autonomous Agent Mode
    2. Example: Enabling Agent Mode in Configuration
    3. 2. Defining Task Scope for Agent Mode
    4. Example: Defining a Task Scope
    5. 3. Reviewing Agent-Proposed Changes
    6. Example: Reviewing and Approving Agent Changes
    7. Change Review Process
    8. 4. Approving Multi-File Edits
    9. Example: Approving Multi-File Changes
    10. Best Practices for Multi-File Edits
    11. 5. Configuring Auto-Approval Rules
    12. Example: Basic Auto-Approval Rule Configuration
    13. Example: Advanced Rule with Multiple Conditions
    14. 6. Setting Iteration and Turn Limits
    15. Example: Configuring Limits in AI Agent
    16. 7. Running Background Agents
    17. Example: Configuring a Background Agent
    18. Key Considerations
    19. 8. Canceling and Resuming Agent Tasks
    20. Example: Canceling and Resuming a Task

  17. Managing Agent Context Windows

    1. 1. Understanding Token Limits per Model
    2. Example: Calculating Token Usage
    3. 2. Managing Context Window Overflow
    4. Example: Context Truncation Strategy
    5. 3. Summarizing Long Conversations
    6. Example: Auto-summarize configuration
    7. Example: Manual summary trigger
    8. 4. Pruning Irrelevant Context
    9. Example: Pruning with LRU
    10. 5. Using File Attachments Efficiently
    11. Example: Attaching Files to Context
    12. Efficient File Attachment Tips
    13. 6. Understanding Context Caching
    14. Example: Memory Cache Implementation
    15. Example: Persistent Cache with File Storage
    16. 7. Optimizing Context for Cost
    17. Example: Reducing Context Size
    18. 8. Handling Context Truncation Errors
    19. Example: Sliding Window Implementation

  18. Using Workspace Indexing and Embeddings

    1. 1. Understanding Codebase Indexing
    2. Example: Indexing Configuration
    3. 2. Configuring Workspace Search Scope
    4. Example: Configure search scope in settings
    5. 3. Excluding Files from Indexing
    6. Example: .indexignore configuration
    7. 4. Using Semantic Code Search
    8. Example: Semantic Search Query
    9. Key Benefits
    10. 5. Refreshing Stale Indexes
    11. Example: Refreshing Workspace Index
    12. Example: Rebuilding Embedding Index
    13. 6. Understanding Embedding-Based Retrieval
    14. Example: Retrieving Similar Code Snippets
    15. 7. Troubleshooting Indexing Performance
    16. Example: Adjusting Indexing Settings
    17. 8. Indexing Large Monorepos
    18. Example: Configure monorepo indexing
    19. Indexing Strategy for Monorepos

  19. Managing Agent Memory and Sessions

    1. 1. Understanding Short-Term vs Long-Term Memory
    2. Example: Memory Management in AI Agents
    3. Key Differences Summary
    4. 2. Persisting Session State
    5. Example: Saving Session to LocalStorage
    6. Example: Loading Session from LocalStorage
    7. 3. Resuming Previous Sessions
    8. Example: Resuming Session
    9. Session Resumption Process
    10. 4. Storing User Preferences in Memory
    11. Example: Saving User Preferences
    12. Example: Loading User Preferences
    13. 5. Scoping Memory to Project vs User
    14. Example: Memory Scoping Configuration
    15. Key Considerations
    16. 6. Clearing and Resetting Memory
    17. Memory Management Best Practices
    18. 7. Debugging Memory Retrieval Issues
    19. Example: Logging Memory Access Patterns
    20. Common Debugging Steps
    21. 8. Organizing Memory Files by Topic
    22. Example: Memory File Organization

  20. Implementing Function Calling and Tool Use

    1. 1. Understanding Tool Calling Concepts
    2. Example: Tool Schema Definition
    3. 2. Defining Tool Schemas
    4. Example: Tool Schema Definition
    5. 3. Registering Custom Tools with Agents
    6. Example: Registering a Custom Tool
    7. 4. Handling Tool Call Responses
    8. Example: Processing Tool Call Response
    9. 5. Chaining Sequential Tool Calls
    10. Example: Chaining Tool Calls
    11. 6. Handling Tool Call Errors
    12. Example: Error Recovery Strategy
    13. Best Practices for Tool Call Error Handling
    14. 7. Restricting Tool Access by Permission
    15. Example: Configuring Tool Access by Permission
    16. 8. Testing Tool Call Reliability
    17. Example: Basic Reliability Test
    18. Reliability Testing Best Practices

  21. Understanding the Model Context Protocol

    1. 1. Understanding MCP Architecture
    2. Example: Basic MCP Server Configuration
    3. Key Features of MCP Architecture
    4. 2. Understanding MCP Clients and Servers
    5. Example: Basic MCP Client Initialization
    6. Example: MCP Server Setup
    7. Key Concepts
    8. 3. Understanding MCP Resources
    9. Example: Defining an MCP Resource
    10. 4. Understanding MCP Tools
    11. Example: Using mcp-tool to list available tools
    12. Example: Invoking a tool via mcp-tool
    13. 5. Understanding MCP Prompts
    14. Example: Basic MCP Prompt Structure
    15. Example: System Prompt for Context
    16. Key Points About MCP Prompts
    17. 6. Understanding MCP Transport Types
    18. Example: WebSocket Transport Setup
    19. 7. Understanding MCP Authentication
    20. Example: Bearer Token Authentication
    21. 8. Comparing MCP with Function Calling
    22. Key Differences Summary
    23. 9. Comparing MCP with the Agent-to-Agent (A2A) Protocol
    24. Key Differences Summary

  22. Setting Up MCP Servers

    1. 1. Installing Existing MCP Servers
    2. Example: Installing Python MCP Server
    3. 2. Configuring MCP Server Registry Files
    4. Example: Basic MCP Server Configuration
    5. 3. Building a Custom MCP Server
    6. Example: Basic MCP Server Setup
    7. Example: Registering a Custom Handler
    8. Key Steps to Build an MCP Server
    9. 4. Registering MCP Tools and Handlers
    10. Example: Registering a Tool
    11. Example: Registering a Handler
    12. 5. Testing MCP Servers Locally
    13. Example: Local MCP Server Test Setup
    14. Example: Testing with curl
    15. Example: Client Connection Test
    16. Testing Steps
    17. 6. Deploying Remote MCP Servers
    18. Example: Deploying an MCP Server with Node.js
    19. Deployment Checklist
    20. 7. Managing MCP Server Environment Variables
    21. Example: Setting Environment Variables
    22. 8. Securing MCP Server Credentials
    23. Example: Environment-Based API Key Usage
    24. Example: Secure Token Refresh Logic
    25. Key Security Practices

  23. Configuring MCP Tools and Resources

    1. 1. Enabling MCP Servers in IDE Settings
    2. Example: Enabling MCP in VS Code settings.json
    3. 2. Selecting Available MCP Tools per Session
    4. Example: Enabling a Tool in Session
    5. 3. Restricting MCP Tool Permissions
    6. Example: Setting Tool Permissions in MCP Config
    7. 4. Managing Multiple MCP Server Connections
    8. Example: Connecting to Multiple Servers
    9. Workflow: Switching Between Servers
    10. Server Management Summary
    11. 5. Debugging MCP Tool Call Failures
    12. Example: Logging Tool Call Errors
    13. 6. Monitoring MCP Server Logs
    14. Example: Configuring Log Level in MCP Server
    15. Log Level Summary
    16. 7. Versioning MCP Server Configurations
    17. Example: Versioned Configuration File
    18. 8. Disabling Unused MCP Servers
    19. Example: Disable MCP Server via Configuration

  24. Building Agent Skills

    1. 1. Understanding the Agent Skills Concept
    2. Example: Skill Interface Definition
    3. Key Characteristics
    4. 2. Creating SKILL.md Files
    5. Example: SKILL.md Template
    6. 3. Defining Skill Metadata and Descriptions
    7. Example: Skill Metadata Configuration
    8. 4. Structuring Skill Instructions
    9. Example: Goal Definition
    10. Example: Context Setup
    11. Example: Action Steps
    12. Example: Success Criteria
    13. 5. Referencing External Files from Skills
    14. Example: Importing a JSON Configuration File
    15. 6. Triggering Skills Automatically
    16. Example: Auto-triggered Code Review
    17. 7. Scoping Skills to Specific Domains
    18. Example: Domain-Specific Skill Configuration
    19. 8. Packaging and Sharing Skills
    20. Example: Package.json for an AI Skill
    21. Best Practices for Packaging AI Skills
    22. Package Formats for AI Skills
    23. 9. Debugging Skill Invocation
    24. Example: Logging Skill Invocation
    25. Debugging Checklist

  25. Implementing Sub-Agents

    1. 1. Understanding the Sub-Agent Concept
    2. Example: Sub-Agent Architecture Overview
    3. Core Benefits of Sub-Agent Systems
    4. 2. Creating Custom Sub-Agent Definitions
    5. Example: Defining a Custom Sub-Agent
    6. 3. Assigning Tools to Sub-Agents
    7. Example: Assigning tools to sub-agent
    8. Example: Using tool_call to integrate external API
    9. 4. Restricting Sub-Agent Model Selection
    10. Example: Model Restriction Configuration
    11. 5. Delegating Tasks to Sub-Agents
    12. Example: Delegating Code Generation
    13. Example: Delegating Test Execution
    14. 6. Running Sub-Agents in Parallel
    15. Example: Running Sub-Agents in Parallel
    16. Best Practices for Parallel Sub-Agent Execution
    17. 7. Aggregating Sub-Agent Results
    18. Example: Simple Result Aggregation
    19. Example: Summarizing Sub-Agent Outputs
    20. 8. Debugging Sub-Agent Failures
    21. Example: Logging Execution Errors
    22. Example: Validating Input Data
    23. Common Debugging Tools

  26. Orchestrating Multi-Agent Workflows

    1. 1. Designing Orchestrator-Worker Patterns
    2. Example: Basic Orchestrator-Worker Communication
    3. Key Considerations
    4. Orchestrator vs Worker Roles
    5. 2. Implementing Sequential Agent Pipelines
    6. Example: Sequential Pipeline Setup
    7. Example: DataCollector Agent
    8. Example: ModelRunner Agent
    9. 3. Implementing Parallel Agent Fan-Out
    10. Example: Fan-out Pattern with Concurrent Agents
    11. 4. Passing Context Between Agents
    12. Example: Agent Communication with Context
    13. 5. Handling Agent Handoffs
    14. Example: Contextual Handoff Implementation
    15. Best Practices for Agent Handoffs
    16. 6. Implementing Human-in-the-Loop Checkpoints
    17. Example: Configuring a Human Review Step
    18. 7. Managing Shared State Across Agents
    19. Example: Agent State Update via Redis
    20. 8. Resolving Conflicting Agent Outputs
    21. Example: Conflict Resolution via Voting

  27. Generating Code with AI Agents

    1. 1. Generating Boilerplate Code
    2. Example: React Component Generation
    3. Example: Spring Boot Controller
    4. Example: Node.js API Endpoint
    5. 2. Generating Functions from Descriptions
    6. Example: Generate a factorial function
    7. 3. Generating UI Code from Screenshots and Mockups
    8. Example: UI Code Generation from Figma Design
    9. Key Capabilities
    10. 4. Generating Unit Test Scaffolding
    11. Example: Test Generation
    12. Best Practices
    13. 5. Generating API Client Code
    14. Example: Generate JavaScript Client
    15. Example: Generated Client Usage
    16. 6. Generating Configuration Files
    17. Example: Generating a .env file
    18. 7. Generating Code Comments
    19. Example: AI-Generated Inline Comment
    20. Example: JSDoc Style Comment
    21. 8. Reviewing Generated Code for Correctness
    22. Example: Code Review Checklist
    23. Review Process Workflow
    24. Key Points to Consider
    25. 9. Regenerating Code with Refined Prompts
    26. Example: Refining a Prompt for Better Output
    27. Key Points About Prompt Refinement

  28. Refactoring Code with AI Agents

    1. 1. Requesting Function Extraction
    2. Example: Extracting a function from a large method
    3. 2. Requesting Code Simplification
    4. Example: Using AI to simplify a complex conditional
    5. 3. Renaming Symbols Across Files
    6. Example: Renaming a Variable Across Files
    7. 4. Migrating Code to New APIs
    8. Example: Migrating from old to new API
    9. 5. Converting Between Programming Languages
    10. Example: Converting Python to JavaScript
    11. Comparison of Conversion Tools
    12. 6. Applying Design Pattern Refactors
    13. Example: Strategy Pattern Refactor
    14. 7. Verifying Refactor Correctness
    15. Example: Unit Test Coverage Check
    16. Best Practices for Verification
    17. 8. Reverting Unwanted Refactors
    18. Example: Revert a refactoring in Git

  29. Debugging with AI Agents

    1. 1. Explaining Stack Traces
    2. Example: Stack Trace Analysis
    3. Key Points
    4. 2. Identifying Root Causes of Bugs
    5. Example: AI Agent Log Parsing
    6. 3. Suggesting Fix Candidates
    7. Example: Suggesting a Fix
    8. 4. Adding Debug Logging Automatically
    9. Example: Enabling AI Debug Logging
    10. 5. Reproducing Reported Issues
    11. Example: Debugging a Failing Test Case
    12. 6. Analyzing Runtime Error Patterns
    13. Example: AI Agent Runtime Error Detection
    14. Key AI Techniques for Error Analysis
    15. 7. Validating Bug Fixes with Tests
    16. Example: Unit Test for Bug Fix
    17. 8. Comparing Before and After Behavior
    18. Example: AI-Driven Debugging Workflow

  30. Generating Tests with AI Agents

    1. 1. Generating Unit Tests from Code
    2. Example: AI-Generated Unit Test
    3. Key Benefits
    4. 2. Generating Edge Case Tests
    5. Edge Case Test Generation Strategy
    6. 3. Generating Integration Tests
    7. Example: AI Integration Test Generation
    8. Best Practices for AI-Generated Integration Tests
    9. 4. Generating Mock Data and Fixtures
    10. Example: Generating User Mock Data
    11. Example: Creating Fixture from Template
    12. 5. Improving Test Coverage Gaps
    13. Example: AI-Generated Test for Missing Branch
    14. Key Strategies for AI-Enhanced Test Coverage
    15. 6. Reviewing Generated Test Quality
    16. Review Process Steps
    17. Generated vs Manual Test Quality
    18. Key Points to Validate
    19. 7. Fixing Failing Tests Automatically
    20. Example: AI Repairing a Failing Test
    21. How AI Fixes Failing Tests
    22. 8. Generating Test Assertions from Requirements
    23. Best Practices for AI-Generated Assertions

  31. Reviewing Pull Requests with AI Agents

    1. 1. Requesting Automated PR Summaries
    2. Example: Using AI for PR Summary
    3. 2. Using Copilot Code Review
    4. Example: Copilot Review in Action
    5. Key Benefits of AI Code Review
    6. Copilot vs Manual Review
    7. 3. Identifying Security Issues in Reviews
    8. Example: Security Issue Detection Workflow
    9. Key Security Indicators AI Looks For
    10. 4. Suggesting Code Improvements in Reviews
    11. Example: AI Suggestion for Refactoring
    12. Key Benefits of AI Code Suggestions
    13. 5. Generating Commit Messages
    14. Example: AI-Generated Commit Message
    15. 6. Generating PR Descriptions
    16. Example: AI PR Description Generation
    17. 7. Resolving Review Comments Automatically
    18. Example: Resolving Style Comment
    19. Example: Resolving Security Issue
    20. 8. Configuring Review Rule Sets
    21. Example: Basic rule set configuration
    22. Best Practices for Rule Sets

  32. Generating Documentation with AI Agents

    1. 1. Generating Function Docstrings
    2. Example: Docstring Generation
    3. 2. Generating README Files
    4. Example: README Generation Configuration
    5. README Generation Workflow
    6. 3. Generating API Documentation
    7. Example: Generating API Docs from JSDoc Comments
    8. Example: Output Markdown Documentation
    9. 4. Generating Architecture Diagrams from Code
    10. Example: Generating a Class Diagram with PlantUML
    11. Comparison: AI vs Manual Diagram Generation
    12. 5. Keeping Documentation in Sync with Code
    13. Example: Using GitHub Actions to Sync Docs
    14. 6. Generating Changelog Entries
    15. Example: Changelog Entry Format
    16. Example: Breaking Change Entry
    17. 7. Translating Documentation with AI
    18. Example: Translating Documentation
    19. 8. Summarizing Legacy Code for Documentation
    20. Example: Summarizing a Legacy Function

  33. Automating Git Workflows with AI

    1. 1. Generating Commit Messages Automatically
    2. Example: Using ai-commit CLI
    3. Example: Configuring commit template
    4. 2. Resolving Merge Conflicts with AI
    5. Example: AI-assisted Conflict Resolution
    6. 3. Generating Branch Names
    7. Example: AI-Generated Branch Name
    8. 4. Summarizing Diff Changes
    9. 5. Automating Changelog Generation
    10. Example: Using commitizen with conventional commits
    11. Example: Generating changelog with standard-version
    12. 6. Reviewing Commit History for Patterns
    13. Example: AI Analysis of Commit History
    14. 7. Splitting Large Commits with AI Assistance
    15. Example: Using AI to Split a Large Commit
    16. 8. Drafting Release Notes from Commits
    17. Example: Generating Release Notes
    18. Example: AI-Powered Release Note Drafting

  34. Selecting and Switching AI Models

    1. 1. Comparing Model Capabilities
    2. Example: Code Generation Comparison
    3. 2. Switching Models Mid-Session
    4. Example: Switching Models in a Development Workflow
    5. 3. Using Model Routing Strategies
    6. Example: Basic model routing configuration
    7. Key Considerations for Model Routing
    8. 4. Selecting Models for Cost vs Quality
    9. Example: Cost-Effective Model Switching
    10. Summary: Cost vs Quality Trade-offs
    11. 5. Configuring Fallback Models
    12. Example: Fallback Configuration
    13. 6. Using Local and Open-Source Models with Ollama
    14. Example: Running a Local Model with Ollama
    15. Comparison: Ollama vs Cloud AI APIs
    16. 7. Testing Model Output Consistency
    17. Example: Comparing outputs across model versions
    18. Comparison: Model Output Stability Metrics
    19. 8. Pinning Model Versions for Reproducibility
    20. Example: Using Model ID in API Call
    21. Best Practices for Version Pinning
    22. 9. Evaluating New Model Releases
    23. Example: Benchmarking New Model

  35. Optimizing AI Agent Costs and Tokens

    1. 1. Understanding Token-Based Pricing
    2. Example: Token Counting
    3. Key Points to Reduce Token Costs
    4. 2. Monitoring Token Usage
    5. Example: Token Usage Monitoring
    6. Token Usage Best Practices
    7. 3. Reducing Context Size to Cut Costs
    8. Example: Truncating Input
    9. Example: Summarizing Context
    10. 4. Using Prompt Caching
    11. Example: Prompt Caching in Action
    12. 5. Batching Requests for Efficiency
    13. Example: Batching API Calls
    14. 6. Setting Usage Budgets and Alerts
    15. Example: Configuring Usage Budgets
    16. 7. Choosing Cost-Effective Models for Routine Tasks
    17. Example: Using Claude 3 Haiku for Routine Tasks
    18. 8. Auditing Monthly Usage Reports
    19. Example: Parsing AI Cost Report
    20. Key Metrics to Monitor
    21. Steps to Audit Usage Reports

  36. Securing AI Agent Usage

    1. 1. Preventing Prompt Injection Attacks
    2. Example: Vulnerable Prompt Handling
    3. Example: Secure Prompt Handling
    4. Key Mitigation Techniques
    5. 2. Avoiding Secrets Exposure in Prompts
    6. Example: Secure Prompt Construction
    7. Best Practices for Prompt Security
    8. 3. Restricting Agent File System Access
    9. Example: Configuring File System Permissions
    10. 4. Reviewing Agent-Executed Commands
    11. Example: Command Execution Log
    12. Best Practices for Command Review
    13. 5. Sandboxing Agent Tool Execution
    14. Example: Node.js Sandboxing
    15. 6. Auditing Agent Action Logs
    16. Example: Log Format for API Call
    17. Key Audit Points
    18. 7. Handling Untrusted Tool Output Safely
    19. Example: Sanitizing Tool Output
    20. Best Practices for Tool Output Safety
    21. 8. Validating Agent-Generated Dependencies
    22. Example: Validating NPM Dependencies
    23. Example: Scanning Docker Images for Vulnerabilities

  37. Integrating AI Agents into CI/CD Pipelines

    1. 1. Running Agents in GitHub Actions
    2. Example: Basic AI Agent Workflow
    3. 2. Automating Code Review in Pipelines
    4. Example: AI Code Review Integration
    5. 3. Automating Test Generation in Pipelines
    6. Example: AI-Generated Test Case
    7. Workflow: AI Test Generation Pipeline
    8. Comparison: Manual vs AI Test Generation
    9. 4. Gating Merges on Agent Checks
    10. Example: GitHub Actions Workflow with AI Agent Check
    11. 5. Configuring Agent API Keys in CI
    12. Example: Setting up API keys in GitHub Actions
    13. 6. Monitoring Agent Usage in Pipelines
    14. Example: Pipeline Metrics Collection
    15. Key Monitoring Points
    16. 7. Caching Agent Context Between Runs
    17. Example: Caching AI Agent State
    18. 8. Rolling Back Failed Agent Automations
    19. Rollback Process Overview
    20. Example: Rollback Script

  38. Governing AI Agents in Enterprise Teams

    1. 1. Setting Organization-Wide Policies
    2. Example: AI Usage Policy Template
    3. Key Policy Components
    4. 2. Managing Data Retention Settings
    5. Example: Configure Data Retention Policy
    6. 3. Configuring Content Exclusion Rules
    7. Example: Excluding Sensitive File Paths
    8. 4. Auditing Agent Usage Across Teams
    9. Example: Audit Log Structure
    10. Key Audit Points
    11. Agent Audit vs. Manual Code Review
    12. 5. Managing Seat Allocation and Licensing
    13. Example: Seat Allocation Configuration
    14. Seat Management Workflow
    15. 6. Enforcing Approved Model Lists
    16. Example: Model List Configuration
    17. 7. Complying with Data Residency Requirements
    18. Example: Configuring Data Residency in AI Agent
    19. 8. Onboarding Teams to AI Coding Standards
    20. Example: Setting up a Team AI Coding Standard Template
    21. Onboarding Workflow
    22. Key Points for Onboarding

  39. Evaluating AI-Generated Code Quality

    1. 1. Reviewing Generated Code for Bugs
    2. Example: Bug Detection in AI-Generated Code
    3. Key Areas to Inspect
    4. 2. Checking for Hallucinated APIs
    5. Example: Validating API Endpoints
    6. 3. Validating License Compliance
    7. Example: Checking License Compliance for Open Source Dependencies
    8. 4. Measuring Suggestion Acceptance Rates
    9. Example: Calculating Acceptance Rate
    10. Key Considerations for Acceptance Rate Metrics
    11. 5. Benchmarking Agent Performance
    12. Example: Measuring Code Accuracy
    13. Key Metrics for AI Agent Benchmarking
    14. 6. Comparing Outputs Across Agents
    15. Example: Comparing Code Suggestions
    16. Comparison Grid: Agent Output Consistency
    17. 7. Tracking Regression from AI Changes
    18. Example: Regression Test Setup
    19. Best Practices for Regression Tracking
    20. 8. Building an Internal Evaluation Suite
    21. Example: Basic evaluation suite structure
    22. Key Features of Evaluation Suites

  40. Troubleshooting AI Agent Behavior

    1. 1. Diagnosing Unresponsive Agents
    2. Example: Handling Rate Limiting
    3. 2. Fixing Ignored Instructions
    4. Example: Clear Instruction Formatting
    5. 3. Resolving Context Loss Issues
    6. Example: Context Management with Session Tracking
    7. 4. Fixing Repeated Tool Call Failures
    8. Example: Configuring Retry Limits
    9. 5. Clearing Corrupted Session State
    10. Example: Resetting Session State
    11. 6. Reporting Bugs to Agent Vendors
    12. Example: Filing a bug report for incorrect code generation
    13. Best Practices for Bug Reporting
    14. 7. Reviewing Agent Debug Logs
    15. Example: Enabling debug logging in an AI agent
    16. Common Debug Log Patterns
    17. 8. Recovering from Runaway Agent Loops
    18. Example: Detecting and Stopping Infinite Loops

  41. Building Custom AI Agent Extensions

    1. 1. Creating VS Code Chat Extensions
    2. Example: Basic VS Code Chat Extension Structure
    3. Example: AI Chat Extension Activation
    4. Key Steps to Create a VS Code Chat Extension
    5. 2. Registering Custom Tools via Extension API
    6. Example: Registering a Custom Tool
    7. 3. Publishing Agent Extensions
    8. Example: Package.json Configuration
    9. Publication Steps
    10. Extension Types
    11. Deployment Workflow
    12. 4. Testing Custom Extensions Locally
    13. Example: Local testing setup with mock AI service
    14. Testing Workflow
    15. 5. Handling Extension Authentication
    16. Example: Configuring OAuth2 Authentication
    17. 6. Versioning and Updating Extensions
    18. Example: Versioning in Manifest
    19. Workflow: Updating Extension
    20. 7. Distributing Extensions to a Team
    21. Example: Publishing to NPM
    22. Best Practices for Team Distribution
    23. 8. Deprecating and Removing Extensions
    24. Example: Deprecation in Manifest