← Back to Dashboard
248
Pages Scanned
50
Pages Flagged
248
Changed Pages
20.2%
% Pages Flagged

Scan Information

Started At: 2026-01-31 00:00:09

Finished At: 2026-02-10 18:44:36

Status: completed

Target Repo: Azure

Current Phase: discovery

Files Queued: 248

Files Completed: 248

Problematic Pages

50 issues found
Application Gateway Tutorial: Improve web application access - Azure Application Gateway .../articles/application-gateway/tutorial-autoscale-ps.md
High Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ powershell_heavy ⚠️ missing_linux_example ⚠️ windows_tools
Summary
The tutorial exclusively uses Azure PowerShell and Windows PowerShell cmdlets for all steps, including certificate creation and file paths. There are no Bash, Azure CLI, or Linux/macOS-specific instructions or examples. Windows tools (e.g., New-SelfSignedCertificate, Export-PfxCertificate) are used for certificate creation, which are not available on Linux/macOS by default.
Recommendations
  • Add equivalent Azure CLI (az) commands for all resource creation and configuration steps, as Azure CLI is cross-platform.
  • Provide instructions for creating self-signed certificates on Linux/macOS (e.g., using OpenSSL) and explain how to export them in PFX format.
  • Use platform-neutral file paths in examples, or clarify differences for Linux/macOS users.
  • Include a note or section for Linux/macOS users outlining how to adapt the tutorial for their environment.
GitHub Create Pull Request
Artifact Signing Set up signing integrations to use Artifact Signing ...ticles/artifact-signing/how-to-signing-integrations.md
High Priority View Details →
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
⚠️ windows_first ⚠️ powershell_heavy ⚠️ windows_tools ⚠️ missing_linux_example
Summary
The documentation for setting up signing integrations with Artifact Signing is heavily focused on Windows. The main integration described in detail is SignTool, which is a Windows-only tool. All installation instructions, examples, and prerequisites are Windows-centric, using PowerShell, MSI installers, WinGet, and referencing Windows SDK components. There are no Linux or macOS equivalents or alternative signing tool instructions provided, nor is there guidance for using Artifact Signing from non-Windows environments. Other integrations (GitHub Actions, Azure DevOps, SDK) are mentioned only briefly and without platform-specific setup details.
Recommendations
  • Add explicit guidance or examples for Linux/macOS users, such as how to use Artifact Signing via the SDK, CLI, or other cross-platform tools.
  • If SignTool is Windows-only, clarify this early and direct Linux/macOS users to supported alternatives (e.g., SDK, GitHub Actions, Azure DevOps).
  • Provide setup instructions for Artifact Signing using the SDK on Linux/macOS, including installation and usage examples.
  • Include a table or section comparing platform support for each integration, so users know which options are available for their OS.
  • Where possible, provide shell (bash) examples alongside PowerShell commands.
GitHub Create Pull Request
Azure Relay https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-relay/includes/relay-hybrid-connections-dotnet-get-started-server.md ...https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-relay/includes/relay-hybrid-connections-dotnet-get-started-server.md
High Priority View Details →
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
⚠️ windows_first ⚠️ missing_linux_example
Summary
The documentation exclusively describes creating a .NET Framework console application using Visual Studio, which is a Windows-only development environment and runtime. There are no instructions or examples for Linux/macOS users, such as using .NET Core/.NET 5+ or cross-platform editors like VS Code. The NuGet package installation and project setup steps are tailored to Visual Studio on Windows, omitting CLI-based or cross-platform alternatives.
Recommendations
  • Add instructions for creating a .NET Core or .NET 5+ console application, which is cross-platform.
  • Include examples for using the dotnet CLI to create projects and install NuGet packages.
  • Mention and provide steps for using cross-platform editors like Visual Studio Code.
  • Clarify if the Microsoft.Azure.Relay package and sample code are compatible with Linux/macOS, and provide any necessary platform-specific notes.
GitHub Create Pull Request
Application Gateway Diagnostic logs ...application-gateway/application-gateway-diagnostics.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ powershell_heavy ⚠️ windows_first ⚠️ missing_linux_example
Summary
The documentation provides explicit instructions for enabling diagnostic logging using PowerShell, but does not offer equivalent examples for Azure CLI, Bash, or other cross-platform tools. The PowerShell method is presented before the Azure portal method, and no Linux/macOS command-line alternatives are mentioned. This creates friction for users who do not use Windows or PowerShell.
Recommendations
  • Add Azure CLI examples for enabling diagnostic logging alongside the PowerShell example.
  • Present cross-platform command-line options (such as Bash/CLI) before or alongside PowerShell to avoid Windows-first bias.
  • Explicitly mention that both PowerShell and Azure CLI can be used, and link to relevant CLI documentation.
  • Include notes or examples for Linux/macOS users where applicable.
GitHub Create Pull Request
Automation Azure Automation data security ...b/main/articles/automation/automation-managing-data.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ windows_first ⚠️ powershell_heavy ⚠️ windows_tools
Summary
The documentation provides both Windows and Linux guidance for TLS configuration, but Windows instructions and references (especially PowerShell cmdlets) are presented first and more frequently. Data retention and backup sections rely heavily on Windows PowerShell cmdlets, with no equivalent CLI or Linux-native examples. Linux guidance is present for TLS, but not for other management tasks.
Recommendations
  • Provide Azure CLI or REST API examples alongside PowerShell cmdlets for resource management and backup tasks.
  • Include Linux/macOS-specific instructions for exporting runbooks and DSC configurations, not just PowerShell-based methods.
  • Present Windows and Linux guidance in parallel, rather than listing Windows first.
  • Reference cross-platform tools where possible, and clarify which steps are platform-agnostic.
GitHub Create Pull Request
Application Gateway Scaling and Zone-redundant Application Gateway v2 ...eway/application-gateway-autoscaling-zone-redundant.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
⚠️ powershell_heavy ⚠️ windows_first
Summary
The documentation page is generally platform-neutral in its conceptual sections, but the 'Next steps' section prominently features a tutorial link that uses Azure PowerShell for creating an autoscaling, zone-redundant Application Gateway. This may suggest a Windows-first approach and PowerShell-heavy bias, as Linux/macOS users typically use Azure CLI or ARM templates. No Linux/macOS-specific examples or alternatives are mentioned.
Recommendations
  • Add links to equivalent tutorials using Azure CLI and ARM/Bicep templates for creating autoscaling, zone-redundant Application Gateways.
  • In the 'Next steps' section, present Azure CLI and template-based options alongside PowerShell, or mention that PowerShell is cross-platform but CLI is preferred on Linux/macOS.
  • Clarify that PowerShell is available on Linux/macOS, or provide guidance for non-Windows users.
GitHub Create Pull Request
Automation Manage certificates in Azure Automation ...n/articles/automation/shared-resources/certificates.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ powershell_heavy ⚠️ windows_tools ⚠️ windows_first
Summary
The documentation page for managing certificates in Azure Automation demonstrates a notable bias towards Windows and PowerShell tooling. PowerShell cmdlets are presented first and in detail, with multiple examples and workarounds recommended via PowerShell. The creation and management of certificates rely heavily on PowerShell and Windows-centric cryptographic providers. Linux/macOS alternatives, such as CLI or bash examples, are absent, and the Python examples are limited to accessing certificates, not managing them. The documentation assumes familiarity with Windows tools and patterns, which may create friction for Linux/macOS users.
Recommendations
  • Add Azure CLI examples for certificate management tasks, including creation, retrieval, and deletion.
  • Include guidance or examples for Linux/macOS users, such as using OpenSSL to prepare certificates for upload.
  • Clarify which steps are platform-agnostic and which require Windows, and provide parity where possible.
  • Expand Python examples to include certificate management, not just retrieval.
  • Explicitly mention any limitations or requirements for non-Windows users when using Azure Automation certificates.
