Yes, 9 Router is small Node.js server on your machine that proxies chat requests to 40+ AI providers (Anthropic, OpenAI, Gemini, GLM, local Ollama, etc.), with automatic fallback when a subscription hits its quota and a built-in token-compression layer ("RTK") that trims 20–40% off tool-output tokens. Because it exposes a standard /v1 chat endpoint, any client that supports Bring Your Own Key (BYOK). including Visual Studio 2026's Copilot Chat can point at it instead of GitHub's own model backend. This good scenario when you want to utilize your LLM model into Visual Studio as alternative of Github Copilot. Visual Studio codes altready has extension for 9 Router. How about Visual Studio 2026? This article will discuss how to configure Visual Studio 2026 to work with 9 Router.
Benefit of using 9 router
You can save your token by utilizing unused free token
You can avoid subscription by combining all free LLM token
You can create and connect LLM based on task and combos
Challange using 9 router
you need to install 9 routers in your PC / Server
You can get inconsistent result because each LLM will have different response
You need to create account for each LLM that you need
On this article, we will create a simple script to install, 9Router, and Visual Studio configuration. You can run the ready to use script here https://github.com/ridiferd/9Router-VS2026.git
Step 1 — Install and run 9Router
git clone https://github.com/decolua/9router.git cd 9router npm install npm run build npm run start # or run persistently with PM2: npm install -g pm2 pm2 start npm --name 9router -- start pm2 save
By default the server listens on http://localhost:20128, with:
Proxy endpoint: http://localhost:20128/v1
Dashboard: http://localhost:20128/dashboard
Step 2: Connect providers and generate a key
Open the dashboard and sign in with the password you set via INITIAL_PASSWORD.
Add your provider accounts (e.g. cc/ for Claude Code subscription, glm/, kr/, vertex/, etc.).
Optionally build a fallback stack (e.g. primary subscription, cheap backup, free model) so Visual Studio never hits a hard stop mid-session.
Copy the generated API key from the dashboard, you'll paste it into Visual Studio next.
Step 3: Register 9Router inside Visual Studio 2026 Copilot Chat
Visual Studio's native Manage Models dialog (Copilot Chat , model picker , Manage Models) currently ships provider slots for OpenAI, Anthropic, Google, xAI, Azure, and Foundry Local it does not (as of this writing) expose a bare "custom base URL" field the way VS Code Insiders does. The practical, documented workaround is to use the Azure OpenAI slot, which does accept an arbitrary resource endpoint:
Model picker, Manage Modelsm Add Models, provider Azure.
Resource Endpoint: http://localhost:20128/v1
API Key: the key copied from the 9Router dashboard
Model ID: the provider-prefixed model you configured, e.g. kr/claude-sonnet-4.5
Display Name: anything recognizable, e.g. "9Router – Ridilabs"
Save, then select it from the model picker in a chat request to confirm a response comes back.
Check this dialog against your current VS build before relying on it Microsoft has been actively expanding BYOK/custom-endpoint support through 2026, and a native "OpenAI Compatible" slot may already exist by the time you read this.
Step 4: Verify and tune
Inline completions still run through GitHub's own infrastructure and are not rerouted, BYOK only affects Chat/Agent requests.
Output from a non-Copilot model bypasses GitHub's Responsible AI content filtering.
Toggle RTK / token-saving filters and fallback order any time from Dashboard, Endpoint settings without touching the Visual Studio config again.
Hi All, Ensuring high‑quality code is one of the most important responsibilities in modern software development. Clean, maintainable, and secure code reduces long‑term technical debt, minimizes bugs in production, and improves team productivity. Traditionally, developers rely on manual reviews, static analysis tools, and extensive debugging sessions. Today, GitHub Copilot brings a new level of intelligence to this process.
More than just an AI code generator, GitHub Copilot acts as a real‑time reviewer, debugger, and quality assistant. This article explores how you can use GitHub Copilot to evaluate code quality, detect potential bugs, and improve your development workflow. On this article i use Visual Studio 2026, you will try on Visual Studio Codes it will work better
1. Why Code Quality Matters
High‑quality code leads to:
Fewer bugs and production incidents
Easier maintenance and refactoring
Better performance and security
Faster onboarding for new developers
More predictable development cycles
However, maintaining quality manually is time‑consuming. GitHub Copilot helps automate and accelerate this process.
2. How GitHub Copilot Helps Improve Code Quality
GitHub Copilot analyzes your code as you write and provides intelligent suggestions based on patterns learned from billions of lines of open‑source code.
a. Real‑Time Suggestions for Cleaner Code
Copilot continuously evaluates your code and offers improvements such as:
Simplifying complex logic
Suggesting clearer variable or function names
Recommending more efficient algorithms
Removing unused or redundant code
For example, if you write a deeply nested loop, Copilot may propose a more readable or optimized version.
b. Detecting Potential Bugs Automatically
Copilot can identify common pitfalls and risky patterns, including:
Null reference risks
Incorrect API usage
Missing error handling
Potential infinite loops
Security vulnerabilities such as SQL injection
If you write an API endpoint without validating input, Copilot often warns you and suggests adding validation logic.
c. Suggesting More Secure and Efficient Implementations
Copilot frequently recommends best‑practice alternatives, such as:
Using secure libraries for password hashing
Avoiding unsafe operations
Replacing manual parsing with built‑in framework utilities
Improving memory or CPU efficiency
This helps ensure your code follows modern standards.
3. Using GitHub Copilot Chat for Code Review and Debugging
The Copilot Chat feature is one of the most powerful tools for improving code quality.
a. Ask Copilot to Review Your Code
You can highlight a block of code and ask:
/review
Copilot will provide:
A list of potential bugs
Readability improvements
Security warnings
Refactoring suggestions
b. Ask Copilot to Explain Errors
When you encounter an exception or failing test, you can ask:
Explain why this code fails
Copilot will analyze the stack trace, identify the root cause, and propose a fix.
c. Ask Copilot to Improve Performance
For performance‑critical functions, you can request:
Improve performance of this function
Copilot may suggest:
Algorithmic improvements
Better data structures
Reduced allocations
Parallelization opportunities
4. Using GitHub Copilot to Generate Unit Tests
Unit tests are essential for maintaining code quality. Copilot can:
Generate unit tests automatically
Suggest edge cases you may have missed
Create consistent test structures
Example prompt:
Generate unit tests for this function using xUnit. Include edge cases.
This accelerates test coverage and reduces human error.
5. Recommended Workflow for Checking Code Quality with Copilot
A practical workflow might look like this:
1. Write your code normally
Copilot provides real‑time suggestions.
2. Use Copilot Chat for review
Ask for improvements, bug detection, or readability enhancements.
3. Generate unit tests
Ensure critical functions are covered.
4. Apply refactoring suggestions
Let Copilot help rewrite complex or inefficient sections.
5. Debug with Copilot
When errors occur, ask Copilot to analyze and propose fixes.
6. Case Study: Detecting Bugs in an ASP.NET Core API
Consider the following login endpoint:
[HttpPost("login")] public async Task<IActionResult> Login(UserLoginRequest request) { var user = await _userService.GetUser(request.Username); if (user.Password == request.Password) return Ok("Success"); return Unauthorized(); }
If you run /review on this code, Copilot will typically identify issues such as:
Plain‑text password comparison
Missing input validation
Potential null reference on user
Lack of rate limiting (risk of brute force attacks)
Copilot may then propose a more secure and robust implementation.
7. Conclusion
GitHub Copilot is more than an AI assistant—it is a powerful tool for improving code quality and detecting bugs early. By integrating Copilot into your workflow, you can:
Reduce debugging time
Improve security and maintainability
Write cleaner, more consistent code
Boost overall development productivity
What is Vibe Coding?
Vibe Coding is an AI-first development workflow where you:
Describe your intent in natural language.
Let the AI generate most of the code.
Iteratively refine through conversational prompts and quick tests.
In Visual Studio 2026, this is powered by:
Copilot Agent for multi-file reasoning.
Live Context Awareness for understanding your entire solution.
Instant Refactor for AI-driven code restructuring.
The Problem: Prototype ≠ Production
Vibe Coding excels at speed, but production systems demand:
Reliability (no hidden runtime errors)
Security (no unsafe defaults)
Performance (optimized for scale)
Maintainability (clear structure and documentation)
Without a production-readiness checklist, vibe-coded apps risk:
AI-generated anti-patterns
Missing edge case handling
Weak security defaults
Poor test coverage
Production-Readiness Checklist for Vibe-Coded Projects
1. Run AI Code Audits
Visual Studio 2026 includes AI Code Auditor:
Detects insecure patterns (e.g., SQL injection risks, unsafe file handling)
Flags deprecated APIs
Suggests performance optimizations
Always run the Audit → Security & Performance Scan before committing.
2. Enforce Strong Typing & Contracts
AI-generated code sometimes uses loose typing for speed. In C#, enable:
Csharp
<Project Sdk="Microsoft.NET.Sdk"> <PropertyGroup> <Nullable>enable</Nullable> <TreatWarningsAsErrors>true</TreatWarningsAsErrors> </PropertyGroup> </Project>
This ensures null safety and forces you to handle all warnings.
3. Add Comprehensive Unit & Integration Tests
Vibe Coding can generate tests for you:
Csharp
[TestClass] public class PaymentServiceTests { [TestMethod] public void ProcessPayment_ShouldThrow_WhenCardIsInvalid() { var service = new PaymentService(); Assert.ThrowsException<InvalidCardException>(() => service.ProcessPayment("1234", 100)); } }
Best Practice:
Aim for 80%+ coverage.
Include edge cases and failure scenarios.
4. Refactor for Maintainability
Use AI Instant Refactor to:
Split large functions into smaller, reusable methods.
Apply consistent naming conventions.
Remove unused code.
5. Secure Configuration Management
Never hardcode secrets in vibe-coded prototypes. Use Visual Studio 2026 Secret Manager:
Powershell
dotnet user-secrets set "DbPassword" "SuperSecret123"
And retrieve in code:
Csharp
var password = configuration["DbPassword"];
6. Performance Profiling
Before deployment:
Use Visual Studio Profiler to detect bottlenecks.
Let AI suggest algorithmic improvements.
Test under realistic load conditions.
7. Code Review with Humans
Even with AI audits, human review is essential. Pair with a senior developer to:
Validate business logic.
Ensure compliance with coding standards.
Catch subtle domain-specific issues.
Deployment Workflow for Vibe-Coded Apps
Prototype with Vibe Coding → Fast iteration.
Run AI Code Audit → Fix flagged issues.
Add Tests & Refactor → Improve reliability.
Security Hardening → Secrets, auth, and input validation.
Performance Profiling → Optimize for scale.
Human Code Review → Final quality gate.
Deploy to Staging → Test in production-like environment.
Go Live → Confidently release.
Vibe to Prod Checklist Template (Markdown)
# Vibe to Prod Checklist – Visual Studio 2026
## 1. Code Quality - [ ] Run AI Code Audit (Security & Performance) - [ ] Fix all flagged issues - [ ] Remove unused code and imports ## 2. Type Safety & Standards - [ ] Enable Nullable Reference Types - [ ] Treat Warnings as Errors - [ ] Apply consistent naming conventions ## 3. Testing - [ ] Unit tests for all core functions - [ ] Integration tests for critical workflows - [ ] Edge case and failure scenario coverage - [ ] Achieve 80%+ code coverage ## 4. Security - [ ] No hardcoded secrets - [ ] Use Secret Manager for sensitive data - [ ] Validate all external inputs - [ ] Apply authentication & authorization checks ## 5. Performance - [ ] Run Visual Studio Profiler - [ ] Optimize slow methods - [ ] Test under expected load ## 6. Review & Approval - [ ] Peer code review completed - [ ] Business logic validated - [ ] Compliance with coding standards ## 7. Deployment - [ ] Deploy to staging environment - [ ] Run smoke tests - [ ] Approve for production release
Programming robots with C# and Visual Studio is one of the most accessible ways to enter robotics—especially if you prefer working in the .NET ecosystem. Whether you want to control a physical robot arm or simulate one entirely in software, this guide walks you through the tools, kits, emulators, and workflow you need to get started.
1. What You Need Before You Begin
Essential Software
Visual Studio (Community Edition) Free and fully capable for robotics development. Supports .NET 6+ and integrates well with robotics SDKs.
.NET SDK Required to compile and run C# applications.
Robot Simulation or Control SDK The most popular options include:
RoboDK C# API — allows simulation and offline programming of industrial robots. RoboDK
Microsoft Robotics Developer Studio (MRDS) — older but still useful for learning and simulation. youtube.com
Optional: Bot Framework Emulator If you are building conversational robots (software bots), you can test them locally. Microsoft Learn
2. Choosing a Robot Kit or Simulator
You have two main paths: physical robot kits or virtual robots.
A. Physical Robot Kits
Ideal for hands‑on learners.
Recommended beginner kits:
Elegoo Smart Car (Arduino-based, programmable from C# via serial communication or custom firmware) youtube.com
DIY Arduino robot kits — inexpensive and widely supported.
How to connect C# to a physical robot:
Use SerialPort in C# to send commands to the robot’s microcontroller.
Write firmware on the robot that interprets commands (e.g., “MOVE 10”, “TURN 90”).
B. Virtual Robots (Simulators)
If you don’t have hardware, simulation is the best path.
1. RoboDK
A professional-grade simulator supporting hundreds of industrial robots.
Provides a C# API for controlling robots, generating paths, and exporting programs.
Works directly with Visual Studio. RoboDK
2. Microsoft Robotics Developer Studio (Obsolete)
Includes a visual simulation environment and a drag‑and‑drop programming interface.
Lets you program virtual robots without buying hardware. youtube.com
3. Setting Up Your Development Environment
Step 1 — Install Visual Studio
Install the Community Edition with the “.NET desktop development” workload.
Step 2 — Install the Robot SDK
Depending on your choice:
RoboDK: Install RoboDK + import the C# API via NuGet or the RoboDK.cs file. RoboDK
MRDS: Install Microsoft Robotics Developer Studio and its simulation environment.
Step 3 — Create a C# Project
Use:
Console App
WPF App (if you want UI controls)
Class Library (for modular robot logic)
4. Programming Your First Robot in C#
Basic Workflow
Connect to the robot or simulator (RoboDK: RoboDK RDK = new RoboDK();)
Load or select the robot model
Define movement targets Using matrices, joint angles, or XYZ coordinates.
Send movement commands
MoveJ() for joint movement
MoveL() for linear movement
Run and debug inside Visual Studio
5. Using Emulators and Testing Tools
RoboDK Simulator
Simulates robot motion
Detects collisions
Generates real robot programs RoboDK
MRDS Visual Simulation Environment
Lets you drive a virtual robot in a 3D world youtube.com
Bot Framework Emulator (for software robots)
Tests conversational bots built in C# Microsoft Learn
6. Where to Go Next
Once you master basic movement:
Add sensors (camera, ultrasonic, IMU)
Implement path planning
Use AI/ML for autonomous behavior
Deploy to real industrial robots via RoboDK
Overview
Visual Studio 2026 embeds agentic AI across the IDE, helping you understand unfamiliar codebases, adapt pasted snippets to project conventions, and surface performance and security insights before pull requests. These agents include language-specific assistants and a Profiler Agent that can identify and help fix performance hotspots
Setup and workflow tips
Enable local agents where possible to keep latency low and preserve context; let the IDE index your solution so suggestions match your code patterns.
Create a reproducible dev container with consistent SDKs and extensions so agent outputs remain stable across machines.
Use the agent’s “Did You Mean” or intent detection to refine searches and code navigation when the IDE misinterprets your query.
Why this matters: agents perform best when they have accurate, consistent project metadata and build traces to reference.
Writing and refactoring with agents
- Ask agents for idiomatic conversions (e.g., convert loops to LINQ or async patterns) and then review the diff rather than accepting blindly.
- Use paste-and-fix: paste snippets and let the agent adapt names, imports, and formatting to your project conventions; confirm tests and run the build after changes.
- Generate unit tests and edge-case scenarios from the agent’s suggestions, then run coverage tools to validate test quality.
Debugging and profiling
- Run the Profiler Agent early on slow scenarios; it can point to hot paths and suggest targeted fixes with benchmark-backed guidance.
- Capture traces and feed them to the agent so recommendations are grounded in real runtime data rather than heuristics.
- Use agent-suggested fixes as a starting point: implement, benchmark, and add microbenchmarks to prevent regressions.
Team practices and security
- Treat agent outputs as first drafts: enforce code review and static analysis gates to catch logic, licensing, or security issues the agent might miss.
- Document agent-assisted changes in PR descriptions so reviewers know what was automated and why.
- Audit third-party suggestions for licensing and supply-chain risk; agents can suggest dependencies but you must validate them.
Quick cheatsheet
- Daily: run solution index + agent sync; accept small fixes with tests.
- Before PR: run agent code review, static analysis, and Profiler Agent for performance regressions.
- When onboarding: ask the agent to summarize architecture, key modules, and common patterns to flatten the learning curve.
Bottom line: agentic AI in Visual Studio 2026 accelerates routine work and surfaces deep insights, but you keep final judgment—use agents to draft, test, and measure, not to replace review and validation.
1. Check if You’re Affected
Try opening a localhost/IIS site or any app that uses loopback (e.g., Visual Studio debugging, SSMS, Duo Desktop).
If you see errors like ERR_CONNECTION_RESET or ERR_HTTP2_PROTOCOL_ERROR, you’re impacted.
2. Immediate Workarounds
Option A: Uninstall the Problematic Update
Run in Command Prompt (Admin):
wusa /uninstall /kb:5066835 wusa /uninstall /kb:5065789
Restart your machine after uninstall.
This restores localhost/IIS functionality but removes October security fixes.
Option B: Disable HTTP/2 (Temporary Fix)
Open Registry Editor (regedit).
Navigate to:
HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\HTTP\Parameters
Add a new DWORD (32-bit) Value:
Name: EnableHttp2
Value: 0
Restart your machine.
This forces Windows to use HTTP/1.1, bypassing the broken HTTP/2 stack.
3. Permanent Fix (Preferred for Enterprises)
Apply Microsoft’s Known Issue Rollback (KIR)
Download the KIR Group Policy MSI for your Windows version (24H2, 25H2, or Server 2025) from Microsoft’s official site.
Install the MSI on your domain controller.
Open Group Policy Editorand navigate to:
Computer Configuration → Administrative Templates → <KIR Policy Name>
Enable the rollback policy.
Run gpupdate /force on affected clients or wait for policy refresh.
4. Other Issues & Fixes
IssueFix
DRM-protected content fails
Wait for Microsoft patch; use modern streaming apps
SMB v1 file sharing broken
Switch to SMB v2/v3 (SMB v1 is deprecated)
WUSA installer errors
Use Windows Update or WSUS instead
5. Recommended Action Plan
Developers / Local IIS users → Use HTTP/2 registry fix or uninstall update immediately.
Enterprise IT → Deploy KIR via Group Policy for scale.
Security-conscious environments → Prefer KIR over uninstalling updates, since it keeps security patches intact.
If you already get the issue, in order to make sure you get latest update please make sure you switch get the latest update in Windows Update
In the world of software development, choosing the right tools can significantly impact productivity, collaboration, and maintainability. Microsoft offers two powerful yet distinct tools: Visual Studio 2022 and Visual Studio Code. While their names suggest similarity, their purposes diverge sharply. So, if you already have Visual Studio 2022 installed, is there any real need to add VS Code to your toolkit? The answer is depending on your scenario.
If you're working on:
Large-scale enterprise applications
.NET or C++ projects with deep debugging needs
Integrated Azure, Docker, or SQL workflows
Complex solution management with multiple projects
Then Visual Studio 2022 likely covers all your bases. It’s designed for end-to-end development, offering everything from code editing to deployment pipelines.
Why Developers Still Use VS Code
Despite having Visual Studio 2022, many developers install VS Code for complementary reasons:
Speed: VS Code launches instantly and is ideal for quick edits or scripting.
Cross-platform: It runs on Linux and macOS, making it ideal for cloud-native or containerized workflows.
Extension Ecosystem: VS Code supports thousands of extensions, including for Markdown, YAML, JSON, and even Jupyter Notebooks.
Minimalism: For tasks like editing config files, writing documentation, or working with Git, VS Code is less cluttered.
Strategic Use in Academic and Cloud Contexts
For educators, researchers, and cloud-native developers like yourself, VS Code offers:
Remote Development: Connect to cloud VMs or containers via SSH or WSL.
Notebooks & AI: Excellent support for Python, Jupyter, and ML workflows.
Curriculum Flexibility: Easier to onboard students with a lightweight editor.
Conclusion: Complement, Not Compete
Visual Studio 2022 and VS Code are not rivals—they’re complements. Think of Visual Studio as your full-featured lab, and VS Code as your agile field notebook. If your workflow spans enterprise systems, cloud-native environments, and academic experimentation, having both tools installed is not redundant—it’s strategic. If you have plenty space and storage, you can install Visual Studio, but if you have limitation, you can install one of the toolkit.
With the end of Visual Studio 2022's lifecycle approaching, many developers are wondering why they should continue using Visual Studio when all its features are now available in Visual Studio Code. Here's why Visual Studio still holds its ground:
Comprehensive Development Environment
Visual Studio offers a comprehensive development environment with advanced tools for debugging, testing, and version control. While Visual Studio Code has made significant strides, Visual Studio still provides a more robust set of tools for large-scale enterprise projects.
Performance and Stability
Visual Studio is known for its performance and stability, especially for complex projects. It handles large codebases more efficiently and offers better performance for resource-intensive tasks.
Integrated Development Experience
Visual Studio provides an integrated development experience with seamless support for various programming languages, frameworks, and tools. It offers a unified interface for all development tasks, making it easier for developers to manage their projects.
Advanced Debugging Tools
Visual Studio's advanced debugging tools are unmatched. It offers powerful features like IntelliTrace, which allows developers to trace and diagnose issues more effectively. Visual Studio Code, while improving, still lacks some of these advanced debugging capabilities.
Extensive Extensions Marketplace
Both Visual Studio and Visual Studio Code have extensive extensions marketplaces, but Visual Studio's marketplace is more mature and offers a wider range of tools and integrations. This makes it easier for developers to find and install the tools they need.
Enterprise Support
For enterprise-level development, Visual Studio provides better support and integration with enterprise tools and services. It offers features like Team Foundation Server (TFS) and Azure DevOps, which are essential for large-scale development projects.
Customization and User Experience
Visual Studio offers extensive customization options, allowing developers to tailor the environment to their specific needs. It provides a more polished and user-friendly experience, especially for long-term projects.
Conclusion
There is a reason why Visual Studio codes icon is not full infinitive loop, while the Visual Studio is full loop. Because there is 1.4 cycle of devops that not covered yet in Visual Studio such as:
IDE vs Codes Editor
Advanced Debugging with AI vs Debugging
High Performance for Large Codebases vs Good for Research / Academic / Small Medium Project
Resource optimizes vs Lightweight
Single platform vs Multiplatform
This article is going with post for Azure Global Bootcamp 2023 that held in Cilacap Indonesia. On this session, I shared about how to use AI in Visual Studio 2022 and Visual Studio Codes, you can grab and see the decks on this post.
If you want to join my live session, you can join at https://bit.ly/globalazure2023 , see you there
As a software engineer, i feel overwhelming with the software development process. Although, it's been more than decades to learn about it and plus my doctoral degree is in software engineering. i don't have any confidence that our software will have less bugs, better performance, and stable architecture. This is because several reasons such as:
requirements changes
lack of better architecture (chaos architecture)
untested software
So my real question is how we create better software and eliminating that problem. Let's think simple solution about this:
Requirements changes --> unavoidable --> we should take care the changes by giving our customer chance to change as long as they pay
Lack of better architecture --> can be avoided --> we should create a standard platform in the team and the architect should maintain the document so it should up to date
Untested software --> can be avoided --> we can create a standard process to make sure the software is tested and the bugs is eliminated.
Requirements Changes
the way to improve the requirement process is by
Creating a series workshop / meeting session to improve the requirement visibility
Managing clear documentation about the requirement and the requirement changes.
Tracking the changes about the requirement and the requirement changes.
So what tool do you have for these:
Azure DevOps
Microsoft Planner
Microsoft OneNote
You can learn further here Manage requirements, Agile methods - Azure DevOps | Microsoft Docs
Lack of Better Architecture
The way to improve better architecture are:
Evaluate the architecture with the architecture best practices
Learning the new technology that can fulfill you architectural need
Implement standardization of your platform and architecture task
So what tool do you have for these:
Visual Studio 2022 or later to check the code map, and code analysis
Visio or PowerPoint to create and propose your architecture work
Azure WIKI to document your architecture
You can learn further about the architecting here
Visual Studio 2022 architecture feature - Architecture analysis & modeling tools - Visual Studio (Windows) | Microsoft Docs
Architecture Center - Azure Architecture Center - Azure Architecture Center | Microsoft Docs
Untested Software
The way to improve your software quality are:
Regular testing. For example, do software testing for each iteration
Creating your testing script. For example, you can create manual testing on Azure DevOps or automated testing with Visual Studio
Get Feedback from customer. Do feedback session with the client for each iteration.
So what tool do you have for these:
Visual Studio unit testing and testing feature
Azure DevOps testing feature
Microsoft Teams for documenting your meeting
You can learn further about the testing here
Unit test tools - Visual Studio (Windows) | Microsoft Docs
What is Azure Test Plans? Manual, exploratory, and automated test tools. - Azure Test Plans | Microsoft Docs