← Back to Dashboard
251
Pages Scanned
51
Pages Flagged
251
Changed Pages
20.3%
% Pages Flagged

Scan Information

Started At: 2026-01-30 00:00:06

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

Status: completed

Target Repo: Azure

Current Phase: discovery

Files Queued: 251

Files Completed: 251

Problematic Pages

51 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: 4 bias types
Detected Bias Types
⚠️ powershell_heavy ⚠️ windows_tools ⚠️ missing_linux_example ⚠️ windows_first
Summary
This tutorial is heavily focused on Azure PowerShell and Windows tools, with all examples and instructions using PowerShell cmdlets and Windows-specific certificate creation/export commands. There are no CLI (az), Bash, or Linux/macOS alternatives provided, and the certificate steps rely on Windows-only PowerShell modules. The documentation assumes a Windows environment throughout, creating friction for Linux/macOS users.
Recommendations
  • Provide equivalent Azure CLI (az) commands for all resource creation and management steps.
  • Include instructions for creating self-signed certificates on Linux/macOS (e.g., using OpenSSL), and show how to export to PFX format.
  • Clarify which steps are Windows-specific and offer cross-platform alternatives where possible.
  • Reorganize examples so that cross-platform methods (Azure CLI, OpenSSL) are presented alongside or before Windows/PowerShell examples.
GitHub Create Pull Request
Azure Relay Tutorial: REST tutorial using Azure Relay ...rticles/azure-relay/service-bus-relay-rest-tutorial.md
High Priority View Details →
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
⚠️ windows_tools ⚠️ powershell_heavy ⚠️ windows_first ⚠️ missing_linux_example
Summary
The tutorial is heavily focused on Windows development environments and tools, specifically Visual Studio and the Windows Communication Foundation (WCF) REST programming model. All examples use C#/.NET Framework and Visual Studio, with instructions tailored to Windows workflows (e.g., 'Run as administrator', Solution Explorer, .NET Framework Console App). There are no Linux/macOS equivalents or cross-platform alternatives provided, and the documentation does not mention how to perform these steps on non-Windows systems or using cross-platform .NET (Core/5+).
Recommendations
  • Clarify early in the tutorial that the WCF REST programming model and WCF Relay are Windows-centric and require .NET Framework, which is only supported on Windows.
  • If possible, mention or link to cross-platform alternatives for Azure Relay (such as using .NET Core/.NET 5+ with Azure Relay SDK, or using REST APIs directly).
  • Provide guidance for Linux/macOS users, such as using Visual Studio Code with .NET Core if any part of the workflow is supported, or explicitly state that the tutorial is Windows-only.
  • Add a note in the prerequisites section about platform limitations and recommend alternatives for non-Windows users.
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 PowerShell-centric, with all code examples and module references using PowerShell. It specifically mentions 'Windows PowerShell' and does not provide any examples or guidance for Bash, Azure CLI, or cross-platform scripting. Linux/macOS users are not given equivalent examples or instructions, which may create friction for those not using Windows or PowerShell.
Recommendations
  • Add Azure CLI (az) examples for authentication and credential management alongside PowerShell examples.
  • Clarify that PowerShell Core (pwsh) is cross-platform and supported, and update references from 'Windows PowerShell' to 'PowerShell' where appropriate.
  • Provide guidance or links for using Microsoft Entra ID authentication in Azure Automation with non-PowerShell runbooks (e.g., Python).
  • Explicitly state if certain features or modules are only available in Windows PowerShell, and suggest alternatives for Linux/macOS users.
  • Reorder sections so that cross-platform or platform-agnostic methods are presented before Windows-specific instructions.
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 provides a general overview of Azure Change Tracking and Inventory, which supports both Windows and Linux. However, there is a notable Windows bias in the registry key tracking section, which is exclusively focused on Windows registry keys with no mention of Linux equivalents (such as configuration files or system settings). Additionally, examples and tables in this section are Windows-specific, and there are no Linux-specific examples or guidance for tracking Linux configuration changes. The order of presentation also tends to mention Windows features first or exclusively in some areas.
Recommendations
  • Add examples or tables showing how Change Tracking and Inventory can monitor Linux configuration files (e.g., /etc/passwd, /etc/ssh/sshd_config) or Linux system settings.
  • Include Linux-specific scenarios in sections discussing file and configuration change tracking, not just generic mentions.
  • Balance the presentation order by alternating or grouping Windows and Linux examples where applicable.
  • Clarify which features are Windows-only and which are cross-platform, to help Linux users understand applicability.
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 updating the PowerShell Az.NetAppFiles module and provides a PowerShell-specific command and link before mentioning Azure CLI and REST API usage. No Linux/macOS-specific examples or parity notes are provided, and the PowerShell guidance is given more detail than for other platforms.
Recommendations
  • Add explicit instructions for updating the Azure CLI for Linux/macOS users, similar to the PowerShell guidance.
  • Provide example commands for both Azure CLI and PowerShell when relevant, and ensure CLI examples are shown first or in parallel.
  • Clarify that both Azure CLI and PowerShell are supported, and link to platform-specific installation/update guides.
  • Consider including a table or section comparing usage across platforms (Windows, Linux, macOS) for common tasks.
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 exclusively describes creating a .NET Framework console application using Visual Studio, a Windows-only IDE, and does not mention Linux/macOS-compatible alternatives such as .NET Core/.NET 5+ or cross-platform development tools. All instructions and code samples assume a Windows development environment, with no guidance for Linux or macOS users.
Recommendations
  • Add instructions for creating a .NET Core or .NET 5+ console application, which is cross-platform and can run on Windows, Linux, and macOS.
  • Include examples for using cross-platform IDEs or command-line tools (e.g., Visual Studio Code, dotnet CLI) to create and manage the project.
  • Clarify which steps are Windows-specific and provide Linux/macOS alternatives where possible.
  • Explicitly state the platform requirements and recommend cross-platform approaches for broader accessibility.
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 ⚠️ powershell_heavy
Summary
The documentation provides instructions for configuring IP firewall rules for Azure Relay namespaces using the Azure portal and Resource Manager templates. However, when referencing deployment of the ARM template, it links only to PowerShell-based instructions, which are Windows-centric. There is no mention of Linux/macOS CLI alternatives (such as Azure CLI or Bash), and the deployment guidance implicitly prioritizes Windows/PowerShell tooling.
Recommendations
  • Add explicit instructions or links for deploying ARM templates using Azure CLI (az deployment group create) and Bash, which are cross-platform and widely used on Linux/macOS.
  • When referencing deployment guides, include both PowerShell and Azure CLI options, or link to a page that covers all supported methods.
  • Ensure that examples and instructions do not assume the use of Windows/PowerShell unless the feature is Windows-only.