GitHub Create Pull Request
Azure Relay https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-relay/includes/relay-hybrid-connections-http-requests-dotnet-get-started-client.md ...id-connections-http-requests-dotnet-get-started-client.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ windows_tools ⚠️ missing_linux_example ⚠️ windows_first
Summary
The documentation assumes the use of Visual Studio and .NET Framework, both of which are primarily Windows tools. It provides instructions for creating a Console App (.NET Framework) project in Visual Studio, with no mention of cross-platform alternatives such as .NET Core/.NET 5+ or Visual Studio Code. There are no instructions or examples for Linux or macOS users, and the workflow is Windows-centric.
Recommendations
  • Add instructions for creating a cross-platform .NET (Core/5/6/7+) console application using the dotnet CLI, which works on Linux, macOS, and Windows.
  • Mention Visual Studio Code as an alternative IDE, and provide guidance for users on Linux/macOS.
  • Clarify whether the Microsoft.Azure.Relay NuGet package and the sample code are compatible with .NET Core/.NET 5+.
  • If possible, provide a sample using the dotnet CLI to add the NuGet package (e.g., 'dotnet add package Microsoft.Azure.Relay').
  • Explicitly state if the instructions are Windows-only and link to cross-platform guides if available.
GitHub Create Pull Request
Azure Netapp Files Create a capacity pool for Elastic zone-redundant service in Azure NetApp Files ...icles/azure-netapp-files/elastic-capacity-pool-task.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
⚠️ powershell_heavy ⚠️ windows_first
Summary
The documentation mentions PowerShell and the Az.NetAppFiles module explicitly in the 'Before you begin' section, providing update instructions and a link to PowerShell documentation. While Azure CLI and REST API are also referenced, PowerShell is given special attention, and no Linux-specific shell (e.g., Bash) or cross-platform CLI usage examples are provided. The order of mention also places PowerShell before REST API, and there are no Linux/macOS-specific instructions or examples.
Recommendations
  • Add explicit instructions or examples for updating and using the Azure CLI on Linux/macOS, similar to the PowerShell guidance.
  • Include cross-platform CLI commands and clarify that Azure CLI works on Windows, Linux, and macOS.
  • Balance the mention of PowerShell and CLI tools, ensuring that Linux/macOS users are equally supported.
  • Provide links to Azure CLI documentation for Linux/macOS users alongside PowerShell links.
GitHub Create Pull Request
Azure Relay Azure Relay Hybrid Connections - WebSockets in .NET ...e-relay/relay-hybrid-connections-dotnet-get-started.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
⚠️ windows_tools ⚠️ windows_first
Summary
The documentation assumes the use of Visual Studio (a Windows-centric IDE) for all development steps and does not mention or provide guidance for Linux/macOS users or alternative tools (e.g., VS Code, .NET CLI). While the .NET code itself is likely cross-platform, the instructions and prerequisites are Windows/Visual Studio focused.
Recommendations
  • Add instructions for using cross-platform tools such as Visual Studio Code or the .NET CLI (dotnet new, dotnet run) for creating and running the sample applications.
  • Clarify that the code samples work on Linux and macOS, and provide any platform-specific notes if needed.
  • Mention that Visual Studio is optional and that other editors/IDEs can be used.
  • If any steps are Windows-specific (e.g., screenshots, file paths), provide Linux/macOS equivalents or clarify differences.
GitHub Create Pull Request
Azure Relay https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-relay/includes/relay-hybrid-connections-http-requests-dotnet-get-started-server.md ...id-connections-http-requests-dotnet-get-started-server.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ windows_tools ⚠️ windows_first ⚠️ missing_linux_example
Summary
The documentation assumes the use of Visual Studio and .NET Framework, both of which are primarily Windows tools. There are no instructions or examples for creating the project on Linux/macOS (e.g., using .NET Core/SDK and command-line tools like 'dotnet new'), nor any mention of cross-platform editors or workflows.
Recommendations
  • Add instructions for creating the project using the .NET CLI (e.g., 'dotnet new console') for cross-platform compatibility.
  • Clarify whether the Microsoft.Azure.Relay package and code sample work with .NET Core/.NET 5+ on Linux/macOS, and provide guidance if so.
  • Include alternative instructions for installing NuGet packages via the command line (e.g., 'dotnet add package').
  • Mention cross-platform editors like VS Code as alternatives to Visual Studio.
  • If .NET Framework is required and cross-platform is not supported, explicitly state that this sample is Windows-only.
GitHub Create Pull Request
API Center Quickstart - Create Your Azure API Center - ARM Template .../articles/api-center/set-up-api-center-arm-template.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ windows_first ⚠️ powershell_heavy ⚠️ missing_linux_example
Summary
The documentation provides both Azure CLI and Azure PowerShell examples for deploying the ARM template, but PowerShell is given equal prominence despite being Windows-centric. There is no mention of Linux/macOS-specific shell environments or alternative deployment methods (e.g., Bash, scripting on Linux), and PowerShell requirements are listed alongside CLI prerequisites. The order of examples does not strongly favor Windows, but the inclusion of PowerShell as a primary method may create friction for Linux/macOS users.
Recommendations
  • Clarify that Azure CLI works natively on Linux/macOS and provide Bash-specific instructions or notes for Linux users.
  • Mention that Azure Cloud Shell supports both Bash and PowerShell, and highlight Bash as a cross-platform option.
  • Consider listing Azure CLI examples first, as it is cross-platform, and move PowerShell examples to a secondary position.
  • Add a note or section for deploying ARM templates using Bash or other Linux-native tools (e.g., curl, jq, etc.), if applicable.
GitHub Create Pull Request
Automation Use Microsoft Entra ID in Azure Automation to authenticate to Azure ...ob/main/articles/automation/automation-use-azure-ad.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
⚠️ powershell_heavy ⚠️ windows_tools ⚠️ missing_linux_example ⚠️ windows_first
Summary
The documentation is heavily focused on PowerShell and Windows-centric tools and patterns. All code examples and module references are for PowerShell, with no mention of Bash, CLI, or Linux/macOS alternatives. The process for creating credential assets and managing Azure resources is described exclusively using PowerShell cmdlets and Windows-specific concepts (e.g., PSCredential), with no guidance for users who may prefer or require cross-platform approaches.
Recommendations
  • Add equivalent examples using Azure CLI and Bash for credential management and runbook automation.
  • Clarify whether Azure Automation runbooks can be authored and executed using non-PowerShell languages (e.g., Python) and provide examples if supported.
  • Mention cross-platform alternatives to PSCredential and PowerShell modules, or note any platform limitations explicitly.
  • Where PowerShell is required, state that these steps apply to all platforms where PowerShell Core is available, and clarify any Windows-only requirements.
