diff --git a/scripts/helpers/Build-PSModule.ps1 b/scripts/helpers/Build-PSModule.ps1
index 4dbb4244..8188491b 100644
--- a/scripts/helpers/Build-PSModule.ps1
+++ b/scripts/helpers/Build-PSModule.ps1
@@ -32,19 +32,19 @@ function Build-PSModule {
     )
 
     LogGroup "Building module [$ModuleName]" {
-        Write-Verbose "Source path:          [$ModuleSourceFolderPath]"
+        Write-Host "Source path:          [$ModuleSourceFolderPath]"
         if (-not (Test-Path -Path $ModuleSourceFolderPath)) {
             Write-Error "Source folder not found at [$ModuleSourceFolderPath]"
             exit 1
         }
         $moduleSourceFolder = Get-Item -Path $ModuleSourceFolderPath
-        Write-Verbose "Module source folder: [$moduleSourceFolder]"
+        Write-Host "Module source folder: [$moduleSourceFolder]"
 
         $moduleOutputFolder = New-Item -Path $ModulesOutputFolderPath -Name $ModuleName -ItemType Directory -Force
-        Write-Verbose "Module output folder: [$moduleOutputFolder]"
+        Write-Host "Module output folder: [$moduleOutputFolder]"
 
         $docsOutputFolder = New-Item -Path $DocsOutputFolderPath -ItemType Directory -Force
-        Write-Verbose "Docs output folder:   [$docsOutputFolder]"
+        Write-Host "Docs output folder:   [$docsOutputFolder]"
     }
 
     Build-PSModuleBase -ModuleName $ModuleName -ModuleSourceFolder $moduleSourceFolder -ModuleOutputFolder $moduleOutputFolder
diff --git a/scripts/helpers/Build/Build-PSModuleBase.ps1 b/scripts/helpers/Build/Build-PSModuleBase.ps1
index 3b237313..e00a33fc 100644
--- a/scripts/helpers/Build/Build-PSModuleBase.ps1
+++ b/scripts/helpers/Build/Build-PSModuleBase.ps1
@@ -32,7 +32,7 @@ function Build-PSModuleBase {
     )
 
     LogGroup 'Build base' {
-        Write-Verbose "Copying files from [$ModuleSourceFolder] to [$ModuleOutputFolder]"
+        Write-Host "Copying files from [$ModuleSourceFolder] to [$ModuleOutputFolder]"
         Copy-Item -Path "$ModuleSourceFolder\*" -Destination $ModuleOutputFolder -Recurse -Force -Verbose -Exclude "$ModuleName.psm1"
         New-Item -Path $ModuleOutputFolder -Name "$ModuleName.psm1" -ItemType File -Force -Verbose
     }