GitHub Create Pull Request
Azure Resource Manager Relocation guidance for Azure Firewall ...e-manager/management/relocation/relocation-firewall.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ powershell_heavy ⚠️ missing_linux_example ⚠️ windows_tools
Summary
The documentation provides step-by-step guidance for relocating Azure Firewall using either the Azure Portal or Azure PowerShell. However, it exclusively features PowerShell as the command-line automation option, with no mention of Azure CLI or Bash scripting. This creates friction for Linux/macOS users who do not use PowerShell, and may not have it installed or prefer native tools. Additionally, links to further automation (such as creating firewall policies) also reference PowerShell guides, reinforcing the bias.
Recommendations
  • Add equivalent Azure CLI examples for all PowerShell command sequences, as Azure CLI is cross-platform and widely used on Linux/macOS.
  • Explicitly mention that PowerShell commands can be run on Linux/macOS via PowerShell Core, but provide Azure CLI alternatives for users who prefer Bash or native shells.
  • Update cross-referenced guides (such as policy creation) to include CLI instructions or link to CLI documentation.
  • Consider a 'tabbed' approach for command-line examples: PowerShell, Azure CLI, and Bash, to ensure parity and user choice.
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 demonstrates a moderate Windows bias. Windows-specific certificate store access is described in detail and shown first, with C# and Java examples for Windows. Linux guidance is present but less prominent, with Linux examples only for C# and no code samples for other languages (Node.js, PHP, Python, Java). Windows certificate store patterns and tools are explained before Linux equivalents, and references to Windows-specific APIs and stores are more thorough.
Recommendations
  • Add code examples for Linux for other popular languages (Node.js, Python, Java, PHP) showing how to load certificates from the provided file paths.
  • Present Linux and Windows examples side-by-side or in parallel tabs for all major languages, rather than focusing on Windows first.
  • Expand explanations of Linux certificate handling, including common libraries (e.g., OpenSSL, cryptography) and best practices.
  • Clarify when guidance applies to both platforms and highlight platform differences more explicitly.
  • Reference Linux tools and patterns (e.g., environment variables, file permissions) where relevant.
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 page provides command-line examples primarily using Azure CLI and Azure PowerShell, with explicit mention of the Azure PowerShell cmdlet before Linux-friendly alternatives. The 'set-azapimanagement' PowerShell cmdlet is listed alongside REST API and Azure CLI, but no Linux/macOS shell example (e.g., Bash, curl) is provided. The order of tools mentioned (REST API, Azure CLI, PowerShell) puts Windows-centric tooling at parity or ahead of Linux-native approaches. No explicit Linux/macOS example is given for disabling a regional gateway, and no mention is made of platform-specific considerations for Linux users.
Recommendations
  • Provide Bash/curl examples for REST API calls to manage API Management instances, especially for disabling/enabling regional gateways.
  • Clarify that Azure CLI is cross-platform and works on Linux/macOS, and consider listing it before PowerShell.
  • Where PowerShell is mentioned, also provide equivalent Bash or shell script examples for Linux/macOS users.
  • Explicitly state platform compatibility for each tool (Azure CLI, PowerShell, REST API) to help users choose the best option for their OS.
  • Add a note or section for Linux/macOS users highlighting any differences or additional steps required.
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 provides a link to a tutorial for creating an autoscaling, zone-redundant Application Gateway using Azure PowerShell, without mentioning or linking to equivalent instructions for Linux/macOS users (e.g., Azure CLI, ARM templates, or Terraform). This suggests a bias toward Windows/PowerShell tooling and may create friction for users on other platforms.
Recommendations
  • Add links or sections for creating autoscaling, zone-redundant Application Gateway using Azure CLI, which is cross-platform.
  • Include references to ARM template or Bicep deployment methods for infrastructure-as-code parity.
  • Ensure that Linux/macOS users are aware of alternative tools and provide examples or tutorials for those platforms.
  • When listing tutorials, present cross-platform options first or together, rather than PowerShell-only.
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, which supports both Windows and Linux. However, there are several instances of Windows bias: Windows paths and conventions (e.g., D:\home) are often mentioned first or exclusively in examples; references to Windows tools (such as msbuild, Web Deploy/MSDeploy, IIS, and w3wp.exe) are frequent and sometimes lack Linux equivalents or explanations; some sections (e.g., Kudu build automation) are Windows-centric and presented before Linux alternatives; and some examples or settings use Windows environment variable syntax or refer to Windows-only features without always clarifying Linux differences. While Linux support is present (e.g., Oryx build automation, Linux-specific settings), parity and visibility could be improved.
Recommendations
  • Ensure that examples and paths are shown for both Windows and Linux, ideally side-by-side or with clear tabs/pivots.
  • When referencing Windows tools or conventions (e.g., msbuild, Web Deploy), explicitly mention Linux alternatives (e.g., Oryx, ZIP deploy) and provide links or brief explanations.
  • In tables and lists, avoid listing Windows paths or features first unless they are more common; alternate ordering or use neutral language.
  • Where environment variables or settings differ between Windows and Linux, clearly indicate applicability and provide Linux-specific usage notes.
  • Add more Linux/macOS-focused examples, especially for deployment, logging, and build automation.
  • Clarify when a feature or variable is Windows-only, Linux-only, or cross-platform, to reduce ambiguity.
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 via PowerShell, but does not offer equivalent examples for Linux/macOS users (e.g., Azure CLI or Bash). The PowerShell method is presented before the Azure portal method, and no Linux-friendly command-line alternatives are shown. The log converter tool referenced is C#/.NET-based, which may be less accessible for non-Windows users.
Recommendations
  • Add Azure CLI examples for enabling diagnostic logging, as Azure CLI is cross-platform and widely used on Linux/macOS.
  • Present command-line examples for both PowerShell and Azure CLI side-by-side, or indicate which platforms each method supports.
  • Reference log conversion tools or scripts that work natively on Linux/macOS (e.g., Python-based converters) in addition to the C#/.NET tool.
  • Clarify that PowerShell Core is available cross-platform, if relevant, and provide installation guidance for non-Windows users.
  • Ensure that screenshots and instructions for the Azure portal are platform-neutral.
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 ⚠️ missing_linux_example ⚠️ windows_tools
Summary
The documentation heavily references Azure PowerShell scripts for migration tasks, including configuration migration and public IP retention. There are no examples or guidance for users who may prefer or require Azure CLI, Bash, or other cross-platform tools. The exclusive mention of PowerShell and lack of Linux/macOS-specific instructions or parity creates friction for non-Windows users.
Recommendations
  • Provide equivalent Azure CLI (az) commands or scripts for all migration steps currently covered only by PowerShell.
  • Explicitly state platform compatibility for the PowerShell scripts (e.g., if they work in PowerShell Core on Linux/macOS).
  • Add Bash or cross-platform scripting examples where possible, or link to relevant Azure CLI documentation.
  • Clarify any limitations or requirements for Linux/macOS users in the migration process.
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: 4 bias types
Detected Bias Types
⚠️ powershell_heavy ⚠️ windows_tools ⚠️ missing_linux_example ⚠️ windows_first
Summary
The documentation for migrating Azure Application Gateway from V1 to V2 is heavily focused on PowerShell scripts and commands, with all migration tooling, examples, and instructions provided exclusively in Azure PowerShell syntax. There is no mention of Bash, Azure CLI, or cross-platform alternatives, nor are Linux/macOS-specific usage patterns or considerations addressed. The documentation assumes the use of PowerShell (including local PowerShell environments and modules), which is natively available only on Windows and requires extra setup on Linux/macOS. This creates friction for non-Windows users and may hinder their ability to follow the migration process smoothly.
Recommendations
  • Provide equivalent Azure CLI scripts and examples for all migration steps, including configuration cloning and IP retention.
  • Explicitly state cross-platform compatibility for the provided PowerShell scripts (e.g., test and document usage in PowerShell Core on Linux/macOS).
  • Include instructions for running the scripts in Azure Cloud Shell (which is cross-platform) and clarify any limitations or requirements.
  • Add Bash/Azure CLI examples for common tasks such as retrieving resource IDs, managing certificates, and setting context.
  • Mention prerequisites for Linux/macOS users (e.g., installing PowerShell Core, Az modules) and provide troubleshooting tips for non-Windows environments.
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_tools ⚠️ windows_first
Summary
The documentation page for Azure Application Gateway v2 exhibits a moderate Windows bias. Key migration and registration tasks reference Azure PowerShell scripts and cmdlets, with no mention of Linux/macOS alternatives or Azure CLI equivalents. The 'Next steps' section prioritizes a PowerShell-based tutorial, and the migration guidance is PowerShell-centric. While the core product is cross-platform, the documentation's operational guidance leans toward Windows tooling and patterns.
Recommendations
  • Provide Azure CLI and/or REST API examples alongside PowerShell scripts for migration and registration tasks.
  • Explicitly mention that Azure CLI is supported on Linux/macOS and provide sample commands for those platforms.
  • Balance tutorial links to include both PowerShell and Azure CLI-based guides.
  • Clarify any platform-specific requirements for scripts or tools, and offer alternatives where possible.
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 Azure Automation disaster recovery is notably PowerShell-centric, with all migration scripts and runbook examples provided only in PowerShell and PowerShell Workflow. There are no equivalent examples or guidance for Linux-native tools (such as Bash, Python, or CLI), nor is there mention of cross-platform alternatives. Windows/PowerShell instructions are presented first and exclusively, creating friction for Linux/macOS users who may prefer or require non-PowerShell solutions.
Recommendations
  • Provide equivalent migration scripts and runbook examples using Azure CLI, Bash, or Python to support Linux/macOS users.
  • Explicitly mention whether PowerShell Core (7.x) is supported and cross-platform, and clarify any Windows-only limitations.
  • Add guidance or links for Linux/macOS users on how to install and use PowerShell Core if PowerShell is required.
  • Where possible, offer ARM template or REST API examples for asset migration, which are platform-agnostic.
  • Reorder examples so that cross-platform solutions (e.g., Azure CLI, REST API) are presented before or alongside PowerShell examples.
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: 3 bias types
Detected Bias Types
⚠️ powershell_heavy ⚠️ windows_first ⚠️ missing_linux_example
Summary
The documentation page demonstrates a notable bias toward Windows/PowerShell environments. Most examples, code snippets, and workflows are centered around PowerShell and PowerShell Workflow runbooks, with detailed explanations and screenshots. The process for passing parameters, especially from local machines, is exclusively described using PowerShell commands, with no equivalent CLI or Linux/macOS shell examples. SDK and REST API sections are platform-neutral, but the practical, step-by-step guidance for local execution is Windows/PowerShell-centric. Python runbooks are mentioned, but only briefly and without concrete parameter-passing examples from Linux/macOS environments.
Recommendations
  • Add equivalent examples for starting runbooks and passing parameters using Azure CLI (az automation runbook start) and Bash scripts, suitable for Linux/macOS users.
  • Include instructions for preparing and passing JSON objects to runbooks using Azure CLI or REST API from non-Windows platforms.
  • Provide sample workflows for Python runbooks, including parameter passing from Linux/macOS terminals.
  • Clarify that PowerShell examples are cross-platform where applicable (e.g., PowerShell Core/7+), or explicitly note Windows-only limitations.
  • Reorder or balance examples so that PowerShell and non-PowerShell approaches are presented with equal prominence.
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_first ⚠️ missing_linux_example
Summary
The documentation page for managing certificates in Azure Automation is heavily focused on PowerShell and Windows-centric workflows. All CLI examples use PowerShell, and Windows tools and cmdlets are presented first and in greater detail. There are no examples using Bash, Azure CLI, or Linux-native certificate management tools. Python examples are provided, but only in the context of runbooks, not for certificate management tasks outside of runbooks. This creates friction for Linux/macOS users who may prefer or require non-PowerShell approaches.
Recommendations
  • Add equivalent Azure CLI or REST API examples for certificate management tasks (create, get, remove, set).
  • Provide guidance or examples for uploading certificates from Linux/macOS environments, including using Bash or OpenSSL.
  • Clarify that PowerShell examples are cross-platform (if true), or explicitly mention any platform limitations.
  • Include a section comparing PowerShell and Azure CLI approaches for certificate management.
  • List prerequisites for Linux/macOS users, such as installing PowerShell Core or using Azure CLI.
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: 4 bias types
Detected Bias Types
⚠️ powershell_heavy ⚠️ windows_first ⚠️ missing_linux_example ⚠️ windows_tools
Summary
The documentation for managing credentials in Azure Automation is heavily focused on PowerShell and Windows-centric tooling. All command-line examples use PowerShell cmdlets, and the only non-PowerShell examples are for Python runbooks. There are no examples or guidance for Linux/macOS users who may wish to interact with Azure Automation credentials via Bash, CLI, or other cross-platform tools. The documentation refers to 'Windows PowerShell' explicitly and does not mention alternatives for Linux or macOS environments, nor does it clarify whether PowerShell Core (pwsh) is supported.
Recommendations
  • Add examples using Azure CLI (az) for credential management, if supported.
  • Clarify whether PowerShell Core (pwsh) on Linux/macOS is supported for these cmdlets, and provide examples if so.
  • Explicitly state platform requirements and limitations for PowerShell cmdlets (e.g., Windows-only or cross-platform).
  • Provide guidance or links for Linux/macOS users on how to manage credentials, including any REST API or SDK options.
  • Consider including Bash or shell script examples where possible, or note if such functionality is unavailable.
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: 4 bias types
Detected Bias Types
⚠️ windows_first ⚠️ powershell_heavy ⚠️ missing_linux_example ⚠️ windows_tools
Summary
The documentation frequently references Windows tools and PowerShell cmdlets for critical operations (such as unregistering DSC nodes, exporting runbooks, and DSC configurations), with Linux equivalents either missing or not mentioned. Windows registry/TLS configuration guidance is provided with direct links, while Linux guidance is more generic. Windows examples and tools are often presented first or exclusively.
Recommendations
  • Provide explicit Linux command-line examples (e.g., using Azure CLI or REST API) for tasks currently only described with PowerShell cmdlets, such as unregistering DSC nodes, exporting runbooks, and exporting DSC configurations.
  • When referencing Windows registry or PowerShell steps, add equivalent Linux/OpenSSL or cross-platform instructions where possible.
  • In tables and lists, alternate or parallelize Windows and Linux guidance, rather than listing Windows first.
  • Link to Linux-specific documentation or official Azure CLI docs for Linux users.
  • Clarify when a feature or cmdlet is Windows-only, and suggest alternatives for Linux users.
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 ⚠️ windows_tools
Summary
The documentation provides migration guidance for both Linux and Windows Azure Functions apps. However, Windows/PowerShell/Azure CLI examples and instructions are frequently presented first or in more detail, especially in the 'platform-windows' pivots. Windows-centric tools and patterns (such as Azure CLI commands, PowerShell scripts, and portal steps) are often described before their Linux equivalents, and some sections (such as premigration tasks and manual migration steps) are more comprehensive for Windows users. While Linux migration is supported and covered, the documentation leans toward Windows-first presentation and tooling.
Recommendations
  • Ensure Linux examples and instructions are presented with equal prominence and detail as Windows examples.
  • Where possible, present Linux and Windows instructions side-by-side, or alternate which platform is shown first.
  • Expand Linux-specific migration steps to match the depth provided for Windows, especially for manual migration and troubleshooting.
  • Highlight Linux automation tools (such as az functionapp flex-migration) more prominently, and clarify their limitations or advantages.
  • Review all CLI and portal instructions to ensure Linux users are not required to infer steps from Windows-centric guidance.
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 provides only Azure PowerShell scripts for identifying function apps to migrate, with no mention of Azure CLI or Bash alternatives. PowerShell is a Windows-first tool, and its exclusive use creates friction for Linux/macOS users. Throughout the guide, tooling and workflow examples (such as Visual Studio publishing) are presented without Linux/macOS parity or alternatives, and there is no explicit guidance for Linux users on equivalent steps.
Recommendations
  • Add Azure CLI and/or Bash script examples alongside PowerShell for identifying function apps to migrate.
  • Explicitly mention cross-platform tools (such as VS Code, Azure CLI, GitHub Actions) for migration and deployment steps.
  • Where Visual Studio is referenced, clarify alternatives for Linux/macOS users (e.g., VS Code, CLI publishing).
  • Ensure all scripting and automation examples have Linux/macOS equivalents or links to relevant documentation.