GitHub Create Pull Request
App Service Use TLS/SSL Certificates in App Code ...icles/app-service/configure-ssl-certificate-in-code.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
⚠️ windows_first ⚠️ powershell_heavy ⚠️ missing_linux_example ⚠️ windows_tools
Summary
The documentation page provides detailed, step-by-step examples for accessing TLS/SSL certificates in Windows apps, including C# and Java code for the Windows certificate store. Linux guidance is present but less detailed, with only C# file-based examples and references to external documentation for other languages. Windows-specific tools and patterns (certificate store, environment variables, app settings) are described first and in more depth, while Linux equivalents are mentioned later and with less coverage.
Recommendations
  • Add concrete code examples for loading certificates in popular Linux languages (Node.js, Python, Java, PHP) directly in the documentation, not just references to external docs.
  • Provide more detailed explanation of Linux certificate file formats and access patterns, including security best practices.
  • Balance the order of presentation so Linux and Windows approaches are introduced together, or use tabs to separate platform-specific instructions.
  • Clarify which approaches are cross-platform and which are Windows-only, to reduce confusion.
  • Include troubleshooting tips for Linux users, such as file permissions and environment variable usage.
GitHub Create Pull Request
API Management Deploy an Azure API Management Instance to Multiple Azure Regions ...management/api-management-howto-deploy-multi-region.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ windows_tools ⚠️ powershell_heavy ⚠️ windows_first
Summary
The documentation demonstrates a moderate Windows bias by referencing Azure PowerShell cmdlets (set-azapimanagement) alongside Azure CLI and REST API, and listing PowerShell as a primary tool for managing API Management regional gateways. However, the actual command examples are provided using Azure CLI, which is cross-platform. No Linux-specific tools or shell examples are given, and PowerShell is mentioned before CLI in the list of options for disabling a regional gateway. The overall workflow is portal- and Azure-native, so the impact is moderate.
Recommendations
  • Provide explicit Linux/macOS shell examples (e.g., bash) where CLI commands are shown.
  • Clarify that Azure CLI is fully cross-platform and can be used on Windows, Linux, and macOS.
  • When listing management tools, present Azure CLI before PowerShell to reflect platform neutrality.
  • If PowerShell is mentioned, note that Azure PowerShell is available on Linux/macOS, or link to installation instructions for non-Windows platforms.
  • Add a brief note or section for Linux/macOS users confirming parity of steps and tools.
GitHub Create Pull Request
App Service Install a TLS/SSL Certificate for Your App ...main/articles/app-service/configure-ssl-certificate.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ powershell_heavy ⚠️ windows_tools ⚠️ windows_first
Summary
The documentation provides both Azure CLI and PowerShell examples for RBAC assignment, but PowerShell is given equal prominence, and Windows-specific certificate tooling (IIS, Certreq.exe) is mentioned before Linux alternatives. The FAQ and automation sections also reference PowerShell scripts alongside CLI, and Windows tools are referenced for certificate export. While OpenSSL is documented for Linux/macOS users, Windows-centric tools and patterns are often mentioned first or exclusively.
Recommendations
  • Ensure Linux/macOS alternatives (e.g., OpenSSL) are mentioned before or alongside Windows tools like IIS and Certreq.exe for certificate export.
  • Provide explicit Linux/macOS examples for certificate management tasks where PowerShell or Windows tools are referenced.
  • In automation sections, clarify that Azure CLI works cross-platform and highlight it as the primary example, with PowerShell as a secondary option for Windows users.
  • Where screenshots or UI instructions are given, note any OS-specific differences (if any) for Linux/macOS users.
GitHub Create Pull Request
App Service Environment Variables and App Settings Reference ...ob/main/articles/app-service/reference-app-settings.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
⚠️ windows_first ⚠️ windows_tools ⚠️ powershell_heavy ⚠️ missing_linux_example
Summary
The documentation page covers environment variables and app settings for Azure App Service across Windows and Linux platforms. However, there is a notable Windows-first bias: Windows paths and conventions (e.g., D:\home) are frequently mentioned before Linux equivalents, and some examples and explanations use Windows-centric terminology. Several environment variables and features are described primarily or exclusively for Windows (e.g., IIS, Web Deploy/MSDeploy, machineKey, Jetty/Tomcat settings), with Linux alternatives referenced later or in separate sections. Some settings lack Linux-specific examples or details, and Windows tools (e.g., msbuild, Web Deploy) are discussed without equivalent Linux tooling. While Linux coverage exists (notably Oryx build automation and container settings), the structure and examples tend to prioritize Windows scenarios.
Recommendations
  • Ensure Linux and Windows examples are presented side-by-side or in parallel, rather than Windows-first.
  • Where Windows tools (e.g., msbuild, Web Deploy) are mentioned, provide Linux alternatives or clarify platform applicability.
  • Add Linux-specific examples for environment variables, especially where only Windows paths or conventions are shown.
  • Explicitly indicate platform applicability for each setting, and avoid assuming Windows as the default context.
  • Reorganize sections to alternate or group by platform, reducing implicit prioritization of Windows.
GitHub Create Pull Request
Application Gateway FAQ on V1 retirement ...ob/main/articles/application-gateway/retirement-faq.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ powershell_heavy ⚠️ windows_tools ⚠️ missing_linux_example
Summary
The documentation repeatedly references an Azure PowerShell script as the primary or sole migration tool for moving from Application Gateway V1 to V2. There are no examples or guidance for using Azure CLI, Bash, or other cross-platform tools. The PowerShell script is mentioned as the main automation method, and there is no mention of Linux/macOS compatibility or alternatives, which may create friction for non-Windows users.
Recommendations
  • Provide equivalent Azure CLI or Bash script examples for migration tasks, or explicitly state if only PowerShell is supported.
  • Clarify whether the PowerShell script can be run cross-platform (e.g., with PowerShell Core on Linux/macOS) and provide installation guidance if so.
  • If only PowerShell is supported, offer guidance or workarounds for Linux/macOS users, such as using Azure Cloud Shell.
  • Add notes or links to documentation for running Azure PowerShell on non-Windows platforms.
GitHub Create Pull Request
Automation Disaster recovery for Azure Automation ...in/articles/automation/automation-disaster-recovery.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ powershell_heavy ⚠️ missing_linux_example ⚠️ windows_first
Summary
The documentation for disaster recovery in Azure Automation provides only PowerShell and PowerShell Workflow scripts for migrating Automation account assets, with no mention of Bash, Azure CLI, or Python alternatives. The instructions and examples are Windows-centric, and Linux/macOS users are not given platform-specific guidance or parity in migration tooling. While the feature itself is cross-platform, the operational guidance is heavily biased toward Windows/PowerShell users.
Recommendations
  • Provide equivalent migration scripts or runbooks using Azure CLI, Bash, or Python for Linux/macOS users.
  • Include explicit instructions or examples for importing and executing runbooks from Linux/macOS environments.
  • Clarify any platform limitations and suggest cross-platform best practices for disaster recovery operations.
  • Where PowerShell is required, note how Linux/macOS users can install and use PowerShell Core (pwsh), and provide tested examples for those platforms.
