Visual Studio Code 1.95: A Game-Changing Update for Developers
DEVELOPPEMENT
Patrick Chouinard
11/25/202417 min read
Introduction
Visual Studio Code has always been a favorite among developers for its versatility, lightweight design, and robust feature set. With every update, it seems to push the boundaries of what a coding editor can do—and version 1.95 is no exception. This latest release is packed with powerful features that are set to redefine the way we code, collaborate, and leverage AI to boost productivity.
From AI-driven code edits and seamless integration of multiple GitHub accounts to the flexibility of swapping LLM models within GitHub Copilot, this update is packed with innovations that make coding faster and smarter. Whether you’re a seasoned developer or just starting out, there’s something in this release that will elevate your workflow.
Welcome to the first post in our three-part series, where we’ll dive deep into everything Visual Studio Code 1.95 has to offer. In this article, we’ll explore each new feature in detail, providing practical examples and best practices to ensure you’re making the most of these enhancements. Along the way, we’ll also discuss how these updates can optimize your GitHub Copilot experience and transform your development environment.
So, what can you expect in this post? We’ll start by looking at the game-changing Copilot Edits, move on to the strategic integration of Copilot Chat, and then explore features like multiple GitHub account support and the new capability to swap LLM models. And don’t worry—there’s much more to uncover!
By the end of this series, you’ll have all the tools and insights you need to harness these updates effectively. And if you’re eager to learn about optimizing Copilot through configuration management or selecting the perfect LLM model for your projects, be sure to stay tuned for our upcoming posts. Let’s jump in and see what makes Visual Studio Code 1.95 a game-changer!
Overview of New Features
Version 1.95 of Visual Studio Code brings an impressive lineup of features designed to make development smoother, faster, and smarter. Whether you’re a solo developer working on personal projects or part of a large team juggling complex codebases, these updates have something for everyone. Let’s take a high-level look at what’s new:
Copilot Edits: Take your coding efficiency to the next level with AI-driven code edits. Copilot Edits enables seamless multi-file iterations, providing smart change suggestions that save you time and reduce repetitive tasks.
Copilot Chat in the Secondary Side Bar: Keep Copilot Chat readily accessible with its new position in the secondary side bar. This integration makes it easier to get AI-powered assistance without disrupting your workflow, whether you’re browsing files, reviewing code, or managing source control.
Multiple GitHub Accounts Support: For developers who switch between personal and professional projects, this feature is a game-changer. You can now stay logged in to multiple GitHub accounts simultaneously, streamlining your experience and eliminating the hassle of logging in and out.
LLM Model Swapping for Copilot: One of the most exciting updates is the ability to choose between different large language models (LLMs) for GitHub Copilot. This flexibility allows you to optimize performance based on your specific development tasks, whether you need more speed or greater depth in your AI assistance.
Copilot Code Reviews: Writing high-quality code just got easier. With Copilot Code Reviews, you can receive AI-powered feedback in real time or review all your changes before pushing to the repository. It’s like having a code reviewer on standby, ready to catch errors and suggest improvements.
Enhanced Documentation Generation: No matter your preferred programming language—whether Python, JavaScript, C#, or others—new improvements in documentation templates make it simpler to generate clear, consistent documentation. Say goodbye to missing or incomplete comments and hello to better-maintained codebases.
Preview Settings Indicator: Manage experimental features with more confidence using the new Preview Settings Indicator. This visual cue helps you track which settings are in preview mode, giving you greater control over your development environment and the ability to experiment with new functionalities safely.
Each of these features brings new opportunities to streamline your workflow and enhance your coding experience. In the sections that follow, we’ll dive deeper into how to make the most of these updates, complete with practical examples and tips.
Let’s start by exploring how Copilot Edits can transform your coding process and make multi-file changes a breeze.
Copilot Edits
One of the standout features in Visual Studio Code 1.95 is Copilot Edits, a powerful AI-driven tool that simplifies making code changes across multiple files. Designed to streamline repetitive tasks, this feature allows you to focus more on the critical, high-value aspects of development while leaving the tedious work to AI.
How It Works
Copilot Edits enables you to initiate an AI-powered editing session with a simple selection or by providing a natural language prompt. Once activated, Copilot generates change suggestions and applies them intelligently across your codebase. It analyzes the surrounding context in your project to make sure its edits are consistent and well-integrated with your existing code.
Imagine you need to rename a function that’s used in several places across your codebase. Instead of manually updating each instance, you can use Copilot Edits to automate the process. For example, simply prompt, "Rename the fetchData function to retrieveData throughout the project," and Copilot will handle the rest, making sure the change is applied everywhere it’s needed.
Another useful scenario could be updating a recurring pattern, like changing the structure of error handling across various modules. Instead of painstakingly altering each file, a simple instruction to Copilot can save you hours of work, transforming a tedious process into an effortless one.
Best Practices for Using Copilot Edits
Start with a Clear Prompt: When using Copilot Edits, the key to getting accurate results is giving precise and descriptive instructions. The clearer your prompt, the better Copilot can understand your intent and deliver the changes you want.
Review Suggestions Carefully: Even though Copilot is a powerful tool, it’s still important to manually review the changes it makes, especially for complex or sensitive parts of your code. Make sure everything aligns with your project’s architecture and adheres to your coding standards.
Use in Combination with Version Control: Before applying extensive changes, ensure your project is safely committed to version control. This way, you can easily review, revert, or compare Copilot’s edits with your original code if needed.
Potential Limitations and Caveats
While Copilot Edits is excellent for straightforward changes, it may not always perform optimally with deeply complex or highly interdependent code structures. For instance, refactoring heavily coupled components or dealing with intricate dependencies might require a more manual and cautious approach. Always be aware of the AI’s limitations and rely on your expertise to guide the final review and approval of any automated edits.
It’s crucial to remember that Copilot is a tool designed to assist and enhance your development workflow, not to replace your judgment as a developer. By speeding up repetitive tasks, Copilot Edits allows you to focus on more creative and problem-solving aspects of coding while reducing mental overhead.
Why It’s a Game-Changer
Copilot Edits transforms how developers handle large-scale code changes, making processes that used to be painstakingly slow now quick and efficient. The ability to automate multi-file refactorings, maintain consistency, and reduce repetitive work is a significant boost to productivity. It exemplifies how AI can be a powerful partner, helping developers innovate and push boundaries without being bogged down by routine tasks.
With this new way of editing code at your fingertips, let’s move on to another exciting enhancement: the Copilot Chat integration, which brings even more seamless AI-driven assistance into your development workflow.
Copilot Chat in the Secondary Side Bar
The integration of Copilot Chat into the secondary side bar is another major enhancement in Visual Studio Code 1.95. This update is all about improving accessibility and convenience, allowing developers to keep Copilot Chat readily available without disrupting their workflow. Whether you’re exploring files, reviewing code, or managing source control, this new placement makes AI assistance smoother and more seamless.
What’s New?
Previously, using Copilot Chat often meant switching between views or interrupting your current focus. With the new secondary side bar integration, Copilot Chat is now anchored alongside your other essential tools, such as the File Explorer and Source Control. This change allows for a more efficient workflow, especially when you need quick AI-powered assistance while navigating through your codebase.
Imagine you’re reviewing code and want Copilot’s help understanding a function or generating an example usage. Instead of shifting your view or rearranging your workspace, you can simply open Copilot Chat from the side bar and get assistance instantly. This streamlined approach keeps your attention on the task at hand, reducing friction and improving productivity.
How to Use It Effectively
Configure Your Layout: Take a moment to customize your VS Code layout to suit your preferences. If you frequently use Copilot Chat, placing it in a fixed position within the secondary side bar can make accessing AI support even more intuitive.
Effortless Multitasking: Use Copilot Chat alongside other side bar tools to enhance multitasking. For example, while reviewing code in the Source Control view, you can simultaneously ask Copilot for clarification on specific changes or request suggestions for code improvements.
Interactive Code Exploration: Make the most of Copilot Chat for on-the-fly code exploration. If you’re curious about how a piece of code might behave with different inputs or want to generate test cases, Copilot Chat is right there to assist, eliminating the need for disruptive context switches.
Best Practices for Maximum Benefit
Pin and Organize Views: Customize the side bar to keep your most frequently used views, including Copilot Chat, in a convenient order. This way, you can quickly switch between them without losing focus.
Leverage Context: When asking Copilot for help, provide as much context as possible. The more detail you give, the better Copilot can assist. For instance, if you’re working on a specific function, reference it in your query to get more relevant suggestions.
Combine with Other Features: Use Copilot Chat in combination with Copilot Edits for an even more powerful development experience. Ask for edits or explanations and then have Copilot Chat assist in implementing them, all without breaking your flow.
Why This Feature Stands Out
This integration is more than just a convenience—it represents a step forward in how we interact with AI in our development environments. By making Copilot Chat more accessible, VS Code v1.95 enables a more fluid, uninterrupted workflow, saving time and making coding more enjoyable. Developers can now get the help they need exactly when and where they need it, making AI an even more integral part of the development process.
Now that we’ve explored how to keep Copilot Chat within easy reach, let’s move on to a feature that’s bound to be a game-changer for many developers: Multiple GitHub Accounts Support.
Multiple GitHub Accounts Support
Managing multiple GitHub accounts has long been a challenge for developers who juggle personal and professional projects. Visual Studio Code 1.95 addresses this pain point by introducing seamless support for multiple GitHub accounts, simplifying workflows for anyone who needs to switch between identities regularly.
What’s New?
Previously, logging in and out of different GitHub accounts in VS Code was cumbersome and often disrupted development flow. With this update, you can stay signed in to multiple GitHub accounts simultaneously. This means you can effortlessly switch between your personal account and your organization’s account without the hassle of repeated authentication or worrying about using the wrong credentials.
For example, if you’re working on open-source projects in your personal GitHub account and need to jump over to a private enterprise repository, VS Code makes it as smooth as possible. You can seamlessly move between projects while maintaining access to the appropriate repositories, pull requests, and permissions.
How to Set Up and Use This Feature
Adding Multiple Accounts: To add multiple GitHub accounts, go to the Accounts view in the activity bar, select Add Account, and follow the prompts to sign in. Repeat this for each account you want to link.
Switching Between Accounts: Once you have multiple accounts added, switching between them is simple. Use the Account menu in the status bar to choose the account you want to use for the current project or operation. VS Code will handle the rest, ensuring you have the correct permissions and settings for the selected account.
Integration with Extensions: This feature also integrates with GitHub-related extensions, such as the GitHub Pull Requests and Issues extension. You can now manage issues, review pull requests, and access repository data based on the selected account, making it easier to keep your work and personal projects organized.
Best Practices for Managing Multiple Accounts
Use Descriptive Labels: If you work across many accounts, consider labeling them descriptively in your account settings to avoid confusion. This will help you quickly identify which account you’re using and prevent mistakes, like pushing changes to the wrong repository.
Set Default Accounts for Workspaces: For added convenience, configure default accounts for specific workspaces. If you always use your organization’s account for a certain project, set it as the default to streamline your workflow.
Keep Permissions in Check: Review and manage the permissions for each account to ensure you have the right level of access for each project. This is especially important for security-sensitive environments where strict permissions are necessary.
Why This Feature is a Game-Changer
The ability to manage multiple GitHub accounts seamlessly transforms how developers work across projects. By eliminating the need to constantly log in and out, VS Code v1.95 helps maintain a smoother workflow, reducing the risk of credential-related errors. It’s a productivity boost for anyone balancing multiple roles or responsibilities in their coding life.
With GitHub account switching made effortless, let’s turn our attention to a feature that offers unparalleled flexibility: LLM Model Swapping for GitHub Copilot.
LLM Model Swapping for GitHub Copilot
One of the most exciting features introduced in Visual Studio Code 1.95 is the ability to swap between different large language models (LLMs) used by GitHub Copilot. This new level of customization allows developers to optimize their AI assistant not just for specific tasks, but for various stages in the development lifecycle.
What’s New?
Previously, Copilot operated with a default model, suitable for many scenarios but lacking the flexibility to adapt to different stages of a developer’s workflow. Now, with LLM Model Swapping, you can select from a range of models, each fine-tuned for specific phases of development. This ensures that you’re getting the most relevant AI assistance for the work at hand, whether you’re designing complex software architecture or working on quick inline code fixes.
Choosing the Right Model for Each Development Stage
Here’s how you can leverage different models throughout your development lifecycle:
Strong Reasoning Model: Ideal for the architecture and planning phase. This model excels at understanding complex requirements and offering high-level design suggestions. Use it when you’re defining the structure of your application, designing intricate algorithms, or working on major refactorings that require a deep understanding of context.
Balanced Model: Perfect for day-to-day development. This model provides a good balance between speed and contextual understanding, making it well-suited for writing new features, debugging, or reviewing code. It’s the model to rely on for regular coding activities, offering both efficiency and robust suggestions.
Quick Inference Model: Best for inline recommendations. When you’re looking to speed up your workflow with rapid completions, this lightweight model delivers quick and efficient code suggestions. It’s particularly useful for writing repetitive snippets, making small edits, or generating boilerplate code.
Extended Context Model: Tailored for documentation and code review. With a larger context window, this model excels at understanding and generating documentation, summarizing code, and providing insightful reviews. It’s a valuable tool when you’re documenting your work or reviewing extensive pull requests.
Looking Ahead
We’ll explore this topic in greater depth in a future post, where we’ll break down strategies for using LLM Model Swapping to optimize your development workflow. For now, keep in mind how each model can be leveraged throughout different stages of your coding process to maximize efficiency and get the most out of GitHub Copilot.
Up next, let’s dive into another groundbreaking feature that enhances your development experience: Copilot Code Reviews.
Copilot Code Reviews
Another groundbreaking addition in Visual Studio Code 1.95 is Copilot Code Reviews, a feature that introduces AI-driven feedback to your development process. This capability can be a game-changer for ensuring code quality and catching potential issues early, all while reducing the manual effort typically required during code reviews.
How It Works
With Copilot Code Reviews, you can receive intelligent feedback on your code as you write it or review all changes before committing to your repository. By analyzing your modifications, Copilot offers suggestions for improvement, highlights potential bugs or inefficiencies, and even proposes alternative implementations that could make your code more efficient or maintainable.
For example, if you’ve just completed a new feature and want to ensure it’s well-optimized, Copilot can scan your changes and provide recommendations. It might point out redundant logic, suggest a more efficient data structure, or highlight security concerns—saving you from potential issues down the road.
Getting Started with Copilot Code Reviews
Initiate a Review: You can request a code review by selecting a block of code or by reviewing all uncommitted changes in your project. Simply right-click the selection and choose Request Copilot Code Review, or use the dedicated button in the Source Control view.
Review Suggestions: Copilot will provide a list of recommendations and insights. You can choose to apply the suggestions directly, modify your code manually, or dismiss the feedback if it’s not relevant.
Iterative Improvements: As you make changes, you can re-run Copilot Code Reviews to see how your code has evolved and ensure that all issues have been addressed. This iterative approach is invaluable for refining your work and maintaining high-quality code.
Best Practices for Using Copilot Code Reviews
Use for Preliminary Feedback: Treat Copilot’s recommendations as a first pass to catch common mistakes and inefficiencies. It’s a great tool for improving your code before a human review, ensuring you’re presenting your best work to your team.
Combine with Human Review: While Copilot is powerful, it’s still crucial to have a human developer review your code, especially for complex logic, security-critical changes, or code that requires domain-specific knowledge.
Learn from the Suggestions: Take time to understand the rationale behind Copilot’s feedback. This not only improves your code but also helps you grow as a developer, as you learn best practices and alternative coding strategies.
Why It’s a Game-Changer
Copilot Code Reviews significantly enhances the development workflow by providing immediate, AI-driven insights. It reduces the back-and-forth often associated with code reviews, speeds up the development process, and helps you catch issues early. It’s like having an extra set of eyes on your code at all times, boosting confidence and ensuring higher code quality.
Next, let’s explore how the Enhanced Documentation Generation feature can simplify the process of keeping your code well-documented across various languages and frameworks.
Enhanced Documentation Generation
Documentation is a crucial part of any software project, and Visual Studio Code 1.95 introduces improvements to help developers generate clear and consistent documentation across multiple programming languages. Whether you're using Python, JavaScript, C#, or another language, these enhancements make it easier to keep your code well-documented and maintainable.
What’s New?
The new documentation generation feature simplifies the process of creating structured comments and docstrings, making it more intuitive for developers to provide essential information about their code. Visual Studio Code now supports templates for different documentation styles, such as:
Docstrings for Python: Quickly generate formatted comments that describe functions, classes, and methods, including parameter details and return types.
XML Comments for C#: Create standardized XML-based documentation to describe classes and methods, useful for generating comprehensive API documentation.
JSDoc for JavaScript and TypeScript: Automatically generate JSDoc annotations that document function signatures, expected parameters, and return values.
This enhancement is particularly valuable for teams working in multilingual codebases, as it ensures that everyone is following consistent documentation practices, regardless of the language being used.
How to Use This Feature
Automatic Template Generation: Start writing a comment above a function or class, and Visual Studio Code will suggest a documentation template based on the language you’re using. This saves time and ensures consistency in how your code is documented.
Customizable Templates: If your team has specific documentation requirements, you can customize these templates to match your style guidelines. This ensures that all generated documentation meets your project’s standards.
Integration with Copilot: Use GitHub Copilot to fill in documentation details intelligently. By analyzing your code, Copilot can generate descriptions, explain parameters, and suggest return type annotations, making the documentation process even more seamless.
Best Practices for Documentation
Be Descriptive but Concise: Aim to provide enough detail to explain what your code does without overwhelming the reader. Focus on describing the purpose of functions, parameters, and return values clearly.
Keep Documentation Up-to-Date: As your code evolves, make sure to update the documentation accordingly. Use tools like linters or CI checks to ensure documentation is maintained as part of your development workflow.
Standardize Across the Team: Use the customizable templates feature to ensure that everyone on your team is following the same documentation practices. This consistency makes it easier to read and maintain code across the project.
Why This Feature Matters
Well-documented code isn’t just a best practice—it’s essential for collaboration, onboarding new team members, and ensuring your project is maintainable in the long term. By automating and standardizing documentation, Visual Studio Code 1.95 helps developers save time and reduce the friction associated with writing comments and annotations. Combined with GitHub Copilot’s AI-driven suggestions, keeping your code well-documented has never been easier.
With documentation streamlined, let’s wrap up our exploration of Visual Studio Code 1.95’s features by discussing the Preview Settings Indicator and how it enhances your control over experimental features.
Preview Settings Indicator
Visual Studio Code 1.95 introduces the Preview Settings Indicator, a subtle yet powerful addition that gives developers more control over experimental and preview features. This update ensures that you’re always aware of which features are in preview mode and allows you to manage your development environment with greater confidence.
What’s New?
The Preview Settings Indicator is a visual cue integrated into the Settings editor that highlights any settings related to experimental or preview features. These features are often cutting-edge but may still be in active development, so having a clear indicator helps you stay informed and make intentional decisions about which features to enable or experiment with.
Previously, it was easy to overlook which settings were in preview mode, sometimes leading to unexpected behavior in your development setup. With this update, you can now quickly identify and manage these features, reducing potential friction or surprises as you work.
How to Use the Preview Settings Indicator
Navigate to Settings: Open the Settings editor in Visual Studio Code and look for the new indicator next to preview or experimental settings.
Identify Experimental Features: The indicator makes it easy to spot settings that are not yet fully stable, allowing you to review their purpose and decide whether to enable or disable them based on your project needs.
Manage Settings Proactively: Use this feature to stay organized and control which experimental features you’re using, especially if you’re working on critical projects where stability is key. You can also leverage this to try out new capabilities in a controlled manner, giving you early access to future updates.
Best Practices for Managing Experimental Features
Stay Informed: Keep an eye on which features are in preview mode and read the release notes or documentation to understand their current status. This awareness helps you anticipate any impact on your workflow.
Use in Non-Critical Projects: If you’re curious about trying experimental features, consider enabling them in non-critical projects first. This way, you can explore new functionality without risking disruptions in important codebases.
Provide Feedback: Since preview features are often under active development, your feedback can help shape their final implementation. If you encounter issues or have suggestions, don’t hesitate to share your experiences with the development community or through Visual Studio Code’s feedback channels.
Why This Feature Enhances Your Workflow
The Preview Settings Indicator is a small but impactful change that adds transparency to your development environment. By making it easier to manage and monitor experimental settings, Visual Studio Code ensures that you’re always in control. This level of awareness is particularly valuable for teams that prioritize stability but still want to explore and test new tools and features.
Visual Studio Code 1.95 is packed with features designed to streamline your workflow and boost productivity. From AI-driven enhancements with GitHub Copilot to smarter settings management, this update empowers developers to work more efficiently and confidently. As we continue this series, stay tuned for our upcoming posts on how to make the most of these features, including configuration management and optimizing LLM models.
Let’s embrace this new era of AI-assisted development together!
Conclusion
Visual Studio Code 1.95 delivers a powerhouse of new features that push the boundaries of what developers can achieve. From AI-driven improvements like Copilot Edits and Copilot Code Reviews to the seamless integration of Multiple GitHub Accounts and the flexibility to Swap LLM Models, this update truly enhances your coding experience. The introduction of better Documentation Generation and the Preview Settings Indicator further showcases VS Code’s commitment to helping developers stay organized and efficient.
This post marks the first in our three-part series, where we’ve explored these exciting updates and discussed how to make the most of them in your day-to-day development. But there’s so much more to come! Our next posts will dive deeper into:
Configuration Management for GitHub Copilot in Azure DevOps, detailing how to set up coding, testing, and documentation guidelines that maximize your AI assistant’s potential.
Selecting the Perfect LLM Model for Individual Development Tasks, offering insights into optimizing your Copilot experience throughout the software development lifecycle.
Stay tuned for these in-depth guides, and in the meantime, we’d love to hear from you! How do you plan to leverage these new features in your projects? Are there particular updates you’re excited about or questions you’d like us to address in future posts? Drop your thoughts in the comments or connect with us through our social channels.
Let’s continue to embrace this new era of AI-assisted development and see where these powerful tools can take us. Happy coding!