GitHub Create Pull Request
Azure Netapp Files Create an SMB volume for Azure NetApp Files ...-netapp-files/azure-netapp-files-create-volumes-smb.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
⚠️ windows_tools ⚠️ powershell_heavy ⚠️ missing_linux_example ⚠️ windows_first
Summary
The documentation is focused on creating SMB volumes for Azure NetApp Files, which is a protocol supported by both Windows and Linux clients. However, the examples and instructions for managing access and permissions are exclusively Windows-centric, referencing Windows tools (MMC, Windows File Browser, Control Panel) and omitting any guidance for Linux or macOS clients. There are no examples or instructions for mounting SMB volumes or managing permissions from Linux systems, despite SMB support on Linux via tools like smbclient, mount.cifs, or Nautilus.
Recommendations
  • Add instructions or examples for mounting SMB volumes from Linux clients (e.g., using mount.cifs or smbclient).
  • Include guidance for managing SMB permissions from Linux (e.g., using setfacl, smbclient, or other relevant tools).
  • Clarify which steps are Windows-only and provide Linux/macOS alternatives where possible.
  • Reorder sections so that platform-neutral or cross-platform steps are presented before Windows-specific instructions.
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
⚠️ powershell_heavy ⚠️ windows_tools ⚠️ missing_linux_example ⚠️ windows_first
Summary
The documentation is heavily Windows-focused, with all command-line examples using PowerShell or Windows tools (e.g., Get-SmbClientNetworkInterface, set-SmbClientConfiguration), and monitoring instructions referencing Windows Performance Monitor. There are no Linux or macOS SMB client examples, nor any mention of how to achieve similar monitoring or configuration on non-Windows systems. The text assumes the reader is using Windows clients, even though SMB is supported on Linux/macOS and Azure NetApp Files can be accessed from those platforms.
Recommendations
  • Add equivalent Linux/macOS SMB client configuration and monitoring instructions (e.g., using smbclient, mount.cifs, or /proc/fs/cifs stats).
  • Include Linux/macOS command-line examples for checking SMB Multichannel, signing, and encryption status.
  • Mention relevant Linux kernel versions and Samba client features that support SMB Multichannel, signing, and encryption.
  • Provide guidance or references for performance monitoring on Linux/macOS (e.g., using iostat, nstat, or perf tools).
  • Clarify where features or recommendations are Windows-only, and provide alternatives or note limitations for non-Windows clients.
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 GUI, which is platform-agnostic, but the command-line guidance is Windows/PowerShell-centric, with Linux/macOS users given less visibility and guidance.
Recommendations
  • Provide full Azure CLI command examples alongside PowerShell for feature registration and status checking, including syntax and output.
  • Explicitly note that Azure CLI is cross-platform and suitable for Linux/macOS users.
  • Where command-line steps are shown, present both PowerShell and CLI examples side-by-side or in tabs.
  • Clarify that the Azure Portal steps are platform-neutral and accessible from any OS/browser.
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 page primarily demonstrates authentication with Azure Relay using .NET console applications, which are most commonly run on Windows. The highlighted code samples are in C#, and the main sample referenced is for .NET. While Java and JavaScript samples are mentioned, they are not described or linked in the main walkthrough. The instructions for running the sample do not clarify cross-platform compatibility or provide Linux/macOS-specific guidance. Additionally, in the 'Next steps' section, Azure PowerShell is listed before Azure CLI, which is more commonly used on Linux/macOS.
Recommendations
  • Explicitly state that the .NET sample can be run cross-platform (Windows, Linux, macOS) if applicable, and provide instructions for running on Linux/macOS (e.g., using .NET Core/SDK).
  • Include code snippets or walkthroughs for Java and JavaScript samples, not just .NET.
  • In the 'Next steps' section, list Azure CLI before PowerShell, or clarify parity between tools.
  • Add notes or links to platform-specific setup instructions (e.g., installing .NET SDK on Linux/macOS).
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 page primarily provides instructions and examples for running the sample application on a Windows VM, including references to RDP and Windows-specific VM images. There are no explicit instructions or examples for running the sample on Linux VMs, nor are there mentions of Linux tools or remote access methods. While the underlying Azure Relay and managed identity features are cross-platform, the guidance is Windows-centric.
Recommendations
  • Add parallel instructions for creating and configuring a Linux VM, including enabling managed identity.
  • Provide guidance on copying and running the sample application on Linux VMs (e.g., using SSH instead of RDP).
  • Clarify whether the .NET sample can be built and run on Linux (using .NET Core/5+/6+), or highlight the Java/JavaScript samples as Linux-friendly alternatives.
  • Include Linux-specific links for connecting to VMs and managing identities.
  • Reorder or balance examples so that Linux and Windows are presented with equal prominence.
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
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
⚠️ windows_first ⚠️ missing_linux_example
Summary
The documentation is focused on creating a .NET Framework console application using Visual Studio, which is a Windows-centric development environment and technology. There are no instructions or examples for Linux/macOS users, such as using .NET Core/.NET 5+ (cross-platform) or alternative IDEs like VS Code. The NuGet package installation steps are given only for Visual Studio GUI, not for CLI or cross-platform workflows.
Recommendations
  • Add instructions for creating a .NET Core or .NET 5+ console application, which is cross-platform and supported on Linux/macOS.
  • Include examples for installing the NuGet package using the dotnet CLI (e.g., 'dotnet add package Microsoft.Azure.Relay').
  • Mention alternative development environments such as Visual Studio Code and provide corresponding setup steps.
  • Clarify which steps are Windows-specific and provide parity guidance for Linux/macOS users.
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: 2 bias types
Detected Bias Types
⚠️ windows_first ⚠️ missing_linux_example
Summary
The documentation provides instructions and examples exclusively for creating a .NET Framework console application using Visual Studio, a Windows-centric IDE. It does not mention or provide guidance for Linux/macOS users, such as using .NET Core/.NET 5+ (cross-platform), alternative IDEs, or command-line approaches. The NuGet package installation steps are tailored to Visual Studio's GUI, omitting CLI instructions suitable for non-Windows environments.
Recommendations
  • Add instructions for creating a .NET Core/.NET 5+ console application, which is cross-platform and supported on Linux/macOS.
  • Include guidance for using Visual Studio Code or command-line tools (dotnet CLI) to create and manage projects.
  • Provide NuGet package installation steps using the dotnet CLI (e.g., 'dotnet add package Microsoft.Azure.Relay').
  • Clarify that the code sample works on any OS with .NET Core/.NET 5+ and is not limited to Windows.
  • Consider reordering or parallelizing instructions so that Windows and cross-platform approaches are presented equally.
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 instructs users to create a .NET Framework console application using Visual Studio and relies on Windows-centric tooling and workflows. There are no examples or guidance for Linux/macOS users, such as using .NET Core/.NET 5+ or cross-platform development environments. The instructions for adding NuGet packages and project creation are specific to Visual Studio on Windows.
Recommendations
  • Add instructions for creating a cross-platform .NET (Core/5+) console application using the 'dotnet' CLI, which works on Linux and macOS.
  • Provide alternative steps for adding NuGet packages via the CLI (e.g., 'dotnet add package Microsoft.Azure.Relay').
  • Clarify whether the Azure Relay SDK and sample code are compatible with .NET Core/.NET 5+ and non-Windows platforms.
  • Include notes or examples for using VS Code or other cross-platform editors.
  • If .NET Framework is required, explicitly state that this is a Windows-only workflow.
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 ⚠️ windows_first ⚠️ missing_linux_example
Summary
The documentation provides step-by-step instructions for integrating Azure Relay with Azure Private Link Service, primarily using the Azure Portal and Azure PowerShell. The only CLI example is given in PowerShell, with no equivalent Azure CLI (cross-platform) or Bash example. The validation step explicitly instructs users to create a Windows VM and does not mention Linux VM alternatives, nor does it provide Linux/macOS-specific guidance for DNS validation. Overall, the documentation assumes a Windows-centric workflow and omits Linux/macOS parity in examples and validation steps.
Recommendations
  • Add Azure CLI (az) examples alongside PowerShell for creating resources and private endpoints, as Azure CLI is cross-platform and widely used on Linux/macOS.
  • In the validation section, provide instructions for creating a Linux VM and running equivalent DNS validation commands (e.g., nslookup or dig) on Linux/macOS.
  • Clarify that the steps are applicable regardless of VM OS, and provide OS-agnostic guidance where possible.
  • Where screenshots are shown, note that the Azure Portal experience is the same on all platforms.
  • Explicitly mention that PowerShell examples can be run on Linux/macOS using PowerShell Core, or provide links to documentation for cross-platform PowerShell usage.
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: 3 bias types
Detected Bias Types
⚠️ windows_first ⚠️ powershell_heavy ⚠️ missing_linux_example
Summary
The documentation assumes the use of Visual Studio on Windows and provides instructions and examples exclusively for .NET Framework console applications developed and run in Visual Studio. There are no examples or guidance for developing or running the sample applications on Linux or macOS, nor is there mention of cross-platform .NET (Core/5+) or alternative editors/IDEs. This creates friction for Linux/macOS users who may wish to use .NET Core/5+ and cross-platform tools.
Recommendations
  • Clarify whether the sample code works with .NET Core/.NET 5+ and provide instructions for using cross-platform .NET SDKs.
  • Include steps for creating and running the applications using the .NET CLI (dotnet new, dotnet run) on Linux/macOS.
  • Mention alternative editors (e.g., VS Code) and provide guidance for non-Windows environments.
  • Explicitly state any Windows-only requirements (e.g., if the code requires .NET Framework or Visual Studio-specific features).
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 and Windows for .NET development, with all examples and instructions referencing Visual Studio and console applications. There are no instructions or examples for developing or running the sample applications on Linux or macOS, nor mention of cross-platform .NET development tools like VS Code or CLI workflows.
Recommendations
  • Add instructions for creating and running the .NET applications using cross-platform tools such as Visual Studio Code and the .NET CLI.
  • Explicitly mention that .NET Core/.NET 5+ is cross-platform and provide guidance for Linux/macOS users.
  • Include example commands for building and running the applications on Linux/macOS terminals.
  • Clarify any Windows-specific requirements (if any), or state that the tutorial works on Linux/macOS as well.