GitHub Create Pull Request
Application Gateway Migrate from V1 to V2 - Azure Application Gateway ...lob/main/articles/application-gateway/migrate-v1-v2.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ powershell_heavy ⚠️ windows_first ⚠️ missing_linux_example
Summary
The documentation for migrating Azure Application Gateway from V1 to V2 is heavily focused on Azure PowerShell scripts, with all migration steps, examples, and code snippets provided exclusively in PowerShell. There is no mention of Bash, Azure CLI, or cross-platform alternatives, nor are there instructions or examples for Linux/macOS users. The guidance assumes familiarity with PowerShell and Windows-centric tooling, which may create friction for users on non-Windows platforms.
Recommendations
  • Provide equivalent migration instructions and examples using Azure CLI (az), which is cross-platform and widely used on Linux/macOS.
  • Include Bash script examples for common operations, such as retrieving resource IDs, uploading certificates, and running migration scripts.
  • Clarify whether the provided PowerShell scripts can be run in Azure Cloud Shell (which supports PowerShell and Bash) and, if so, provide explicit instructions for both environments.
  • Add a section addressing Linux/macOS users, including prerequisites for running PowerShell Core on those platforms if PowerShell scripts are required.
  • Where possible, link to or provide alternative tooling or scripts for users who prefer not to use PowerShell.
GitHub Create Pull Request
Application Gateway What is Azure Application Gateway v2? .../blob/main/articles/application-gateway/overview-v2.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ powershell_heavy ⚠️ windows_first ⚠️ missing_linux_example
Summary
The documentation page for Azure Application Gateway v2 shows a notable Windows bias. Migration guidance and preview registration/unregistration instructions are provided exclusively using Azure PowerShell commands, with no equivalent Azure CLI or Bash examples for Linux/macOS users. The main tutorial linked is PowerShell-based, and PowerShell is mentioned before any cross-platform alternatives. This creates friction for users on Linux or macOS who may prefer or require Azure CLI or Bash.
Recommendations
  • Add Azure CLI and Bash examples for all PowerShell commands, especially for migration and preview registration/unregistration.
  • Link to tutorials that use Azure CLI or Bash, or provide parity for the PowerShell tutorial.
  • Explicitly note that both PowerShell and Azure CLI are supported and provide guidance for choosing the right tool based on OS.
  • Ensure that future documentation sections do not default to PowerShell-only unless the feature is Windows-specific.
GitHub Create Pull Request
Automation Configure runbook input parameters in Azure Automation ...b/main/articles/automation/runbook-input-parameters.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
⚠️ powershell_heavy ⚠️ windows_tools ⚠️ missing_linux_example ⚠️ windows_first
Summary
The documentation is heavily focused on PowerShell and Windows-centric tools and patterns. All code examples for starting and interacting with runbooks use PowerShell cmdlets, C#, or the Azure portal. There are no CLI (az), Bash, or Linux-native examples for assigning parameters or starting runbooks. The PowerShell approach is always presented first and in detail, while Python runbooks are only briefly mentioned, and no Linux/macOS-specific workflows are covered.
Recommendations
  • Add examples using the Azure CLI (az automation runbook start) for starting runbooks and passing parameters, which work cross-platform.
  • Include Bash or shell script examples for Linux/macOS users, especially for tasks like passing JSON files as parameters.
  • Clarify that PowerShell Core (pwsh) is cross-platform and, where possible, provide examples that work on both Windows and Linux.
  • Mention and link to documentation for using the REST API with curl or other cross-platform tools.
  • Balance the order of presentation so that cross-platform methods (CLI, REST) are not always after PowerShell/Windows examples.
GitHub Create Pull Request
Automation Manage credentials in Azure Automation ...in/articles/automation/shared-resources/credentials.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ powershell_heavy ⚠️ windows_tools ⚠️ windows_first
Summary
The documentation is heavily PowerShell-centric, with all CLI examples using Windows PowerShell cmdlets and patterns. Windows tools and terminology (e.g., PSCredential, PowerShell modules) are referenced exclusively or before Python equivalents. There are no examples or guidance for Linux/macOS users who might want to use Azure Automation credentials via Bash, Azure CLI, or other non-Windows scripting environments.
Recommendations
  • Add examples for managing credentials using Azure CLI or REST API, which are cross-platform.
  • Clarify whether PowerShell Core (pwsh) on Linux/macOS is supported for these cmdlets and, if so, provide examples.
  • Explicitly state any platform limitations (e.g., if only Windows PowerShell is supported for certain operations).
  • Provide parity in example ordering: show Python and cross-platform options alongside PowerShell, not after.
  • Mention how Linux/macOS users can interact with Azure Automation credentials, or note if such support is unavailable.
GitHub Create Pull Request
Azure App Configuration Configuration Provider Overview ...e-app-configuration/configuration-provider-overview.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ windows_first ⚠️ powershell_heavy ⚠️ missing_linux_example
Summary
The documentation page lists configuration provider libraries for multiple languages and platforms, but .NET and ASP.NET Core (Windows-centric technologies) are presented first in all tables and examples. All .NET sample links point to repositories and samples that are typically Windows-oriented (.NET Framework, ASP.NET Core), with no explicit mention of Linux/macOS compatibility or equivalent Linux-first examples. There is no discussion of Linux-specific configuration patterns, nor are Linux/macOS usage scenarios highlighted. The page implicitly prioritizes Windows/.NET technologies, which may create friction for Linux/macOS users.
Recommendations
  • Add explicit notes or sections clarifying cross-platform compatibility for .NET Core and ASP.NET Core libraries, including Linux/macOS usage.
  • Provide sample links or code snippets demonstrating usage on Linux/macOS environments (e.g., running .NET Core on Ubuntu, using Python/Go/JavaScript providers on Linux).
  • Reorder the provider library tables to alternate or group by platform/language rather than always listing Windows-centric technologies first.
  • Include references to Linux/macOS configuration patterns or tools where relevant.
  • Ensure that documentation samples and guides are not exclusively Windows/PowerShell-based, and provide Bash or Linux shell equivalents where appropriate.
GitHub Create Pull Request
Azure Change Tracking Inventory Azure Change Tracking and Inventory Overview by Using Azure Monitor Agent ...change-tracking-inventory/overview-monitoring-agent.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ windows_first ⚠️ windows_tools ⚠️ missing_linux_example
Summary
The documentation generally presents Change Tracking and Inventory as cross-platform, supporting both Windows and Linux. However, there is a notable bias in the 'Track registry keys' section, which exclusively discusses Windows registry monitoring with no mention of Linux equivalents (such as tracking changes to key Linux configuration files or directories). Additionally, the registry section provides a detailed table of Windows-specific keys without offering a comparable Linux-focused example or explanation. In several sections, Windows terminology and tools (e.g., registry, Group Policy, Internet Explorer) are mentioned without Linux analogs, and Windows is often listed first when both platforms are referenced.
Recommendations
  • Add a section or table describing Linux-specific change tracking capabilities, such as monitoring changes to important configuration files (e.g., /etc/passwd, /etc/ssh/sshd_config) or systemd service files.
  • When listing features or examples, alternate the order or explicitly mention Linux alongside Windows to reinforce parity.
  • In the 'Track registry keys' section, clarify that registry monitoring is Windows-specific and provide a parallel explanation for what is monitored on Linux (e.g., tracked files, daemons, or configuration directories).
  • Include Linux-specific screenshots or examples where possible, especially in sections that currently only reference Windows concepts.