diff --git a/scripts/helpers/Build/Build-PSModuleDocumentation.ps1 b/scripts/helpers/Build/Build-PSModuleDocumentation.ps1
index 423c406d..5ae946a1 100644
--- a/scripts/helpers/Build/Build-PSModuleDocumentation.ps1
+++ b/scripts/helpers/Build/Build-PSModuleDocumentation.ps1
@@ -34,7 +34,7 @@ function Build-PSModuleDocumentation {
     LogGroup 'Build docs - Generate markdown help' {
         $ModuleName | Remove-Module -Force
         Import-Module -Name $ModuleName -Force -RequiredVersion '999.0.0'
-        Write-Verbose ($ModuleName | Get-Module)
+        Write-Host ($ModuleName | Get-Module)
         $null = New-MarkdownHelp -Module $ModuleName -OutputFolder $DocsOutputFolder -Force -Verbose
     }
 
@@ -75,13 +75,13 @@ function Build-PSModuleDocumentation {
         $PublicFunctionsFolder = Join-Path $ModuleSourceFolder.FullName 'functions\public' | Get-Item
         Get-ChildItem -Path $DocsOutputFolder -Recurse -Force -Include '*.md' | ForEach-Object {
             $file = $_
-            Write-Verbose "Processing:        $file"
+            Write-Host "Processing:        $file"
 
             # find the source code file that matches the markdown file
             $scriptPath = Get-ChildItem -Path $PublicFunctionsFolder -Recurse -Force | Where-Object { $_.Name -eq ($file.BaseName + '.ps1') }
-            Write-Verbose "Found script path: $scriptPath"
+            Write-Host "Found script path: $scriptPath"
             $docsFilePath = ($scriptPath.FullName).Replace($PublicFunctionsFolder.FullName, $DocsOutputFolder.FullName).Replace('.ps1', '.md')
-            Write-Verbose "Doc file path:     $docsFilePath"
+            Write-Host "Doc file path:     $docsFilePath"
             $docsFolderPath = Split-Path -Path $docsFilePath -Parent
             New-Item -Path $docsFolderPath -ItemType Directory -Force
             Move-Item -Path $file.FullName -Destination $docsFilePath -Force
@@ -89,9 +89,9 @@ function Build-PSModuleDocumentation {
         # Get the MD files that are in the public functions folder and move them to the same place in the docs folder
         Get-ChildItem -Path $PublicFunctionsFolder -Recurse -Force -Include '*.md' | ForEach-Object {
             $file = $_
-            Write-Verbose "Processing:        $file"
+            Write-Host "Processing:        $file"
             $docsFilePath = ($file.FullName).Replace($PublicFunctionsFolder.FullName, $DocsOutputFolder.FullName)
-            Write-Verbose "Doc file path:     $docsFilePath"
+            Write-Host "Doc file path:     $docsFilePath"
             $docsFolderPath = Split-Path -Path $docsFilePath -Parent
             New-Item -Path $docsFolderPath -ItemType Directory -Force
             Move-Item -Path $file.FullName -Destination $docsFilePath -Force
diff --git a/scripts/helpers/Build/Build-PSModuleManifest.ps1 b/scripts/helpers/Build/Build-PSModuleManifest.ps1
index 6f3d8471..c420b100 100644
--- a/scripts/helpers/Build/Build-PSModuleManifest.ps1
+++ b/scripts/helpers/Build/Build-PSModuleManifest.ps1
@@ -33,64 +33,64 @@ function Build-PSModuleManifest {
 
     LogGroup 'Build manifest file' {
         $sourceManifestFilePath = Join-Path -Path $ModuleOutputFolder -ChildPath "$ModuleName.psd1"
-        Write-Verbose "[SourceManifestFilePath] - [$sourceManifestFilePath]"
+        Write-Host "[SourceManifestFilePath] - [$sourceManifestFilePath]"
         if (-not (Test-Path -Path $sourceManifestFilePath)) {
-            Write-Verbose "[SourceManifestFilePath] - [$sourceManifestFilePath] - Not found"
+            Write-Host "[SourceManifestFilePath] - [$sourceManifestFilePath] - Not found"
             $sourceManifestFilePath = Join-Path -Path $ModuleOutputFolder -ChildPath 'manifest.psd1'
         }
         if (-not (Test-Path -Path $sourceManifestFilePath)) {
-            Write-Verbose "[SourceManifestFilePath] - [$sourceManifestFilePath] - Not found"
+            Write-Host "[SourceManifestFilePath] - [$sourceManifestFilePath] - Not found"
             $manifest = @{}
-            Write-Verbose '[Manifest] - Loading empty manifest'
+            Write-Host '[Manifest] - Loading empty manifest'
         } else {
-            Write-Verbose "[SourceManifestFilePath] - [$sourceManifestFilePath] - Found"
+            Write-Host "[SourceManifestFilePath] - [$sourceManifestFilePath] - Found"
             $manifest = Get-ModuleManifest -Path $sourceManifestFilePath -Verbose:$false
-            Write-Verbose '[Manifest] - Loading from file'
+            Write-Host '[Manifest] - Loading from file'
             Remove-Item -Path $sourceManifestFilePath -Force -Verbose:$false
         }
 
         $rootModule = "$ModuleName.psm1"
         $manifest.RootModule = $rootModule
-        Write-Verbose "[RootModule] - [$($manifest.RootModule)]"
+        Write-Host "[RootModule] - [$($manifest.RootModule)]"
 
         $manifest.ModuleVersion = '999.0.0'
-        Write-Verbose "[ModuleVersion] - [$($manifest.ModuleVersion)]"
+        Write-Host "[ModuleVersion] - [$($manifest.ModuleVersion)]"
 
         $manifest.Author = $manifest.Keys -contains 'Author' ? ($manifest.Author | IsNotNullOrEmpty) ? $manifest.Author : $env:GITHUB_REPOSITORY_OWNER : $env:GITHUB_REPOSITORY_OWNER
-        Write-Verbose "[Author] - [$($manifest.Author)]"
+        Write-Host "[Author] - [$($manifest.Author)]"
 
         $manifest.CompanyName = $manifest.Keys -contains 'CompanyName' ? ($manifest.CompanyName | IsNotNullOrEmpty) ? $manifest.CompanyName : $env:GITHUB_REPOSITORY_OWNER : $env:GITHUB_REPOSITORY_OWNER
-        Write-Verbose "[CompanyName] - [$($manifest.CompanyName)]"
+        Write-Host "[CompanyName] - [$($manifest.CompanyName)]"
 
         $year = Get-Date -Format 'yyyy'
         $copyrightOwner = $manifest.CompanyName -eq $manifest.Author ? $manifest.Author : "$($manifest.Author) | $($manifest.CompanyName)"
         $copyright = "(c) $year $copyrightOwner. All rights reserved."
         $manifest.Copyright = $manifest.Keys -contains 'Copyright' ? -not [string]::IsNullOrEmpty($manifest.Copyright) ? $manifest.Copyright : $copyright : $copyright
-        Write-Verbose "[Copyright] - [$($manifest.Copyright)]"
+        Write-Host "[Copyright] - [$($manifest.Copyright)]"
 
         $repoDescription = gh repo view --json description | ConvertFrom-Json | Select-Object -ExpandProperty description
         $manifest.Description = $manifest.Keys -contains 'Description' ? ($manifest.Description | IsNotNullOrEmpty) ? $manifest.Description : $repoDescription : $repoDescription
-        Write-Verbose "[Description] - [$($manifest.Description)]"
+        Write-Host "[Description] - [$($manifest.Description)]"
 
         $manifest.PowerShellHostName = $manifest.Keys -contains 'PowerShellHostName' ? -not [string]::IsNullOrEmpty($manifest.PowerShellHostName) ? $manifest.PowerShellHostName : $null : $null
-        Write-Verbose "[PowerShellHostName] - [$($manifest.PowerShellHostName)]"
+        Write-Host "[PowerShellHostName] - [$($manifest.PowerShellHostName)]"
 
         $manifest.PowerShellHostVersion = $manifest.Keys -contains 'PowerShellHostVersion' ? -not [string]::IsNullOrEmpty($manifest.PowerShellHostVersion) ? $manifest.PowerShellHostVersion : $null : $null
-        Write-Verbose "[PowerShellHostVersion] - [$($manifest.PowerShellHostVersion)]"
+        Write-Host "[PowerShellHostVersion] - [$($manifest.PowerShellHostVersion)]"
 
         $manifest.DotNetFrameworkVersion = $manifest.Keys -contains 'DotNetFrameworkVersion' ? -not [string]::IsNullOrEmpty($manifest.DotNetFrameworkVersion) ? $manifest.DotNetFrameworkVersion : $null : $null
-        Write-Verbose "[DotNetFrameworkVersion] - [$($manifest.DotNetFrameworkVersion)]"
+        Write-Host "[DotNetFrameworkVersion] - [$($manifest.DotNetFrameworkVersion)]"
 
         $manifest.ClrVersion = $manifest.Keys -contains 'ClrVersion' ? -not [string]::IsNullOrEmpty($manifest.ClrVersion) ? $manifest.ClrVersion : $null : $null
-        Write-Verbose "[ClrVersion] - [$($manifest.ClrVersion)]"
+        Write-Host "[ClrVersion] - [$($manifest.ClrVersion)]"
 
         $manifest.ProcessorArchitecture = $manifest.Keys -contains 'ProcessorArchitecture' ? -not [string]::IsNullOrEmpty($manifest.ProcessorArchitecture) ? $manifest.ProcessorArchitecture : 'None' : 'None'
-        Write-Verbose "[ProcessorArchitecture] - [$($manifest.ProcessorArchitecture)]"
+        Write-Host "[ProcessorArchitecture] - [$($manifest.ProcessorArchitecture)]"
 
         # Get the path separator for the current OS
         $pathSeparator = [System.IO.Path]::DirectorySeparatorChar
 
-        Write-Verbose '[FileList]'
+        Write-Host '[FileList]'
         $files = [System.Collections.Generic.List[System.IO.FileInfo]]::new()
 
         # Get files on module root
@@ -105,27 +105,27 @@ function Build-PSModuleManifest {
         # Get the relative file path and store it in the manifest
         $files = $files | Select-Object -ExpandProperty FullName | ForEach-Object { $_.Replace($ModuleOutputFolder, '').TrimStart($pathSeparator) }
         $manifest.FileList = $files.count -eq 0 ? @() : @($files)
-        $manifest.FileList | ForEach-Object { Write-Verbose "[FileList] - [$_]" }
+        $manifest.FileList | ForEach-Object { Write-Host "[FileList] - [$_]" }
 
-        Write-Verbose '[RequiredAssemblies]'
+        Write-Host '[RequiredAssemblies]'
         $requiredAssembliesFolderPath = Join-Path $ModuleOutputFolder 'assemblies'
         $requiredAssemblies = Get-ChildItem -Path $RequiredAssembliesFolderPath -Recurse -File -ErrorAction SilentlyContinue -Filter '*.dll' |
             Select-Object -ExpandProperty FullName |
             ForEach-Object { $_.Replace($ModuleOutputFolder, '').TrimStart($pathSeparator) }
         $manifest.RequiredAssemblies = $requiredAssemblies.count -eq 0 ? @() : @($requiredAssemblies)
-        $manifest.RequiredAssemblies | ForEach-Object { Write-Verbose "[RequiredAssemblies] - [$_]" }
+        $manifest.RequiredAssemblies | ForEach-Object { Write-Host "[RequiredAssemblies] - [$_]" }
 
-        Write-Verbose '[NestedModules]'
+        Write-Host '[NestedModules]'
         $nestedModulesFolderPath = Join-Path $ModuleOutputFolder 'modules'
         $nestedModules = Get-ChildItem -Path $nestedModulesFolderPath -Recurse -File -ErrorAction SilentlyContinue -Include '*.psm1', '*.ps1' |
             Select-Object -ExpandProperty FullName |
             ForEach-Object { $_.Replace($ModuleOutputFolder, '').TrimStart($pathSeparator) }
         $manifest.NestedModules = $nestedModules.count -eq 0 ? @() : @($nestedModules)
-        $manifest.NestedModules | ForEach-Object { Write-Verbose "[NestedModules] - [$_]" }
+        $manifest.NestedModules | ForEach-Object { Write-Host "[NestedModules] - [$_]" }
 
-        Write-Verbose '[ScriptsToProcess]'
+        Write-Host '[ScriptsToProcess]'
         $allScriptsToProcess = @('scripts') | ForEach-Object {
-            Write-Verbose "[ScriptsToProcess] - Processing [$_]"
+            Write-Host "[ScriptsToProcess] - Processing [$_]"
             $scriptsFolderPath = Join-Path $ModuleOutputFolder $_
             $scriptsToProcess = Get-ChildItem -Path $scriptsFolderPath -Recurse -File -ErrorAction SilentlyContinue -Include '*.ps1' |
                 Select-Object -ExpandProperty FullName |
@@ -133,52 +133,52 @@ function Build-PSModuleManifest {
                 $scriptsToProcess
             }
             $manifest.ScriptsToProcess = $allScriptsToProcess.count -eq 0 ? @() : @($allScriptsToProcess)
-            $manifest.ScriptsToProcess | ForEach-Object { Write-Verbose "[ScriptsToProcess] - [$_]" }
+            $manifest.ScriptsToProcess | ForEach-Object { Write-Host "[ScriptsToProcess] - [$_]" }
 
-            Write-Verbose '[TypesToProcess]'
+            Write-Host '[TypesToProcess]'
             $typesToProcess = Get-ChildItem -Path $ModuleOutputFolder -Recurse -File -ErrorAction SilentlyContinue -Include '*.Types.ps1xml' |
                 Select-Object -ExpandProperty FullName |
                 ForEach-Object { $_.Replace($ModuleOutputFolder, '').TrimStart($pathSeparator) }
         $manifest.TypesToProcess = $typesToProcess.count -eq 0 ? @() : @($typesToProcess)
-        $manifest.TypesToProcess | ForEach-Object { Write-Verbose "[TypesToProcess] - [$_]" }
+        $manifest.TypesToProcess | ForEach-Object { Write-Host "[TypesToProcess] - [$_]" }
 
-        Write-Verbose '[FormatsToProcess]'
+        Write-Host '[FormatsToProcess]'
         $formatsToProcess = Get-ChildItem -Path $ModuleOutputFolder -Recurse -File -ErrorAction SilentlyContinue -Include '*.Format.ps1xml' |
             Select-Object -ExpandProperty FullName |
             ForEach-Object { $_.Replace($ModuleOutputFolder, '').TrimStart($pathSeparator) }
         $manifest.FormatsToProcess = $formatsToProcess.count -eq 0 ? @() : @($formatsToProcess)
-        $manifest.FormatsToProcess | ForEach-Object { Write-Verbose "[FormatsToProcess] - [$_]" }
+        $manifest.FormatsToProcess | ForEach-Object { Write-Host "[FormatsToProcess] - [$_]" }
 
-        Write-Verbose '[DscResourcesToExport]'
+        Write-Host '[DscResourcesToExport]'
         $dscResourcesToExportFolderPath = Join-Path $ModuleOutputFolder 'resources'
         $dscResourcesToExport = Get-ChildItem -Path $dscResourcesToExportFolderPath -Recurse -File -ErrorAction SilentlyContinue -Include '*.psm1' |
             Select-Object -ExpandProperty FullName |
             ForEach-Object { $_.Replace($ModuleOutputFolder, '').TrimStart($pathSeparator) }
         $manifest.DscResourcesToExport = $dscResourcesToExport.count -eq 0 ? @() : @($dscResourcesToExport)
-        $manifest.DscResourcesToExport | ForEach-Object { Write-Verbose "[DscResourcesToExport] - [$_]" }
+        $manifest.DscResourcesToExport | ForEach-Object { Write-Host "[DscResourcesToExport] - [$_]" }
 
         $manifest.FunctionsToExport = Get-PSModuleFunctionsToExport -SourceFolderPath $ModuleOutputFolder
         $manifest.CmdletsToExport = Get-PSModuleCmdletsToExport -SourceFolderPath $ModuleOutputFolder
         $manifest.AliasesToExport = Get-PSModuleAliasesToExport -SourceFolderPath $ModuleOutputFolder
         $manifest.VariablesToExport = Get-PSModuleVariablesToExport -SourceFolderPath $ModuleOutputFolder
 
-        Write-Verbose '[ModuleList]'
+        Write-Host '[ModuleList]'
         $moduleList = Get-ChildItem -Path $ModuleOutputFolder -Recurse -File -ErrorAction SilentlyContinue -Include '*.psm1' | Where-Object -Property Name -NE $rootModule |
             Select-Object -ExpandProperty FullName |
             ForEach-Object { $_.Replace($ModuleOutputFolder, '').TrimStart($pathSeparator) }
         $manifest.ModuleList = $moduleList.count -eq 0 ? @() : @($moduleList)
-        $manifest.ModuleList | ForEach-Object { Write-Verbose "[ModuleList] - [$_]" }
+        $manifest.ModuleList | ForEach-Object { Write-Host "[ModuleList] - [$_]" }
 
-        Write-Verbose '[Gather]'
+        Write-Host '[Gather]'
         $capturedModules = [System.Collections.Generic.List[System.Object]]::new()
         $capturedVersions = [System.Collections.Generic.List[string]]::new()
         $capturedPSEdition = [System.Collections.Generic.List[string]]::new()
 
         $files = $ModuleOutputFolder | Get-ChildItem -Recurse -File -ErrorAction SilentlyContinue
-        Write-Verbose "[Gather] - Processing [$($files.Count)] files"
+        Write-Host "[Gather] - Processing [$($files.Count)] files"
         foreach ($file in $files) {
             $relativePath = $file.FullName.Replace($ModuleOutputFolder, '').TrimStart($pathSeparator)
-            Write-Verbose "[Gather] - [$relativePath]"
+            Write-Host "[Gather] - [$relativePath]"
 
             if ($file.extension -in '.psm1', '.ps1') {
                 $fileContent = Get-Content -Path $file
@@ -191,21 +191,21 @@ function Build-PSModuleManifest {
                         $capturedMatches | ForEach-Object {
                             $hashtable = '@\{[^}]*\}'
                             if ($_ -match $hashtable) {
-                                Write-Verbose " - [#Requires -Modules] - [$_] - Hashtable"
+                                Write-Host " - [#Requires -Modules] - [$_] - Hashtable"
                             } else {
-                                Write-Verbose " - [#Requires -Modules] - [$_] - String"
+                                Write-Host " - [#Requires -Modules] - [$_] - String"
                             }
                             $capturedModules.Add($_)
                         }
                     }
                     # PowerShellVersion -> REQUIRES -Version <N>[.<n>], $null if not provided
                     '^\s*#Requires -Version (.+)$' {
-                        Write-Verbose " - [#Requires -Version] - [$($matches[1])]"
+                        Write-Host " - [#Requires -Version] - [$($matches[1])]"
                         $capturedVersions.Add($matches[1])
                     }
                     #CompatiblePSEditions -> REQUIRES -PSEdition <PSEdition-Name>, $null if not provided
                     '^\s*#Requires -PSEdition (.+)$' {
-                        Write-Verbose " - [#Requires -PSEdition] - [$($matches[1])]"
+                        Write-Host " - [#Requires -PSEdition] - [$($matches[1])]"
                         $capturedPSEdition.Add($matches[1])
                     }
                 }
@@ -223,7 +223,7 @@ function Build-PSModuleManifest {
             $required.ToString()
         #>
 
-        Write-Verbose '[RequiredModules] - Gathered'
+        Write-Host '[RequiredModules] - Gathered'
         # Group the module specifications by ModuleName
         $capturedModules = $capturedModules | ForEach-Object {
             $test = [Microsoft.PowerShell.Commands.ModuleSpecification]::new()
@@ -242,13 +242,13 @@ function Build-PSModuleManifest {
         # Iterate through each group
         foreach ($group in $groupedModules) {
             $requiredModuleName = $group.Name
-            Write-Verbose "Processing required module [$requiredModuleName]"
+            Write-Host "Processing required module [$requiredModuleName]"
             $requiredVersion = $group.Group.RequiredVersion | ForEach-Object { [Version]$_ } | Sort-Object -Unique
             $minimumVersion = $group.Group.Version | ForEach-Object { [Version]$_ } | Sort-Object -Unique | Select-Object -Last 1
             $maximumVersion = $group.Group.MaximumVersion | ForEach-Object { [Version]$_ } | Sort-Object -Unique | Select-Object -First 1
-            Write-Verbose "RequiredVersion: [$($requiredVersion -join ', ')]"
-            Write-Verbose "ModuleVersion:   [$minimumVersion]"
-            Write-Verbose "MaximumVersion:  [$maximumVersion]"
+            Write-Host "RequiredVersion: [$($requiredVersion -join ', ')]"
+            Write-Host "ModuleVersion:   [$minimumVersion]"
+            Write-Host "MaximumVersion:  [$maximumVersion]"
 
             if ($requiredVersion.Count -gt 1) {
                 throw 'Multiple RequiredVersions specified.'
@@ -274,13 +274,13 @@ function Build-PSModuleManifest {
             }
 
             if ($requiredVersion) {
-                Write-Verbose '[RequiredModules] - RequiredVersion'
+                Write-Host '[RequiredModules] - RequiredVersion'
                 $uniqueModule = @{
                     ModuleName      = $requiredModuleName
                     RequiredVersion = $requiredVersion
                 }
             } elseif (($minimumVersion -ne [Version]'0.0.0') -or ($maximumVersion -ne [Version]'9999.9999.9999')) {
-                Write-Verbose '[RequiredModules] - ModuleVersion/MaximumVersion'
+                Write-Host '[RequiredModules] - ModuleVersion/MaximumVersion'
                 $uniqueModule = @{
                     ModuleName = $requiredModuleName
                 }
@@ -291,61 +291,61 @@ function Build-PSModuleManifest {
                     $uniqueModule['MaximumVersion'] = $maximumVersion
                 }
             } else {
-                Write-Verbose '[RequiredModules] - Simple string'
+                Write-Host '[RequiredModules] - Simple string'
                 $uniqueModule = $requiredModuleName
             }
             $uniqueModules.Add([Microsoft.PowerShell.Commands.ModuleSpecification]::new($uniqueModule))
         }
 
-        Write-Verbose '[RequiredModules] - Result'
+        Write-Host '[RequiredModules] - Result'
         $manifest.RequiredModules = $uniqueModules
-        $manifest.RequiredModules | ForEach-Object { Write-Verbose " - [$($_ | Out-String)]" }
+        $manifest.RequiredModules | ForEach-Object { Write-Host " - [$($_ | Out-String)]" }
 
-        Write-Verbose '[PowerShellVersion]'
+        Write-Host '[PowerShellVersion]'
         $capturedVersions = $capturedVersions | Sort-Object -Unique -Descending
-        $capturedVersions | ForEach-Object { Write-Verbose "[PowerShellVersion] - [$_]" }
+        $capturedVersions | ForEach-Object { Write-Host "[PowerShellVersion] - [$_]" }
         $manifest.PowerShellVersion = $capturedVersions.count -eq 0 ? [version]'5.1' : [version]($capturedVersions | Select-Object -First 1)
-        Write-Verbose '[PowerShellVersion] - Selecting version'
-        Write-Verbose "[PowerShellVersion] - [$($manifest.PowerShellVersion)]"
+        Write-Host '[PowerShellVersion] - Selecting version'
+        Write-Host "[PowerShellVersion] - [$($manifest.PowerShellVersion)]"
 
-        Write-Verbose '[CompatiblePSEditions]'
+        Write-Host '[CompatiblePSEditions]'
         $capturedPSEdition = $capturedPSEdition | Sort-Object -Unique
         if ($capturedPSEdition.count -eq 2) {
             throw "Conflict detected: The module requires both 'Desktop' and 'Core' editions." +
             "'Desktop' and 'Core' editions cannot be required at the same time."
         }
         if ($capturedPSEdition.count -eq 0 -and $manifest.PowerShellVersion -gt '5.1') {
-            Write-Verbose "[CompatiblePSEditions] - Defaulting to 'Core', as no PSEdition was specified and PowerShellVersion > 5.1"
+            Write-Host "[CompatiblePSEditions] - Defaulting to 'Core', as no PSEdition was specified and PowerShellVersion > 5.1"
             $capturedPSEdition = @('Core')
         }
         $manifest.CompatiblePSEditions = $capturedPSEdition.count -eq 0 ? @('Core', 'Desktop') : @($capturedPSEdition)
-        $manifest.CompatiblePSEditions | ForEach-Object { Write-Verbose "[CompatiblePSEditions] - [$_]" }
+        $manifest.CompatiblePSEditions | ForEach-Object { Write-Host "[CompatiblePSEditions] - [$_]" }
 
         if ($manifest.PowerShellVersion -gt '5.1' -and $manifest.CompatiblePSEditions -contains 'Desktop') {
             throw "Conflict detected: The module requires PowerShellVersion > 5.1 while CompatiblePSEditions = 'Desktop'" +
             "'Desktop' edition is not supported for PowerShellVersion > 5.1"
         }
 
-        Write-Verbose '[PrivateData]'
+        Write-Host '[PrivateData]'
         $privateData = $manifest.Keys -contains 'PrivateData' ? $null -ne $manifest.PrivateData ? $manifest.PrivateData : @{} : @{}
         if ($manifest.Keys -contains 'PrivateData') {
             $manifest.Remove('PrivateData')
         }
 
-        Write-Verbose '[HelpInfoURI]'
+        Write-Host '[HelpInfoURI]'
         $manifest.HelpInfoURI = $privateData.Keys -contains 'HelpInfoURI' ? $null -ne $privateData.HelpInfoURI ? $privateData.HelpInfoURI : '' : ''
-        Write-Verbose "[HelpInfoURI] - [$($manifest.HelpInfoURI)]"
+        Write-Host "[HelpInfoURI] - [$($manifest.HelpInfoURI)]"
         if ([string]::IsNullOrEmpty($manifest.HelpInfoURI)) {
             $manifest.Remove('HelpInfoURI')
         }
 
-        Write-Verbose '[DefaultCommandPrefix]'
+        Write-Host '[DefaultCommandPrefix]'
         $manifest.DefaultCommandPrefix = $privateData.Keys -contains 'DefaultCommandPrefix' ? $null -ne $privateData.DefaultCommandPrefix ? $privateData.DefaultCommandPrefix : '' : ''
-        Write-Verbose "[DefaultCommandPrefix] - [$($manifest.DefaultCommandPrefix)]"
+        Write-Host "[DefaultCommandPrefix] - [$($manifest.DefaultCommandPrefix)]"
 
         $PSData = $privateData.Keys -contains 'PSData' ? $null -ne $privateData.PSData ? $privateData.PSData : @{} : @{}
 
-        Write-Verbose '[Tags]'
+        Write-Host '[Tags]'
         try {
             $repoLabels = gh repo view --json repositoryTopics | ConvertFrom-Json | Select-Object -ExpandProperty repositoryTopics | Select-Object -ExpandProperty name
         } catch {
@@ -365,7 +365,7 @@ function Build-PSModuleManifest {
                 $manifestTags.Add('PSEdition_Core')
             }
         }
-        $manifestTags | ForEach-Object { Write-Verbose "[Tags] - [$_]" }
+        $manifestTags | ForEach-Object { Write-Host "[Tags] - [$_]" }
         $manifest.Tags = $manifestTags
 
         if ($PSData.Tags -contains 'PSEdition_Core' -and $manifest.PowerShellVersion -lt '6.0') {
@@ -378,59 +378,59 @@ function Build-PSModuleManifest {
             https://learn.microsoft.com/en-us/powershell/gallery/concepts/package-manifest-affecting-ui?view=powershellget-2.x#tag-details
         #>
 
-        Write-Verbose '[LicenseUri]'
+        Write-Host '[LicenseUri]'
         $licenseUri = "https://github.com/$env:GITHUB_REPOSITORY_OWNER/$env:GITHUB_REPOSITORY_NAME/blob/main/LICENSE"
         $manifest.LicenseUri = $PSData.Keys -contains 'LicenseUri' ? $null -ne $PSData.LicenseUri ? $PSData.LicenseUri : $licenseUri : $licenseUri
-        Write-Verbose "[LicenseUri] - [$($manifest.LicenseUri)]"
+        Write-Host "[LicenseUri] - [$($manifest.LicenseUri)]"
         if ([string]::IsNullOrEmpty($manifest.LicenseUri)) {
             $manifest.Remove('LicenseUri')
         }
 
-        Write-Verbose '[ProjectUri]'
+        Write-Host '[ProjectUri]'
         $projectUri = gh repo view --json url | ConvertFrom-Json | Select-Object -ExpandProperty url
         $manifest.ProjectUri = $PSData.Keys -contains 'ProjectUri' ? $null -ne $PSData.ProjectUri ? $PSData.ProjectUri : $projectUri : $projectUri
-        Write-Verbose "[ProjectUri] - [$($manifest.ProjectUri)]"
+        Write-Host "[ProjectUri] - [$($manifest.ProjectUri)]"
         if ([string]::IsNullOrEmpty($manifest.ProjectUri)) {
             $manifest.Remove('ProjectUri')
         }
 
-        Write-Verbose '[IconUri]'
+        Write-Host '[IconUri]'
         $iconUri = "https://raw.githubusercontent.com/$env:GITHUB_REPOSITORY_OWNER/$env:GITHUB_REPOSITORY_NAME/main/icon/icon.png"
         $manifest.IconUri = $PSData.Keys -contains 'IconUri' ? $null -ne $PSData.IconUri ? $PSData.IconUri : $iconUri : $iconUri
-        Write-Verbose "[IconUri] - [$($manifest.IconUri)]"
+        Write-Host "[IconUri] - [$($manifest.IconUri)]"
         if ([string]::IsNullOrEmpty($manifest.IconUri)) {
             $manifest.Remove('IconUri')
         }
 
-        Write-Verbose '[ReleaseNotes]'
+        Write-Host '[ReleaseNotes]'
         $manifest.ReleaseNotes = $PSData.Keys -contains 'ReleaseNotes' ? $null -ne $PSData.ReleaseNotes ? $PSData.ReleaseNotes : '' : ''
-        Write-Verbose "[ReleaseNotes] - [$($manifest.ReleaseNotes)]"
+        Write-Host "[ReleaseNotes] - [$($manifest.ReleaseNotes)]"
         if ([string]::IsNullOrEmpty($manifest.ReleaseNotes)) {
             $manifest.Remove('ReleaseNotes')
         }
 
-        Write-Verbose '[PreRelease]'
+        Write-Host '[PreRelease]'
         # $manifest.PreRelease = ""
         # Is managed by the publish action
 
-        Write-Verbose '[RequireLicenseAcceptance]'
+        Write-Host '[RequireLicenseAcceptance]'
         $manifest.RequireLicenseAcceptance = $PSData.Keys -contains 'RequireLicenseAcceptance' ? $null -ne $PSData.RequireLicenseAcceptance ? $PSData.RequireLicenseAcceptance : $false : $false
-        Write-Verbose "[RequireLicenseAcceptance] - [$($manifest.RequireLicenseAcceptance)]"
+        Write-Host "[RequireLicenseAcceptance] - [$($manifest.RequireLicenseAcceptance)]"
         if ($manifest.RequireLicenseAcceptance -eq $false) {
             $manifest.Remove('RequireLicenseAcceptance')
         }
 
-        Write-Verbose '[ExternalModuleDependencies]'
+        Write-Host '[ExternalModuleDependencies]'
         $manifest.ExternalModuleDependencies = $PSData.Keys -contains 'ExternalModuleDependencies' ? $null -ne $PSData.ExternalModuleDependencies ? $PSData.ExternalModuleDependencies : @() : @()
         if (($manifest.ExternalModuleDependencies).count -eq 0) {
             $manifest.Remove('ExternalModuleDependencies')
         } else {
-            $manifest.ExternalModuleDependencies | ForEach-Object { Write-Verbose "[ExternalModuleDependencies] - [$_]" }
+            $manifest.ExternalModuleDependencies | ForEach-Object { Write-Host "[ExternalModuleDependencies] - [$_]" }
         }
 
-        Write-Verbose 'Creating new manifest file in outputs folder'
+        Write-Host 'Creating new manifest file in outputs folder'
         $outputManifestPath = Join-Path -Path $ModuleOutputFolder -ChildPath "$ModuleName.psd1"
-        Write-Verbose "OutputManifestPath - [$outputManifestPath]"
+        Write-Host "OutputManifestPath - [$outputManifestPath]"
         New-ModuleManifest -Path $outputManifestPath @manifest
     }
 
@@ -439,7 +439,7 @@ function Build-PSModuleManifest {
     }
 
     LogGroup 'Build manifest file - Format' {
-        Set-ModuleManifest -Path $outputManifestPath
+        Set-ModuleManifest -Path $outputManifestPath -Verbose
     }
 
     LogGroup 'Build manifest file - Result - After format' {
diff --git a/scripts/helpers/Build/Build-PSModuleRootModule.ps1 b/scripts/helpers/Build/Build-PSModuleRootModule.ps1
index 623fb37f..28013b5b 100644
--- a/scripts/helpers/Build/Build-PSModuleRootModule.ps1
+++ b/scripts/helpers/Build/Build-PSModuleRootModule.ps1
@@ -129,7 +129,7 @@ $MyInvocation.MyCommand.ScriptBlock.Module.OnRemove = {
         $exports.Add('Function', (Get-PSModuleFunctionsToExport -SourceFolderPath $ModuleOutputFolder))
         $exports.Add('Variable', (Get-PSModuleVariablesToExport -SourceFolderPath $ModuleOutputFolder))
 
-        Write-Verbose ($exports | Out-String)
+        Write-Host ($exports | Out-String)
         #endregion - Analyze source files
 
         #region - Module header
@@ -223,7 +223,7 @@ Write-Debug "[`$scriptName] - $relativePath - Done"
 
         $exportsString = Convert-HashtableToString -Hashtable $exports
 
-        Write-Verbose ($exportsString | Out-String)
+        Write-Host ($exportsString | Out-String)
 
         $params = @{
             Path  = $rootModuleFile
diff --git a/scripts/helpers/Build/Get-PSModuleAliasesToExport.ps1 b/scripts/helpers/Build/Get-PSModuleAliasesToExport.ps1
index 0d3a1545..6c016d7f 100644
--- a/scripts/helpers/Build/Get-PSModuleAliasesToExport.ps1
+++ b/scripts/helpers/Build/Get-PSModuleAliasesToExport.ps1
@@ -24,10 +24,10 @@
 
     $manifest = Get-ModuleManifest -Path $manifestFilePath -Verbose:$false
 
-    Write-Verbose "[$manifestPropertyName]"
+    Write-Host "[$manifestPropertyName]"
     $aliasesToExport = (($manifest.AliasesToExport).count -eq 0) -or ($manifest.AliasesToExport | IsNullOrEmpty) ? '*' : $manifest.AliasesToExport
     $aliasesToExport | ForEach-Object {
-        Write-Verbose "[$manifestPropertyName] - [$_]"
+        Write-Host "[$manifestPropertyName] - [$_]"
     }
 
     $aliasesToExport
diff --git a/scripts/helpers/Build/Get-PSModuleCmdletsToExport.ps1 b/scripts/helpers/Build/Get-PSModuleCmdletsToExport.ps1
index aa0b1e9f..a51623f2 100644
--- a/scripts/helpers/Build/Get-PSModuleCmdletsToExport.ps1
+++ b/scripts/helpers/Build/Get-PSModuleCmdletsToExport.ps1
@@ -24,10 +24,10 @@
 
     $manifest = Get-ModuleManifest -Path $manifestFilePath -Verbose:$false
 
-    Write-Verbose "[$manifestPropertyName]"
+    Write-Host "[$manifestPropertyName]"
     $cmdletsToExport = (($manifest.CmdletsToExport).count -eq 0) -or ($manifest.CmdletsToExport | IsNullOrEmpty) ? '' : $manifest.CmdletsToExport
     $cmdletsToExport | ForEach-Object {
-        Write-Verbose "[$manifestPropertyName] - [$_]"
+        Write-Host "[$manifestPropertyName] - [$_]"
     }
 
     $cmdletsToExport
diff --git a/scripts/helpers/Build/Get-PSModuleFunctionsToExport.ps1 b/scripts/helpers/Build/Get-PSModuleFunctionsToExport.ps1
index 89c5d12f..99f34967 100644
--- a/scripts/helpers/Build/Get-PSModuleFunctionsToExport.ps1
+++ b/scripts/helpers/Build/Get-PSModuleFunctionsToExport.ps1
@@ -19,22 +19,22 @@
 
     $manifestPropertyName = 'FunctionsToExport'
 
-    Write-Verbose "[$manifestPropertyName]"
-    Write-Verbose "[$manifestPropertyName] - Checking path for functions and filters"
+    Write-Host "[$manifestPropertyName]"
+    Write-Host "[$manifestPropertyName] - Checking path for functions and filters"
 
     $publicFolderPath = Join-Path -Path $SourceFolderPath -ChildPath 'functions/public'
     if (-not (Test-Path -Path $publicFolderPath -PathType Container)) {
-        Write-Verbose "[$manifestPropertyName] - [Folder not found] - [$publicFolderPath]"
+        Write-Host "[$manifestPropertyName] - [Folder not found] - [$publicFolderPath]"
         return $functionsToExport
     }
-    Write-Verbose "[$manifestPropertyName] - [$publicFolderPath]"
+    Write-Host "[$manifestPropertyName] - [$publicFolderPath]"
     $functionsToExport = [Collections.Generic.List[string]]::new()
     $scriptFiles = Get-ChildItem -Path $publicFolderPath -Recurse -File -ErrorAction SilentlyContinue -Include '*.ps1'
-    Write-Verbose "[$manifestPropertyName] - [$($scriptFiles.Count)]"
+    Write-Host "[$manifestPropertyName] - [$($scriptFiles.Count)]"
     foreach ($file in $scriptFiles) {
         $fileContent = Get-Content -Path $file.FullName -Raw
         $containsFunction = ($fileContent -match 'function ') -or ($fileContent -match 'filter ')
-        Write-Verbose "[$manifestPropertyName] - [$($file.BaseName)] - [$containsFunction]"
+        Write-Host "[$manifestPropertyName] - [$($file.BaseName)] - [$containsFunction]"
         if ($containsFunction) {
             $functionsToExport.Add($file.BaseName)
         }
diff --git a/scripts/helpers/Build/Get-PSModuleVariablesToExport.ps1 b/scripts/helpers/Build/Get-PSModuleVariablesToExport.ps1
index b8cd5234..004d6325 100644
--- a/scripts/helpers/Build/Get-PSModuleVariablesToExport.ps1
+++ b/scripts/helpers/Build/Get-PSModuleVariablesToExport.ps1
@@ -19,11 +19,11 @@
 
     $manifestPropertyName = 'VariablesToExport'
 
-    Write-Verbose "[$manifestPropertyName]"
+    Write-Host "[$manifestPropertyName]"
 
     $variableFolderPath = Join-Path -Path $SourceFolderPath -ChildPath 'variables/public'
     if (-not (Test-Path -Path $variableFolderPath -PathType Container)) {
-        Write-Verbose "[$manifestPropertyName] - [Folder not found] - [$variableFolderPath]"
+        Write-Host "[$manifestPropertyName] - [Folder not found] - [$variableFolderPath]"
         return $variablesToExport
     }
     $scriptFilePaths = Get-ChildItem -Path $variableFolderPath -Recurse -File -Filter *.ps1 | Select-Object -ExpandProperty FullName
@@ -38,7 +38,7 @@
     }
 
     $variablesToExport | ForEach-Object {
-        Write-Verbose "[$manifestPropertyName] - [$_]"
+        Write-Host "[$manifestPropertyName] - [$_]"
     }
 
     $variablesToExport
diff --git a/scripts/helpers/Build/Import-PSModule.ps1 b/scripts/helpers/Build/Import-PSModule.ps1
index efdae829..dbcac47c 100644
--- a/scripts/helpers/Build/Import-PSModule.ps1
+++ b/scripts/helpers/Build/Import-PSModule.ps1
@@ -27,7 +27,7 @@
     $manifestFilePath = Join-Path -Path $Path $manifestFileName
     $manifestFile = Get-ModuleManifest -Path $manifestFilePath -As FileInfo -Verbose
 
-    Write-Verbose "Manifest file path: [$($manifestFile.FullName)]" -Verbose
+    Write-Host "Manifest file path: [$($manifestFile.FullName)]" -Verbose
     $existingModule = Get-Module -Name $ModuleName -ListAvailable
     $existingModule | Remove-Module -Force -Verbose
     $existingModule.RequiredModules | ForEach-Object { $_ | Remove-Module -Force -Verbose -ErrorAction SilentlyContinue }
@@ -36,11 +36,11 @@
     Resolve-PSModuleDependencies -ManifestFilePath $manifestFile
     Import-Module -Name $ModuleName -RequiredVersion '999.0.0'
 
-    Write-Verbose 'List loaded modules'
+    Write-Host 'List loaded modules'
     $availableModules = Get-Module -ListAvailable -Refresh -Verbose:$false
     $availableModules | Select-Object Name, Version, Path | Sort-Object Name | Format-Table -AutoSize
-    Write-Verbose 'List commands'
-    Write-Verbose (Get-Command -Module $moduleName | Format-Table -AutoSize | Out-String)
+    Write-Host 'List commands'
+    Write-Host (Get-Command -Module $moduleName | Format-Table -AutoSize | Out-String)
 
     if ($ModuleName -notin $availableModules.Name) {
         throw 'Module not found'
diff --git a/scripts/helpers/Build/Resolve-PSModuleDependency.ps1 b/scripts/helpers/Build/Resolve-PSModuleDependency.ps1
index 7d8d0675..8a6ddca8 100644
--- a/scripts/helpers/Build/Resolve-PSModuleDependency.ps1
+++ b/scripts/helpers/Build/Resolve-PSModuleDependency.ps1
@@ -26,11 +26,11 @@ function Resolve-PSModuleDependency {
         [string] $ManifestFilePath
     )
 
-    Write-Verbose 'Resolving dependencies'
+    Write-Host 'Resolving dependencies'
 
     $manifest = Import-PowerShellDataFile -Path $ManifestFilePath
-    Write-Verbose "Reading [$ManifestFilePath]"
-    Write-Verbose "Found [$($manifest.RequiredModules.Count)] modules to install"
+    Write-Host "Reading [$ManifestFilePath]"
+    Write-Host "Found [$($manifest.RequiredModules.Count)] modules to install"
 
     foreach ($requiredModule in $manifest.RequiredModules) {
         $installParams = @{}
@@ -46,19 +46,19 @@ function Resolve-PSModuleDependency {
         $installParams.Force = $true
         $installParams.Verbose = $false
 
-        Write-Verbose "[$($installParams.Name)] - Installing module"
+        Write-Host "[$($installParams.Name)] - Installing module"
         $VerbosePreferenceOriginal = $VerbosePreference
         $VerbosePreference = 'SilentlyContinue'
         Retry -Count 5 -Delay 10 {
             Install-Module @installParams -AllowPrerelease:$false
         }
         $VerbosePreference = $VerbosePreferenceOriginal
-        Write-Verbose "[$($installParams.Name)] - Importing module"
+        Write-Host "[$($installParams.Name)] - Importing module"
         $VerbosePreferenceOriginal = $VerbosePreference
         $VerbosePreference = 'SilentlyContinue'
         Import-Module @installParams
         $VerbosePreference = $VerbosePreferenceOriginal
-        Write-Verbose "[$($installParams.Name)] - Done"
+        Write-Host "[$($installParams.Name)] - Done"
     }
-    Write-Verbose 'Resolving dependencies - Done'
+    Write-Host 'Resolving dependencies - Done'
 }
diff --git a/scripts/helpers/Build/Update-PSModuleManifestAliasesToExport.ps1 b/scripts/helpers/Build/Update-PSModuleManifestAliasesToExport.ps1
index 58b9cfc7..ac805c95 100644
--- a/scripts/helpers/Build/Update-PSModuleManifestAliasesToExport.ps1
+++ b/scripts/helpers/Build/Update-PSModuleManifestAliasesToExport.ps1
@@ -21,17 +21,17 @@ function Update-PSModuleManifestAliasesToExport {
         [Parameter(Mandatory)]
         [System.IO.DirectoryInfo] $ModuleOutputFolder
     )
-    LogGroup "Updating aliases to export in module manifest" {
-        Write-Verbose "Module name: [$ModuleName]"
-        Write-Verbose "Module output folder: [$ModuleOutputFolder]"
+    LogGroup 'Updating aliases to export in module manifest' {
+        Write-Host "Module name: [$ModuleName]"
+        Write-Host "Module output folder: [$ModuleOutputFolder]"
         $aliases = Get-Command -Module $ModuleName -CommandType Alias
-        Write-Verbose "Found aliases: [$($aliases.Count)]"
+        Write-Host "Found aliases: [$($aliases.Count)]"
         foreach ($alias in $aliases) {
-            Write-Verbose "Alias: [$($alias.Name)]"
+            Write-Host "Alias: [$($alias.Name)]"
         }
         $outputManifestPath = Join-Path -Path $ModuleOutputFolder -ChildPath "$ModuleName.psd1"
-        Write-Verbose "Output manifest path: [$outputManifestPath]"
-        Write-Verbose "Setting module manifest with AliasesToExport"
-        Set-ModuleManifest -Path $outputManifestPath -AliasesToExport $aliases.Name
+        Write-Host "Output manifest path: [$outputManifestPath]"
+        Write-Host 'Setting module manifest with AliasesToExport'
+        Set-ModuleManifest -Path $outputManifestPath -AliasesToExport $aliases.Name -Verbose
     }
 }
diff --git a/scripts/main.ps1 b/scripts/main.ps1
index 2cb2f7a2..2220d0e0 100644
--- a/scripts/main.ps1
+++ b/scripts/main.ps1
@@ -6,28 +6,28 @@ param()
 $path = (Join-Path -Path $PSScriptRoot -ChildPath 'helpers')
 LogGroup "Loading helper scripts from [$path]" {
     Get-ChildItem -Path $path -Filter '*.ps1' -Recurse | ForEach-Object {
-        Write-Verbose "[$($_.FullName)]"
+        Write-Host "[$($_.FullName)]"
         . $_.FullName
     }
 }
 
 LogGroup 'Loading inputs' {
     $moduleName = ($env:GITHUB_ACTION_INPUT_Name | IsNullOrEmpty) ? $env:GITHUB_REPOSITORY_NAME : $env:GITHUB_ACTION_INPUT_Name
-    Write-Verbose "Module name:         [$moduleName]"
+    Write-Host "Module name:         [$moduleName]"
 
     $moduleSourceFolderPath = Join-Path -Path $env:GITHUB_WORKSPACE -ChildPath $env:GITHUB_ACTION_INPUT_Path $moduleName
     if (-not (Test-Path -Path $moduleSourceFolderPath)) {
         $moduleSourceFolderPath = Join-Path -Path $env:GITHUB_WORKSPACE -ChildPath $env:GITHUB_ACTION_INPUT_Path
     }
-    Write-Verbose "Source module path:  [$moduleSourceFolderPath]"
+    Write-Host "Source module path:  [$moduleSourceFolderPath]"
     if (-not (Test-Path -Path $moduleSourceFolderPath)) {
         throw "Module path [$moduleSourceFolderPath] does not exist."
     }
 
     $modulesOutputFolderPath = Join-Path $env:GITHUB_WORKSPACE $env:GITHUB_ACTION_INPUT_ModulesOutputPath
-    Write-Verbose "Modules output path: [$modulesOutputFolderPath]"
+    Write-Host "Modules output path: [$modulesOutputFolderPath]"
     $docsOutputFolderPath = Join-Path $env:GITHUB_WORKSPACE $env:GITHUB_ACTION_INPUT_DocsOutputPath
-    Write-Verbose "Docs output path:    [$docsOutputFolderPath]"
+    Write-Host "Docs output path:    [$docsOutputFolderPath]"
 }
 
 $params = @{