GitHub Create Pull Request
Azure Resource Manager Data types in Bicep ...in/articles/azure-resource-manager/bicep/data-types.md
Medium Priority View Details →
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
⚠️ windows_tools ⚠️ windows_first
Summary
The documentation page is generally platform-neutral, but there is a notable Windows bias in the 'Integers' section. It specifically mentions PowerShell as the example SDK/command-line tool that limits integer ranges, without referencing Azure CLI or other cross-platform tools. This may lead Linux/macOS users to believe that PowerShell is the primary or only supported deployment tool for Bicep, and omits equivalent information for other platforms.
Recommendations
  • Include information about integer range limitations for other deployment tools, such as Azure CLI (cross-platform), and clarify whether similar or different limits apply.
  • When mentioning command-line tools, list Azure CLI before or alongside PowerShell to emphasize cross-platform support.
  • Add a brief note or table comparing integer handling across PowerShell, Azure CLI, and other SDKs to help users on all platforms understand potential limitations.
  • Review other sections for implicit references to Windows tooling and ensure parity in examples and guidance.
GitHub Create Pull Request
Azure Resource Manager Relocate an Azure Container Registry to another region ...management/relocation/relocation-container-registry.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 includes several PowerShell command examples (e.g., Get-AzContainerRegistryRepository, Import-AzContainerImage, Set-AzAksCluster) without providing equivalent Azure CLI or bash examples for these steps. While some sections use Azure CLI and bash scripting, PowerShell commands are often presented first or exclusively, and Linux/macOS alternatives are not always given. This may cause friction for users on non-Windows platforms.
Recommendations
  • For every PowerShell command (e.g., Get-AzContainerRegistryRepository, Import-AzContainerImage, Set-AzAksCluster), provide equivalent Azure CLI or bash examples, or clearly indicate if a CLI equivalent does not exist.
  • When showing command-line examples, prefer Azure CLI (cross-platform) or present CLI and PowerShell examples side-by-side.
  • Ensure that all automation and scripting examples are runnable on Linux/macOS, or provide alternatives.
  • If a step is only possible in PowerShell, explicitly state this and link to platform-specific guidance.