GitHub Create Pull Request
Azure Functions Deployment technologies in Azure Functions ...s/azure-functions/functions-deployment-technologies.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ windows_first ⚠️ powershell_heavy ⚠️ missing_linux_example
Summary
The documentation generally presents deployment technologies in a cross-platform manner, but there is a subtle Windows bias. Windows-specific deployment options (like source control, local Git, FTPS) are called out in the technology availability table, and Windows is often mentioned first in lists and explanations. Some examples and instructions (such as trigger syncing and remote build) focus on Windows tools or behaviors before Linux equivalents. Linux-specific deployment nuances are covered, but sometimes as secondary details. There are few explicit Linux command-line examples, and some deployment methods (like source control, local Git, FTPS) are described as 'Windows-only' without offering Linux alternatives or workarounds.
Recommendations
  • Provide Linux/macOS-specific examples and instructions alongside Windows ones, especially for deployment methods that differ between OSes.
  • Where deployment methods are Windows-only, clarify Linux alternatives or explicitly state that no equivalent exists.
  • Ensure that Linux deployment workflows (e.g., remote build, Docker, external package URL) are given equal prominence and detail as Windows workflows.
  • Add more Azure CLI and bash examples for Linux users, especially for common tasks like trigger syncing and deployment.
  • Review the order of presentation to avoid consistently listing Windows options first.
GitHub Create Pull Request
Azure Functions Migrate C# app from in-process to isolated worker model ...es/azure-functions/migrate-dotnet-to-isolated-model.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ powershell_heavy ⚠️ windows_first ⚠️ missing_linux_example
Summary
The documentation page demonstrates a Windows bias primarily in the 'Identify function apps to migrate' section, where only Azure PowerShell is used to enumerate function apps. There are no CLI (az) or Bash examples, and PowerShell is presented as the sole method. Additionally, Visual Studio is mentioned as a publishing tool, which is Windows-centric, and appears before VS Code or cross-platform alternatives. No Linux/macOS-specific instructions or parity examples are provided for these steps.
Recommendations
  • Add equivalent Azure CLI (az) and Bash examples for identifying function apps using the in-process model, ensuring Linux/macOS users can follow along without PowerShell.
  • Explicitly mention cross-platform tools (e.g., VS Code, Azure CLI) for publishing and managing Azure Functions, and provide instructions for these tools alongside Visual Studio.
  • Where PowerShell is used, clarify that it is optional and provide links or code blocks for Linux/macOS alternatives.
  • Consider reordering examples so that cross-platform methods are presented first or in parallel with Windows-specific tools.
GitHub Create Pull Request
Azure Functions Migrate Consumption plan apps to Flex Consumption in Azure Functions ...unctions/migration/migrate-plan-consumption-to-flex.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ windows_first ⚠️ powershell_heavy ⚠️ missing_linux_example
Summary
The documentation provides both Linux and Windows migration paths, but Windows examples and instructions are often presented first or in greater detail, especially in the 'platform-windows' pivots. While Linux migration is supported and even prioritized in some sections (notably with the dedicated az functionapp flex-migration CLI for Linux), Windows instructions are more verbose, and some CLI scripts and troubleshooting steps are Windows-centric. There are also sections where Linux-specific examples or parity are lacking, such as in infrastructure-as-code and troubleshooting scripts.
Recommendations
  • Ensure Linux and Windows instructions/examples are presented with equal detail and prominence, possibly alternating which comes first.
  • Expand Linux-specific troubleshooting and migration scripts to match the depth provided for Windows.
  • Where possible, provide Linux shell (bash) equivalents for PowerShell-heavy or Windows-centric CLI examples.
  • In infrastructure-as-code sections, ensure Linux examples are as complete and easy to follow as Windows ones.
  • Add explicit notes when a feature or command is Windows-only, and suggest Linux alternatives or workarounds.
GitHub Create Pull Request
Azure Government Azure guidance for secure isolation ...es/azure-government/azure-secure-isolation-guidance.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ windows_tools ⚠️ windows_first ⚠️ powershell_heavy
Summary
The documentation is generally cross-platform and covers both Windows and Linux scenarios for Azure isolation, but there are notable instances of Windows bias. Windows technologies (such as Hyper-V, BitLocker, Windows Firewall) are referenced more frequently and in greater detail than their Linux equivalents. In several sections, Windows tools and patterns are described first or exclusively, with Linux alternatives mentioned later or in less detail. PowerShell is often referenced as a primary automation tool, with Azure CLI or Linux-native tools mentioned secondarily. However, Linux support is acknowledged and Linux-specific guidance is provided in most critical areas.
Recommendations
  • Ensure Linux examples and tools (e.g., Azure CLI, SSH, DM-Crypt) are presented alongside or before Windows/PowerShell equivalents where possible.
  • Expand explanations of Linux-native technologies (e.g., DM-Crypt, iptables, firewalld) to match the depth given to Windows technologies like BitLocker and Windows Firewall.
  • Where PowerShell is referenced for automation, provide parallel Azure CLI or bash script examples.
  • Review sections where Windows tools or terminology are used generically (e.g., 'Windows Firewall') and clarify when Linux alternatives are available or applicable.
  • In tables and lists, alternate the order of Windows and Linux examples to avoid a persistent 'Windows-first' impression.
GitHub Create Pull Request
Azure Netapp Files SMB performance best practices for Azure NetApp Files ...ure-netapp-files/azure-netapp-files-smb-performance.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
⚠️ windows_first ⚠️ powershell_heavy ⚠️ windows_tools ⚠️ missing_linux_example
Summary
The documentation is heavily Windows-centric, with all configuration and monitoring examples using Windows commands (PowerShell, perfmon), Windows networking tools, and references to Windows Server/Windows 10. There are no Linux/macOS SMB client examples, nor any mention of how to achieve similar monitoring or configuration on non-Windows platforms, despite SMB being a cross-platform protocol. Linux tools, commands, and client behaviors are absent, and Windows terminology is used exclusively throughout.
Recommendations
  • Add SMB client configuration and performance tuning examples for Linux (e.g., using mount.cifs, smbclient, or kernel parameters).
  • Include Linux/macOS equivalents for monitoring SMB connections, such as using 'smbstatus', 'netstat', or system metrics.
  • Document how to check for SMB Multichannel and encryption support on Linux clients.
  • Clarify which recommendations are Windows-specific and provide parity guidance for other platforms.
  • Reference Linux SMB client documentation and best practices where appropriate.
GitHub Create Pull Request
Azure Netapp Files Create volume replication for Azure NetApp Files ...etapp-files/cross-region-replication-create-peering.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
⚠️ powershell_heavy ⚠️ windows_first
Summary
The documentation page provides Azure PowerShell examples first and in detail for feature registration, with only a brief mention of Azure CLI as an alternative. The step-by-step instructions and screenshots are focused on the Azure Portal UI, which is cross-platform, but the command-line guidance is Windows/PowerShell-centric, potentially creating friction for Linux/macOS users who typically use Azure CLI.
Recommendations
  • Provide full Azure CLI command examples alongside PowerShell for feature registration and status checking, with equivalent step-by-step instructions.
  • Consider listing CLI examples before or alongside PowerShell to avoid Windows-first perception.
  • Clarify that both Azure CLI and PowerShell are supported, and link to relevant CLI documentation.
  • Add notes or sections for Linux/macOS users where command syntax or tooling may differ.
