PluginBench
Skill
Pass
Audit score 90

powershell-windows

sickn33/antigravity-awesome-skills

Master PowerShell Windows syntax rules, error handling, and critical pitfalls to write reliable scripts.

What is powershell-windows?

PowerShell Windows Patterns provides essential syntax rules, operator requirements, and error-handling patterns for Windows PowerShell scripting. Use this when writing or debugging PowerShell scripts to avoid common pitfalls like missing parentheses, unicode characters, and null reference errors.

  • Enforces correct operator syntax with parentheses requirements for logical operators
  • Prevents unicode/emoji usage in scripts with ASCII-only character rules
  • Provides null-check patterns to avoid null reference exceptions
  • Guides string interpolation and complex expression handling
  • Establishes error handling patterns with ErrorActionPreference and try/catch blocks
  • Specifies file path operations using Join-Path for cross-platform safety

How to install powershell-windows

npx skills add https://github.com/sickn33/antigravity-awesome-skills --skill powershell-windows
Claude Code
Cursor
Windsurf
Cline

How to use powershell-windows

  1. 1.Review the operator syntax rules section before using logical operators in conditionals
  2. 2.Apply null-check patterns before accessing properties on variables
  3. 3.Use Join-Path instead of string concatenation for file paths
  4. 4.Wrap cmdlet calls in parentheses when combining with logical operators
  5. 5.Specify -Depth parameter when using ConvertTo-Json on nested objects
  6. 6.Use the provided script template as a starting point for new scripts
  7. 7.Reference the common errors table when encountering unexpected token or parameter errors

Use cases

Good for
  • Writing production PowerShell scripts with proper error handling and null checks
  • Debugging operator syntax errors when using -or, -and with cmdlet calls
  • Converting objects to JSON with correct depth parameters for nested structures
  • Handling file paths safely across different Windows environments
  • Implementing try/catch blocks with proper cleanup and exit codes
Who it's for
  • Windows system administrators
  • PowerShell developers and scripters
  • DevOps engineers using PowerShell automation
  • Anyone debugging PowerShell syntax errors

powershell-windows FAQ

Why do cmdlet calls need parentheses with logical operators?

PowerShell's parser requires each cmdlet call to be wrapped in parentheses when used with -or or -and operators to properly evaluate the boolean expression.

Can I use emoji or unicode characters in PowerShell scripts?

No. Use ASCII-only characters in scripts. Replace emoji with ASCII alternatives like [OK], [!], [*], or [i] for status indicators.

What's the difference between ErrorActionPreference values?

Stop fails immediately (good for development), Continue allows script to continue on errors (production), and SilentlyContinue suppresses error output when errors are expected.

Why should I use Join-Path for file paths?

Join-Path handles path separators correctly across different contexts and is safer than string concatenation for constructing file paths.

What happens if I don't specify -Depth in ConvertTo-Json?

Without -Depth, nested objects may not serialize completely, resulting in truncated or incomplete JSON output. Always specify -Depth 10 or higher for nested structures.

Full instructions (SKILL.md)

Source of truth, from sickn33/antigravity-awesome-skills.


name: powershell-windows description: "PowerShell Windows patterns. Critical pitfalls, operator syntax, error handling." risk: unknown source: community date_added: "2026-02-27"

PowerShell Windows Patterns

Critical patterns and pitfalls for Windows PowerShell.


1. Operator Syntax Rules

CRITICAL: Parentheses Required

❌ Wrong✅ Correct
if (Test-Path "a" -or Test-Path "b")if ((Test-Path "a") -or (Test-Path "b"))
if (Get-Item $x -and $y -eq 5)if ((Get-Item $x) -and ($y -eq 5))

Rule: Each cmdlet call MUST be in parentheses when using logical operators.


2. Unicode/Emoji Restriction

CRITICAL: No Unicode in Scripts

Purpose❌ Don't Use✅ Use
Success✅ ✓[OK] [+]
Error❌ ✗ 🔴[!] [X]
Warning⚠️ 🟡[*] [WARN]
Infoℹ️ 🔵[i] [INFO]
Progress[...]

Rule: Use ASCII characters only in PowerShell scripts.


3. Null Check Patterns

Always Check Before Access

❌ Wrong✅ Correct
$array.Count -gt 0$array -and $array.Count -gt 0
$text.Lengthif ($text) { $text.Length }

4. String Interpolation

Complex Expressions

❌ Wrong✅ Correct
"Value: $($obj.prop.sub)"Store in variable first

Pattern:

$value = $obj.prop.sub
Write-Output "Value: $value"

5. Error Handling

ErrorActionPreference

ValueUse
StopDevelopment (fail fast)
ContinueProduction scripts
SilentlyContinueWhen errors expected

Try/Catch Pattern

  • Don't return inside try block
  • Use finally for cleanup
  • Return after try/catch

6. File Paths

Windows Path Rules

PatternUse
Literal pathC:\Users\User\file.txt
Variable pathJoin-Path $env:USERPROFILE "file.txt"
RelativeJoin-Path $ScriptDir "data"

Rule: Use Join-Path for cross-platform safety.


7. Array Operations

Correct Patterns

OperationSyntax
Empty array$array = @()
Add item$array += $item
ArrayList add`$list.Add($item)

8. JSON Operations

CRITICAL: Depth Parameter

❌ Wrong✅ Correct
ConvertTo-JsonConvertTo-Json -Depth 10

Rule: Always specify -Depth for nested objects.

File Operations

OperationPattern
Read`Get-Content "file.json" -Raw
Write`$data

9. Common Errors

Error MessageCauseFix
"parameter 'or'"Missing parenthesesWrap cmdlets in ()
"Unexpected token"Unicode characterUse ASCII only
"Cannot find property"Null objectCheck null first
"Cannot convert"Type mismatchUse .ToString()

10. Script Template

# Strict mode
Set-StrictMode -Version Latest
$ErrorActionPreference = "Continue"

# Paths
$ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path

# Main
try {
    # Logic here
    Write-Output "[OK] Done"
    exit 0
}
catch {
    Write-Warning "Error: $_"
    exit 1
}

Remember: PowerShell has unique syntax rules. Parentheses, ASCII-only, and null checks are non-negotiable.

When to Use

This skill is applicable to execute the workflow or actions described in the overview.

Limitations

  • Use this skill only when the task clearly matches the scope described above.
  • Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
  • Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.