GitHub Create Pull Request
Azure Resource Manager Relocate Azure Virtual Machine Scale Sets to another region ...nt/relocation/relocation-virtual-machine-scale-sets.md
Low 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 relocating Azure Virtual Machine Scale Sets but consistently references the Azure portal and PowerShell/ARM templates without offering explicit Linux/macOS CLI examples. The use of screenshots and step-by-step guidance is focused on the Azure portal, which is platform-agnostic, but when mentioning Infrastructure as Code (IAC) tools, PowerShell is listed alongside Azure CLI and ARM templates, with no Bash or Linux-specific command examples. There are no references to Linux-specific tooling or workflows, and examples are not shown for Linux users.
Recommendations
  • Add explicit Azure CLI examples using Bash for key steps, such as exporting and deploying templates.
  • Clarify that all steps can be performed on Linux/macOS using Azure CLI and ARM templates, not just PowerShell.
  • Include screenshots or terminal output from Linux environments where relevant.
  • List Azure CLI before PowerShell when mentioning IAC tools to avoid the appearance of Windows-first bias.
GitHub Create Pull Request
API Center Perform API linting and analysis - Azure API Center ...ain/articles/api-center/enable-api-analysis-linting.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 syntax for Azure CLI commands, but PowerShell examples are consistently shown immediately after Bash, and sometimes with explicit 'PowerShell syntax' labels. There is a slight tendency to mention PowerShell in command notes and examples, and the phrase 'Azure CLI command examples in this article can run in PowerShell or a bash shell' puts PowerShell first. However, all core steps and tooling (Azure CLI, Azure Developer CLI, Visual Studio Code) are cross-platform, and Linux/macOS users are not blocked or disadvantaged in completing the tasks.
Recommendations
  • Alternate the order of Bash and PowerShell examples, or group them together under clear headings for each shell.
  • Explicitly mention Linux/macOS compatibility for all tools and steps, especially in prerequisites.
  • Add a short section or note confirming that all steps are fully supported on Linux/macOS, and that Visual Studio Code and Azure CLI are cross-platform.
  • Where possible, provide a single generic CLI example and refer to shell-specific variable syntax only if necessary.
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
⚠️ powershell_heavy ⚠️ windows_first
Summary
The documentation provides both Bash and PowerShell examples for Azure CLI commands, but PowerShell examples are included immediately after Bash for every step, and PowerShell-specific formatting is explicitly called out. This creates a slight Windows-first impression, as Linux/macOS users are expected to use Bash, but the PowerShell examples are given equal prominence. There are no Linux-specific tools or patterns missing, and the Azure CLI is cross-platform.
Recommendations
  • Clearly label Bash examples as suitable for Linux/macOS and PowerShell for Windows.
  • Consider grouping Bash and PowerShell examples under separate tabs or headings to reduce clutter and clarify platform relevance.
  • If possible, show Bash examples first, as Bash is the default shell on Linux/macOS and Azure Cloud Shell.
  • Add a brief note explaining which shell to use on each 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 PowerShell examples are given immediately after Bash for every step, and some variable assignment patterns (e.g., $scope=$apimID.substring(1)) are PowerShell-specific. There is a slight bias toward Windows/PowerShell users, as PowerShell examples are always present and shown alongside Bash, which is standard for Linux/macOS. However, Linux users are not blocked from completing the task, as Bash examples are provided for all steps.