GitHub Create Pull Request
Azure Relay Authenticate from an application - Azure Relay .../main/articles/azure-relay/authenticate-application.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ windows_first ⚠️ powershell_heavy ⚠️ missing_linux_example
Summary
The documentation primarily features .NET (C#) console application samples and highlights PowerShell for role assignment, which are Windows-centric technologies. While Java and JavaScript samples are mentioned, the main walkthrough and code snippets are exclusively .NET/C#, with no explicit Linux/macOS instructions or parity in example ordering. Azure CLI is referenced only in the 'Next steps' section, after PowerShell.
Recommendations
  • Provide step-by-step instructions and code samples for Java and JavaScript applications, not just .NET/C#.
  • Include explicit instructions for running samples on Linux/macOS, such as prerequisites, environment setup, and command-line usage.
  • Present Azure CLI examples before or alongside PowerShell for role assignments, as CLI is cross-platform.
  • Clarify that the .NET sample can be run on Linux/macOS using .NET Core/.NET 5+ if applicable, and provide guidance for doing so.
  • Ensure all sample links are accompanied by brief instructions or notes about platform compatibility.
GitHub Create Pull Request
Azure Relay Authenticate with managed identities for Azure Relay resources .../articles/azure-relay/authenticate-managed-identity.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ windows_first ⚠️ missing_linux_example ⚠️ windows_tools
Summary
The documentation primarily guides users through authenticating with managed identities for Azure Relay resources using a Windows VM. All step-by-step instructions, including VM creation, enabling managed identity, copying files, and running the sample, are Windows-specific. There are no equivalent instructions or explicit guidance for Linux or macOS users, despite the cross-platform nature of managed identities and the availability of .NET Core/Java/JavaScript samples that can run on non-Windows platforms.
Recommendations
  • Add parallel instructions for creating and configuring a Linux VM, including enabling managed identity for Linux VMs.
  • Provide examples or notes on how to copy files and run the sample app on Linux (e.g., using SSH/SCP instead of RDP).
  • Clarify that the .NET sample can run on Linux if using .NET Core/5+ and provide relevant build/run instructions.
  • Include sample commands or scripts for Linux/macOS environments where applicable.
  • Reorder or balance the presentation so that Linux/macOS options are not secondary to Windows.
GitHub Create Pull Request
Azure Relay https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-relay/includes/relay-hybrid-connections-dotnet-get-started-client.md ...https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-relay/includes/relay-hybrid-connections-dotnet-get-started-client.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
⚠️ windows_first ⚠️ missing_linux_example
Summary
The documentation is written with a Windows-first approach, instructing users to create a .NET Framework console application in Visual Studio and referencing Windows-specific workflows (e.g., right-clicking in Visual Studio to manage NuGet packages). There are no instructions or examples for Linux/macOS users, such as using .NET Core/.NET 5+ (which is cross-platform), command-line alternatives to Visual Studio, or platform-agnostic project creation and package management.
Recommendations
  • Add instructions for creating a .NET (Core/5+) console application using the 'dotnet' CLI, which works on Linux/macOS as well as Windows.
  • Include steps for installing the Microsoft.Azure.Relay NuGet package via the command line (e.g., 'dotnet add package Microsoft.Azure.Relay').
  • Clarify that the sample code works with .NET Core/.NET 5+ and is not limited to .NET Framework, or provide a separate section for cross-platform usage.
  • Mention alternative code editors (e.g., VS Code) and workflows for non-Windows environments.
  • Explicitly state any Windows-only requirements if applicable, or highlight cross-platform compatibility.
GitHub Create Pull Request
Azure Relay Configure IP firewall for Azure Relay namespace ...n/articles/azure-relay/ip-firewall-virtual-networks.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
⚠️ windows_first ⚠️ missing_linux_example
Summary
The documentation provides instructions for configuring IP firewall rules for Azure Relay namespaces primarily via the Azure portal and Resource Manager templates. However, when referencing deployment of the ARM template, it links specifically to PowerShell-based instructions, with no mention of Linux/macOS CLI alternatives (such as Azure CLI or Bash). This creates a subtle Windows-first bias and omits Linux/macOS-friendly guidance.
Recommendations
  • Add instructions or links for deploying Resource Manager templates using Azure CLI (az deployment group create) and Bash, which are cross-platform and commonly used on Linux/macOS.
  • When referencing deployment methods, mention both PowerShell and Azure CLI options, and order them neutrally or based on platform relevance.
  • Consider including example commands for both PowerShell and Azure CLI to ensure parity for Linux/macOS users.
GitHub Create Pull Request
Azure Relay Hybrid Connections - HTTP requests in .NET ...ay-hybrid-connections-http-requests-dotnet-get-started.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
⚠️ windows_first ⚠️ missing_linux_example
Summary
The documentation assumes use of Visual Studio on Windows and does not mention or provide examples for developing or running the .NET applications on Linux or macOS. All instructions and tooling references are Windows-centric, with no guidance for cross-platform development environments.
Recommendations
  • Add instructions for creating and running the .NET console applications using cross-platform tools such as VS Code, JetBrains Rider, or the .NET CLI.
  • Clarify that .NET Core/.NET 5+ applications can be developed and run on Linux and macOS, and provide example commands for these platforms.
  • Include steps for installing the .NET SDK on Linux/macOS and running the applications from the terminal.
  • Mention alternative editors (e.g., VS Code) and provide parity in screenshots or walkthroughs.
GitHub Create Pull Request
Azure Relay Integrate Azure Relay with Azure Private Link Service ...blob/main/articles/azure-relay/private-link-service.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ powershell_heavy ⚠️ missing_linux_example ⚠️ windows_first
Summary
The documentation provides detailed instructions for integrating Azure Relay with Azure Private Link Service, but it shows a notable Windows bias. The only CLI automation example is in Azure PowerShell, with no equivalent Azure CLI (cross-platform) or Bash example. The validation steps explicitly instruct users to create a Windows VM, with no mention of Linux VMs or alternative OS options. This creates friction for Linux/macOS users and suggests a Windows-centric approach.
Recommendations
  • Add equivalent Azure CLI (az) examples for creating private endpoints and related resources, as Azure CLI is cross-platform and widely used on Linux/macOS.
  • In the validation section, provide instructions for creating and using a Linux VM (e.g., Ubuntu) in addition to the Windows VM example. Show how to run nslookup or dig on Linux.
  • When referencing command-line operations, avoid assuming the user is on Windows. Use neutral language or provide both Windows and Linux/macOS options.
  • If screenshots are needed, consider including at least one from a Linux VM for parity.
  • Explicitly mention that the steps work on both Windows and Linux unless there is a genuine limitation.
GitHub Create Pull Request
API Center Include file ...ter/includes/configure-managed-identity-apim-reader.md
Low Priority View Details →
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
⚠️ windows_first ⚠️ powershell_heavy
Summary
The documentation provides both Bash and PowerShell examples for Azure CLI commands, but PowerShell examples are shown immediately after Bash for every step, rather than grouping them separately or indicating platform parity. There is a slight Windows-first bias in the formatting and example presentation, but Linux users are not blocked from completing the task.
Recommendations
  • Clearly label Bash and PowerShell examples with platform tags (e.g., 'Linux/macOS' and 'Windows') to help users quickly find relevant instructions.
  • Consider grouping Bash and PowerShell examples under separate headings or tabs for clarity.
  • Ensure that Bash examples are shown first or equally, to avoid implicit prioritization of Windows/PowerShell.
  • Add a brief note clarifying that both Bash and PowerShell are supported and that users should choose the appropriate example for their platform.
GitHub Create Pull Request
API Center Include file .../includes/configure-managed-identity-kv-secret-user.md
Low Priority View Details →
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
⚠️ powershell_heavy ⚠️ windows_first
Summary
The documentation provides both Bash and PowerShell examples for Azure CLI commands, but the PowerShell examples are labeled as 'Formatted for PowerShell' and are always presented immediately after the Bash examples. There is a slight bias toward Windows/PowerShell by including PowerShell-specific syntax, which is primarily relevant for Windows users. However, Bash examples are present and shown first, ensuring Linux/macOS users are not blocked.
Recommendations
  • Clarify in the documentation that both Bash and PowerShell examples are provided for user convenience.
  • Consider labeling the Bash examples as 'Bash (Linux/macOS)' and the PowerShell examples as 'PowerShell (Windows)' for clarity.
  • If possible, group the examples under tabs (e.g., 'Bash', 'PowerShell') to make it easier for users to find the relevant syntax for their platform.
  • Ensure that any PowerShell-specific variables or syntax are explained for users who may be less familiar with PowerShell.
GitHub Create Pull Request
API Center Import APIs from Azure API Management - Azure API Center ...main/articles/api-center/import-api-management-apis.md
Low Priority View Details →
Reviewed by: LLM Analysis
Issues: 1 bias type
Detected Bias Types
⚠️ windows_first
Summary
The documentation provides Azure CLI command examples for both bash and PowerShell shells throughout, with PowerShell examples consistently shown second. There is no exclusive use of Windows tools or patterns, and Linux/macOS users are given parity in command examples and instructions.
Recommendations
  • Maintain the current parity by continuing to provide both bash and PowerShell examples.
  • Consider explicitly mentioning macOS compatibility alongside Linux when referencing bash shell usage.
  • If future updates add troubleshooting or environment setup steps, ensure Linux/macOS instructions are included and not Windows-first.
GitHub Create Pull Request
App Service Migrate from gateway-based to regional virtual network integration .../app-service/migrate-gateway-based-vnet-integration.md
Low Priority View Details →
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
⚠️ windows_first ⚠️ powershell_heavy
Summary
The documentation provides examples for Azure portal, Azure CLI, and Azure PowerShell for all major steps. However, PowerShell examples are always included and shown after CLI, and the CLI examples use Azure CLI (which is cross-platform), but there is a subtle bias in the ordering and inclusion: PowerShell is a Windows-centric tool, and its inclusion in every example may signal a slight Windows-first mindset. The documentation does not omit Linux/macOS-compatible instructions, as Azure CLI is fully supported on those platforms. There are no Windows-only tools or patterns, and no critical steps are Windows-exclusive.
Recommendations
  • Consider clarifying that Azure PowerShell is available cross-platform (Windows, Linux, macOS) to avoid the impression that it is Windows-only.
  • Explicitly mention that Azure CLI is recommended for Linux/macOS users, and PowerShell is optional.
  • If possible, alternate the order of CLI and PowerShell examples, or group them under 'cross-platform' and 'Windows PowerShell' headings.
  • Add a brief note for Linux/macOS users confirming that all steps can be completed using Azure CLI.
GitHub Create Pull Request
App Service Azure App Service Plans ...ob/main/articles/app-service/overview-hosting-plans.md
Low Priority View Details →
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
⚠️ windows_first ⚠️ missing_linux_example
Summary
The documentation is generally neutral regarding Windows and Linux, describing App Service plans and their features for both operating systems. However, there is some Windows bias in the 'Managed Instance on Azure App Service (preview)' section, which is Windows-only and highlights Windows-specific features and tools (e.g., PowerShell, RDP, IIS customization) without mentioning Linux equivalents or alternatives. Additionally, links such as 'App Service plan details' point to Windows pricing by default, and there are no Linux-specific examples or explicit parity notes for features that differ between OSes.
Recommendations
  • Clearly indicate when features (such as Managed Instance) are Windows-only and provide links or notes about Linux alternatives or roadmap if available.
  • Where possible, include Linux-specific examples, especially for configuration, scaling, and deployment scenarios.
  • Ensure pricing and feature comparison tables reference both Windows and Linux plans, or clarify differences.
  • Add parity notes for features that differ between Windows and Linux (e.g., supported runtimes, networking, scaling options).
GitHub Create Pull Request
Application Gateway Quickstart: Deploy Application Gateway for Containers ALB Controller ...ploy-application-gateway-for-containers-alb-controller.md
Low Priority View Details →
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
⚠️ windows_first ⚠️ powershell_heavy
Summary
The documentation provides both Windows and Linux instructions for installing Helm, but the Windows example (using PowerShell and winget) is presented first, and the Linux example second. The only explicit OS-specific example is for Helm installation, and the Windows instructions use PowerShell syntax and Windows tooling (winget). All other commands are cross-platform (Azure CLI, Helm, kubectl, Bash-style variables), and the documentation generally assumes a CLI/Bash environment, which is compatible with Linux/macOS and Windows (with WSL or PowerShell).
Recommendations
  • Present Linux and Windows installation instructions for Helm in parallel tabs or sections, or list Linux first to match the majority of AKS users.
  • Clarify that Azure CLI, Helm, and kubectl commands are cross-platform and provide notes for Windows users about using PowerShell or WSL where appropriate.
  • For Windows instructions, mention that Bash-style variable syntax may need adjustment in PowerShell (e.g., $VAR vs $env:VAR).
  • Ensure parity in troubleshooting notes for both platforms if issues arise during installation.
GitHub Create Pull Request
Azure Functions Guide for running C# Azure Functions in an isolated worker process ...icles/azure-functions/dotnet-isolated-process-guide.md
Low Priority View Details →
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
⚠️ windows_first ⚠️ windows_tools
Summary
The documentation provides a comprehensive, cross-platform guide for running C# Azure Functions in an isolated worker process. However, there are several instances where Windows tools, commands, or configuration steps are mentioned before their Linux equivalents, and some sections (such as ReadyToRun and preview .NET SDK configuration) present Windows examples first or in more detail. Azure PowerShell is also listed as a resource creation method alongside Azure CLI, but not all Linux users will have access to PowerShell by default. Despite these minor biases, Linux and macOS users are generally well-supported, with explicit Linux sections, commands, and deployment guidance.
Recommendations
  • Wherever possible, present Linux and Windows examples side-by-side or in parallel tabs, rather than listing Windows first.
  • When referencing Azure PowerShell, clarify that it is cross-platform but may not be installed by default on Linux/macOS, and recommend Azure CLI as the default for cross-platform scenarios.
  • Ensure that all CLI commands (e.g., for checking/changing app architecture, setting configuration values) are shown for both Windows and Linux, or clarify when they are identical.
  • In sections like ReadyToRun and preview .NET SDK, ensure Linux examples are as detailed and prominent as Windows examples.
  • Consider adding explicit notes or links for macOS users where relevant, especially for local development and deployment.
  • Continue to avoid bias in future updates by reviewing the order and prominence of OS-specific instructions.
GitHub Create Pull Request
Azure Functions App settings reference for Azure Functions ...ain/articles/azure-functions/functions-app-settings.md
Low Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ windows_first ⚠️ windows_tools ⚠️ powershell_heavy
Summary
The documentation is generally cross-platform and covers both Windows and Linux scenarios for Azure Functions app settings. However, there are some minor biases: Windows examples (e.g., path syntax, environment variable delimiters) are occasionally shown first or exclusively, PowerShell-specific settings are documented in detail, and Windows tools (e.g., Azure PowerShell) are mentioned before Linux equivalents (e.g., Azure CLI) in some guidance. Most settings are OS-agnostic, and Linux-specific notes are present where relevant.
Recommendations
  • Where path examples are given (e.g., AzureWebJobs_TypeScriptPath), provide both Windows and Linux path syntax.
  • When discussing environment variable delimiters, clarify Linux behavior with examples (e.g., colons vs double-underscores).
  • In sections suggesting programmatic management (e.g., 'use Azure CLI or Azure PowerShell'), list Azure CLI first or provide equal prominence to both tools.
  • For PowerShell-specific settings, ensure parity by referencing equivalent settings or behaviors for other languages where applicable.
  • In tables or lists that show OS-specific settings (e.g., WEBSITE_TIME_ZONE), ensure both Windows and Linux examples are present and equally visible.
GitHub Create Pull Request
Azure Cache For Redis Azure Cache for Redis with Azure Private Link ...n/articles/azure-cache-for-redis/cache-private-link.md
Low Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ windows_first ⚠️ powershell_heavy ⚠️ missing_linux_example
Summary
The documentation provides step-by-step instructions primarily using the Azure portal UI and Azure PowerShell, with PowerShell examples appearing before Azure CLI. While Azure CLI is cross-platform, the prominence and ordering of PowerShell (which is traditionally Windows-centric) may create a perception of Windows bias. There are no explicit Linux/macOS-specific examples or notes, and no mention of Linux tools or shell patterns (e.g., Bash scripting). The portal instructions are platform-neutral, but command-line automation is shown first with PowerShell, then CLI.
Recommendations
  • Present Azure CLI examples before or alongside PowerShell examples, as CLI is cross-platform and preferred by many Linux/macOS users.
  • Add explicit notes clarifying that Azure CLI commands work on Linux/macOS and Windows.
  • Include Bash shell variable syntax in CLI examples, or provide both Bash and PowerShell variable assignment styles.
  • Where relevant, mention that PowerShell Core is available cross-platform, but clarify that traditional Windows PowerShell is Windows-only.
  • Add links or references to Linux/macOS-specific guidance for Azure Cache for Redis, if available.
GitHub Create Pull Request
Azure Functions Storage considerations for Azure Functions ...ain/articles/azure-functions/storage-considerations.md
Low Priority View Details →
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
⚠️ windows_first ⚠️ powershell_heavy
Summary
The documentation generally covers both Windows and Linux hosting scenarios for Azure Functions, with explicit notes about plan support and Linux-specific features (such as mounting Azure Files). However, there are some instances of Windows bias: Windows plans are mentioned first in several places, and PowerShell examples are provided alongside Azure CLI, but not Bash or other Linux-native scripting. Some settings and features are described as 'Windows only' before Linux equivalents, and the documentation occasionally defaults to Windows terminology or order.
Recommendations
  • Ensure that Linux and macOS hosting scenarios are described with equal prominence and clarity as Windows scenarios.
  • Provide Bash or Linux-native scripting examples alongside PowerShell, especially in sections where Azure CLI is used.
  • When listing hosting plan support or configuration settings, alternate or balance the order so Linux is not always listed after Windows.
  • Where features differ between platforms, provide clear guidance for both, and link to Linux/macOS-specific documentation where appropriate.
GitHub Create Pull Request
Azure Netapp Files Azure NetApp Files for Azure Government ...b/main/articles/azure-netapp-files/azure-government.md
Low Priority View Details →
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
⚠️ windows_first ⚠️ powershell_heavy
Summary
The documentation provides access instructions for Azure NetApp Files in Azure Government via the portal, Azure CLI, REST API, and PowerShell. While CLI and REST API methods are platform-agnostic, the PowerShell section is detailed and includes multiple connection types and commands. PowerShell instructions are given their own section and are more extensive than for other platforms. The order of sections places PowerShell after CLI and REST API, but the PowerShell section is notably more detailed. There are no Linux/macOS-specific examples or mentions of Bash, Cloud Shell, or other non-Windows tools. However, the CLI instructions are sufficient for Linux/macOS users, and the feature itself is not Windows-specific.
Recommendations
  • Add explicit mention that Azure CLI is cross-platform and works on Linux/macOS as well as Windows.
  • Include Bash or shell script examples for connecting via CLI, if applicable.
  • Clarify that PowerShell Core is available on Linux/macOS, or provide links to cross-platform PowerShell installation guides.
  • Consider adding a note or section for Linux/macOS users to highlight parity and any platform-specific considerations.
GitHub Create Pull Request
Azure Netapp Files Configure customer-managed keys for Azure NetApp Files volume encryption .../azure-netapp-files/configure-customer-managed-keys.md
Low Priority View Details →
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
⚠️ windows_first ⚠️ powershell_heavy
Summary
The documentation provides both Azure CLI and Azure PowerShell examples for configuring customer-managed keys for Azure NetApp Files. However, PowerShell examples are given equal prominence as CLI, and in some sections, PowerShell is referenced before CLI. There are no Linux-specific shell examples (e.g., Bash), and PowerShell is a Windows-centric tool, which may create friction for Linux/macOS users. The CLI examples are cross-platform, but the presence and prominence of PowerShell may signal a slight Windows bias.
Recommendations
  • Ensure Azure CLI examples are shown first, as CLI is cross-platform and preferred for Linux/macOS users.
  • Add explicit Bash shell examples where relevant, especially for scripting tasks (e.g., using variables, piping outputs).
  • Clarify that PowerShell examples are optional and primarily for Windows users, while CLI is recommended for Linux/macOS.
  • Consider adding a short note at the top of the examples section indicating CLI is cross-platform and PowerShell is Windows-centric.
  • Review screenshots and UI references to ensure they do not assume a Windows environment (e.g., avoid showing Windows-only UI elements if not necessary).
GitHub Create Pull Request
Azure Netapp Files Troubleshoot volume errors for Azure NetApp Files ...in/articles/azure-netapp-files/troubleshoot-volumes.md
Low Priority View Details →
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
⚠️ windows_first ⚠️ powershell_heavy
Summary
The documentation provides troubleshooting steps for Azure NetApp Files volumes across SMB, NFS, and dual-protocol scenarios. While the content covers both Windows (SMB/AD DS) and Linux (NFS) environments, there is a tendency to present Windows/Active Directory concepts and tools first, and PowerShell is used for some administrative examples (e.g., setting Kerberos encryption type). Linux-specific commands and troubleshooting steps are present, but Windows-centric terminology and tools (such as 'Active Directory Users and Computers', PowerShell, and AD DS group memberships) are often mentioned before Linux equivalents, and some steps assume familiarity with Windows administration.
Recommendations
  • Where PowerShell commands are given (e.g., Set-ADComputer), provide equivalent instructions for Linux environments (such as using ldapmodify or samba-tool where appropriate).
  • When referencing 'Active Directory Users and Computers', clarify how similar tasks can be performed from Linux (e.g., via LDAP tools or command-line utilities).
  • Ensure that troubleshooting steps for NFS and Kerberos on Linux are as detailed as those for SMB/AD DS on Windows, including example commands and configuration file locations.
  • Present Linux and Windows examples side-by-side, or alternate which is shown first, to avoid implicit prioritization.
  • Explicitly mention cross-platform tools and workflows where possible, and link to Linux/macOS-specific documentation for AD integration.
GitHub Create Pull Request