Recommendations
  • Clarify that Bash examples are for Linux/macOS and PowerShell for Windows, possibly with tabbed sections or explicit OS labels.
  • Ensure variable naming consistency between Bash and PowerShell examples to avoid confusion (e.g., $apimID vs $apicObjID).
  • Consider listing Bash (Linux/macOS) examples before PowerShell (Windows) examples, or use tabs to let users select their environment.
  • Add a brief note for users on macOS/Linux that Bash is the recommended shell for Azure CLI.
GitHub Create Pull Request
API Center Quickstart - Create Your Azure API Center - ARM Template .../articles/api-center/set-up-api-center-arm-template.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 deploying the ARM template, but PowerShell is given equal prominence and is listed immediately after CLI. There is no explicit Linux/macOS bias, but the presence of PowerShell examples and references (including a custom metadata tag 'devx-track-azurepowershell') may signal a slight Windows bias. No Linux-specific shell (bash) or OS-specific guidance is provided, though the Azure CLI example is cross-platform.
Recommendations
  • Clarify that Azure CLI commands work on Windows, Linux, and macOS, and recommend it as the preferred cross-platform method.
  • Add a note for Linux/macOS users about using Azure CLI in their native terminal environments.
  • Consider listing Azure CLI examples first, and PowerShell second, to emphasize cross-platform parity.
  • If relevant, mention how to upload the template file from Linux/macOS (e.g., using scp or curl) in Cloud Shell.
GitHub Create Pull Request
App Service Install a TLS/SSL Certificate for Your App ...main/articles/app-service/configure-ssl-certificate.md
Low Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ windows_first ⚠️ powershell_heavy ⚠️ windows_tools
Summary
The documentation generally provides cross-platform guidance, but there are subtle biases. In automation examples, both Azure CLI and PowerShell are shown, but PowerShell is given its own dedicated section and is often listed second, which is a minor 'windows_first' bias. In the certificate export section, Windows tools (IIS, Certreq.exe) are mentioned for exporting certificates, but Linux/macOS equivalents are not explicitly referenced. There is a link to OpenSSL commands (cross-platform), but the Windows-specific tools are called out by name. The FAQ and automation sections also highlight PowerShell scripts alongside Azure CLI, but do not mention Bash or Linux-native scripting. Overall, Linux and macOS users can complete all tasks, but may need to infer or adapt some steps.
Recommendations
  • When referencing certificate export tools, explicitly mention Linux/macOS equivalents (e.g., 'use OpenSSL on Linux/macOS, or IIS/Certreq.exe on Windows').
  • In automation sections, provide Bash script examples or clarify that Azure CLI commands work on all platforms.
  • When listing PowerShell, always pair with Azure CLI and clarify cross-platform compatibility.
  • Consider adding a short section or callout for Linux/macOS users, especially for certificate preparation and export steps.
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 follows. The use of PowerShell and winget for Windows is highlighted, while the Linux installation uses a generic bash/curl command. All other commands throughout the guide are cross-platform (Azure CLI, Helm, kubectl) and do not exhibit OS-specific bias.
Recommendations
  • Present Windows and Linux installation instructions for Helm side-by-side or in parallel tabs, rather than listing Windows first.
  • Explicitly mention that Azure CLI, Helm, and kubectl commands are cross-platform and can be run on Windows, Linux, or macOS.
  • Consider adding a macOS-specific Helm installation example for completeness.
  • Clarify that Azure Cloud Shell is OS-agnostic and available to all users.
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: 2 bias types
Detected Bias Types
⚠️ windows_first ⚠️ powershell_heavy
Summary
The documentation provides both Azure PowerShell and Azure CLI examples for managing private endpoints, but PowerShell examples are presented first and in greater detail. This ordering and emphasis may create a perception of Windows bias, as PowerShell is most commonly used on Windows, while Azure CLI is cross-platform and preferred by many Linux/macOS users. The rest of the documentation is portal-focused and platform-neutral.
Recommendations
  • Present Azure CLI examples before PowerShell examples, or alternate their order in different sections.
  • Explicitly state that Azure CLI is cross-platform and suitable for Linux/macOS users.
  • Ensure that all PowerShell instructions have equivalent Azure CLI examples, and vice versa.
  • Add a short note clarifying that both CLI and PowerShell approaches are supported on all platforms, and users can choose based on their environment.
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 generally provides cross-platform guidance for running C# Azure Functions in an isolated worker process, with explicit instructions for both Windows and Linux where relevant. However, there are some instances of Windows bias: Windows-based tools (Visual Studio, Azure PowerShell) are listed before Linux alternatives (VS Code, Azure CLI), and Windows-specific instructions or examples (such as ReadyToRun and deployment settings) are sometimes presented first or in more detail. Linux equivalents are present but occasionally less emphasized or appear after Windows instructions.
Recommendations
  • Ensure that Linux and macOS instructions/examples are presented with equal prominence and detail as Windows ones, especially in sections about deployment, performance optimizations, and debugging.
  • When listing tools or workflows (e.g., Visual Studio, VS Code, CLI, PowerShell), alternate the order or explicitly state cross-platform parity.
  • Where Windows-specific instructions are given, immediately follow with Linux/macOS equivalents, rather than separating into tabs or sections that may be overlooked.
  • Expand Linux/macOS troubleshooting and performance optimization details to match the depth of Windows coverage.
  • Consider adding explicit notes about macOS support where applicable, not just Linux.
GitHub Create Pull Request
Azure Functions Deployment technologies in Azure Functions ...s/azure-functions/functions-deployment-technologies.md
Low Priority View Details →
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
⚠️ windows_first ⚠️ powershell_heavy ⚠️ windows_tools
Summary
The documentation generally presents deployment methods and tools in a cross-platform manner, but there is a subtle Windows bias: Windows-based deployment options (such as source control, local Git, and FTPS) are called out in the technology availability table, and Windows-specific tools (Visual Studio, Kudu/SCM site) are often mentioned first or in more detail. Visual Studio (Windows-only) is listed before Visual Studio Code (cross-platform) in several places. The documentation references Windows behaviors and tools before Linux equivalents, and some deployment examples and explanations are more detailed for Windows scenarios. However, Linux deployment methods (Core Tools, Docker, remote build, etc.) are covered and called out where relevant.
Recommendations
  • Present cross-platform tools (Visual Studio Code, Core Tools, Azure CLI) before Windows-only tools (Visual Studio) in lists and examples.
  • Ensure Linux-specific deployment methods and caveats are given equal prominence and detail as Windows methods.
  • Add explicit Linux/macOS command-line examples where only Windows/PowerShell or GUI instructions are shown.
  • Clarify when a tool or method is Windows-only, and provide Linux/macOS alternatives or workarounds where possible.
  • Balance explanations of Kudu/SCM site features by describing Linux limitations and alternatives up front.
GitHub Create Pull Request
Azure App Configuration Configuration Provider Overview ...e-app-configuration/configuration-provider-overview.md
Low Priority View Details →
Reviewed by: LLM Analysis
Issues: 1 bias type
Detected Bias Types
⚠️ windows_first
Summary
The documentation lists .NET-based provider libraries first in all tables and examples, with .NET Standard, ASP.NET Core, Azure Functions, and .NET Framework appearing before Java, Python, JavaScript, and Go. While the content covers cross-platform libraries and does not provide Windows-only instructions or tools, the ordering and emphasis may subtly prioritize Windows/.NET users.
Recommendations
  • Reorder the provider libraries table to alternate or group by language family (e.g., .NET, Java, Python, JavaScript, Go) rather than listing all .NET options first.
  • Explicitly mention that .NET Standard and .NET Core are cross-platform and supported on Linux/macOS as well as Windows.
  • Add a brief note clarifying that all listed libraries (except .NET Framework) are intended for cross-platform use.
  • Consider rotating the order of examples or highlighting non-.NET samples in introductory sections.
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 a few areas where Windows is mentioned first (e.g., in environment variable delimiters and sample paths), Windows tools (like PowerShell) are referenced before Linux alternatives, and PowerShell-specific settings are documented in detail. Some examples, such as the TypeScript compiler path, use Windows-style paths, and certain settings are explicitly marked as Windows-only without always providing Linux equivalents or alternatives first.
Recommendations
  • Ensure that examples (such as file paths) are shown for both Windows and Linux, or use platform-neutral formats where possible.
  • When referencing tools (e.g., PowerShell), mention Linux equivalents (such as Bash or Azure CLI) alongside or before Windows tools.
  • For settings that have OS-specific behaviors, clearly document both Windows and Linux/macOS usage, and avoid presenting Windows as the default unless it is truly the most common scenario.
  • Where sample values or instructions are OS-specific, provide both Windows and Linux/macOS examples in parallel.
  • Review the ordering of OS mentions in explanations to avoid implicit prioritization of Windows.
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
⚠️ powershell_heavy ⚠️ windows_first
Summary
The documentation provides access instructions for Azure NetApp Files in Azure Government using Azure CLI, REST API, and PowerShell. While the Azure CLI section is platform-neutral, the PowerShell section is detailed and extensive, listing multiple connection types and commands. PowerShell access is described after CLI and REST API, but the PowerShell section is longer and more prominent. There are no Linux/macOS-specific examples or mentions of tools like Bash, nor is there guidance for Linux-native workflows beyond the CLI. The 'Next steps' section also highlights PowerShell-based REST API usage.
Recommendations
  • Add explicit Bash or shell examples for connecting to Azure Government using Azure CLI on Linux/macOS.
  • Clarify that Azure CLI commands work equally on Windows, Linux, and macOS, and provide platform-specific notes if needed.
  • Include a brief section or note for Linux/macOS users, confirming parity and pointing to relevant documentation.
  • Balance the PowerShell section with equivalent detail for CLI or other cross-platform tools.
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 covers troubleshooting for Azure NetApp Files volumes across SMB, NFS, and dual-protocol scenarios. While it addresses both Windows (SMB/AD DS) and Linux (NFS) environments, there is a mild Windows bias: Windows/AD DS concepts and terminology appear first and more frequently, and PowerShell is used for some AD configuration examples without equivalent Linux CLI or LDAP tooling examples. Linux-specific troubleshooting steps are present, but Windows-centric tools and patterns are referenced first or exclusively in some cases.
Recommendations
  • Provide Linux/UNIX equivalents for AD/LDAP management tasks (e.g., using ldapmodify, samba-tool, or other CLI utilities) alongside PowerShell examples.
  • When referencing AD DS or machine account creation, clarify how Linux administrators can perform equivalent tasks (e.g., with samba or LDAP tools).
  • Balance example ordering so that NFS/Linux scenarios are not always after SMB/Windows scenarios.
  • Where troubleshooting involves AD DS, note cross-platform approaches (e.g., using RSAT on Windows, samba-tool on Linux, etc.).
  • For service restarts and Kerberos ticket acquisition, include macOS-specific instructions if relevant.
GitHub Create Pull Request
Azure Resource Manager Bicep functions - resources ...ure-resource-manager/bicep/bicep-functions-resource.md
Low Priority View Details →
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
⚠️ windows_tools ⚠️ windows_first
Summary
The documentation is generally cross-platform and focused on Bicep language features, which are OS-agnostic. However, in the section describing how to discover available 'list*' operations for resources, the PowerShell (Get-AzProviderOperation) example is presented before the Azure CLI example. PowerShell is primarily a Windows tool (though cross-platform now), and its precedence may signal a Windows-first bias. No Linux/macOS-specific examples or tools are missing, but the ordering and inclusion of PowerShell may create minor friction for non-Windows users.
Recommendations
  • Present Azure CLI examples before PowerShell examples, as Azure CLI is more universally available across platforms.
  • Explicitly mention that both Azure CLI and PowerShell are cross-platform, but Azure CLI is pre-installed on most Linux distros and macOS.
  • Consider adding a note for Linux/macOS users about installing Azure CLI and PowerShell, if relevant.
  • Where possible, use generic, platform-neutral commands or provide parity in example ordering.
GitHub Create Pull Request