diff --git a/PSAI.psd1 b/PSAI.psd1
index 1e83929..f276a1f 100644
--- a/PSAI.psd1
+++ b/PSAI.psd1
@@ -39,6 +39,8 @@ PSAI brings OpenAI ChatGPT to PowerShell, leveraging advanced AI capabilities in
         'New-Agent'
         'Get-AgentResponse'
         'Invoke-InteractiveCLI'
+        'Get-PSAISkillFrontmatter'
+        'Read-PSAISkill'
         'Add-OAIVectorStore'
         'Clear-OAIAllItems'
         'Clear-OAIAssistants'
diff --git a/PSAI.psm1 b/PSAI.psm1
index 8aa64ac..2b08cfd 100644
--- a/PSAI.psm1
+++ b/PSAI.psm1
@@ -18,6 +18,8 @@
 . $PSScriptRoot/Public/New-Agent.ps1
 . $PSScriptRoot/Public/Get-AgentResponse.ps1
 . $PSScriptRoot/Public/Invoke-InteractiveCLI.ps1
+. $PSScriptRoot/Public/Get-PSAISkillFrontmatter.ps1
+. $PSScriptRoot/Public/Read-PSAISkill.ps1
 . $PSScriptRoot/Public/Add-OAIVectorStore.ps1
 . $PSScriptRoot/Public/Clear-OAIAllItems.ps1
 . $PSScriptRoot/Public/Clear-OAIAssistants.ps1
diff --git a/Public/Get-PSAISkillFrontmatter.ps1 b/Public/Get-PSAISkillFrontmatter.ps1
new file mode 100644
index 0000000..cf9a536
--- /dev/null
+++ b/Public/Get-PSAISkillFrontmatter.ps1
@@ -0,0 +1,96 @@
+<#
+.SYNOPSIS
+Retrieves skill metadata (name and description) from SKILL.md files in a skills directory.
+
+.DESCRIPTION
+The Get-PSAISkillFrontmatter function scans a directory for SKILL.md files and extracts
+their YAML frontmatter metadata. This implements the Anthropic Claude Skills pattern where
+skills are discovered via their metadata (Level 1 loading).
+
+Each SKILL.md file should have YAML frontmatter with 'name' and 'description' fields:
+---
+name: Skill Name
+description: What this skill does and when to use it
+---
+
+.PARAMETER SkillsRoot
+The root directory containing skill subdirectories. Defaults to "./skills".
+
+.PARAMETER AsPSCustomObject
+Returns results as PowerShell custom objects instead of JSON.
+
+.PARAMETER Compress
+When returning JSON, compress the output to a single line.
+
+.EXAMPLE
+PS> Get-PSAISkillFrontmatter
+Returns JSON array of all skills found in ./skills directory.
+
+.EXAMPLE
+PS> Get-PSAISkillFrontmatter -SkillsRoot "C:\MySkills" -AsPSCustomObject
+Returns PowerShell objects for all skills in the specified directory.
+
+.NOTES
+This function implements the Anthropic Claude Skills architecture pattern for PowerShell,
+enabling progressive disclosure where skill metadata is loaded first, and full skill
+content is loaded on-demand using Read-PSAISkill.
+#>
+function Get-PSAISkillFrontmatter {
+    [CmdletBinding()]
+    param(
+        [Parameter()]
+        [string]$SkillsRoot = "./skills",
+        
+        [Parameter()]
+        [switch]$AsPSCustomObject,
+        
+        [Parameter()]
+        [switch]$Compress
+    )
+
+    $skillFiles = Get-ChildItem -Path $SkillsRoot -Recurse -Filter "SKILL.md" -ErrorAction SilentlyContinue
+    $results = @()
+
+    foreach ($file in $skillFiles) {
+        $lines = Get-Content $file.FullName
+        $start = $lines.IndexOf('---')
+        
+        if ($start -ge 0) {
+            # Find the closing '---' after $start
+            $end = -1
+            for ($i = $start + 1; $i -lt $lines.Count; $i++) {
+                if ($lines[$i] -eq '---') {
+                    $end = $i
+                    break
+                }
+            }
+            
+            if ($end -gt $start) {
+                $frontmatter = $lines[$start..$end]
+                $name = $null
+                $description = $null
+                
+                foreach ($line in $frontmatter) {
+                    if ($line -match '^name:\s*(.+)$') {
+                        $name = $matches[1].Trim()
+                    }
+                    if ($line -match '^description:\s*(.+)$') {
+                        $description = $matches[1].Trim()
+                    }
+                }
+                
+                $results += [PSCustomObject]@{
+                    fullname    = $file.FullName
+                    name        = $name
+                    description = $description
+                }
+            }
+        }
+    }
+
+    if ($AsPSCustomObject) {
+        return $results
+    }
+    
+    return $results | ConvertTo-Json -Depth 3 -Compress:$Compress
+}
diff --git a/Public/Read-PSAISkill.ps1 b/Public/Read-PSAISkill.ps1
new file mode 100644
index 0000000..2f67510
--- /dev/null
+++ b/Public/Read-PSAISkill.ps1
@@ -0,0 +1,46 @@
+<#
+.SYNOPSIS
+Reads the complete content of a skill file.
+
+.DESCRIPTION
+The Read-PSAISkill function reads the entire content of a SKILL.md file (or any file)
+and returns it as a single string. This implements Level 2 loading in the Anthropic 
+Claude Skills pattern, where the full skill instructions are loaded on-demand when
+the AI agent determines a skill is needed.
+
+This function is designed to be called by an AI agent when it needs detailed instructions
+from a skill file. The file path is typically obtained from Get-PSAISkillFrontmatter.
+
+.PARAMETER Fullname
+The full path to the skill file to read. This is typically a SKILL.md file path from
+the Get-PSAISkillFrontmatter output.
+
+.EXAMPLE
+PS> Read-PSAISkill -Fullname "C:\skills\pdf-processing\SKILL.md"
+Returns the complete content of the PDF processing skill file.
+
+.EXAMPLE
+PS> $skills = Get-PSAISkillFrontmatter -AsPSCustomObject
+PS> $pdfSkill = $skills | Where-Object { $_.name -eq "PDF Processing" }
+PS> Read-PSAISkill -Fullname $pdfSkill.fullname
+Discovers and reads a specific skill file.
+
+.NOTES
+This function implements the Anthropic Claude Skills architecture pattern for PowerShell.
+It should only be used to read skill files (SKILL.md) or related resources, not arbitrary
+files. The AI agent's instructions should enforce this constraint.
+#>
+function Read-PSAISkill {
+    [CmdletBinding()]
+    param(
+        [Parameter(Mandatory)]
+        [string]$Fullname
+    )
+
+    if (-not (Test-Path -Path $Fullname)) {
+        Write-Error "File not found: $Fullname"
+        return
+    }
+
+    Get-Content -Path $Fullname -Raw
+}
diff --git a/README.md b/README.md
index 12d2f52..e96cb63 100644
--- a/README.md
+++ b/README.md
@@ -111,6 +111,92 @@ This command will recursively list all files in the specified directory and its
 
 Run either of these commands in PowerShell to output all files in a directory.
 
+## PSAI Skills
+
+**PSAI Skills** bring the Anthropic Claude Skills architecture pattern to PowerShell, enabling modular, reusable capabilities that extend AI agent functionality with domain-specific expertise. Skills use progressive disclosure to load only the information needed at each stage, making agents more efficient and focused.
+
+### What are Skills?
+
+Skills are filesystem-based resources that provide AI agents with:
+- **Domain-specific workflows** and best practices
+- **On-demand loading** (progressive disclosure pattern)
+- **Structured guidance** through YAML frontmatter and markdown content
+
+### Three-Level Loading Architecture
+
+Skills implement a three-level loading pattern inspired by Anthropic Claude:
+
+1. **Level 1: Metadata (always loaded)** - YAML frontmatter with `name` and `description` for skill discovery
+2. **Level 2: Instructions (loaded on-demand)** - Full skill content with workflows and code examples
+3. **Level 3: Resources (loaded as needed)** - Additional files, scripts, and reference materials
+
+### Quick Start with Skills
+
+Discover available skills:
+
+```powershell
+# Get all skills as JSON
+Get-PSAISkillFrontmatter -SkillsRoot "./skills"
+
+# Get skills as PowerShell objects
+Get-PSAISkillFrontmatter -SkillsRoot "./skills" -AsPSCustomObject
+```
+
+Read full skill content:
+
+```powershell
+$skills = Get-PSAISkillFrontmatter -SkillsRoot "./skills" -AsPSCustomObject
+$readSkill = $skills | Where-Object { $_.name -eq "Read File" }
+Read-PSAISkill -Fullname $readSkill.fullname
+```
+
+### Creating a Skills-Enabled Agent
+
+```powershell
+$instructions = @"
+You are a PowerShell Skills AI Assistant. 
+
+When a user provides a request, analyze it to determine which skills are relevant.
+
+**ONLY USE** Read-PSAISkill to read SKILL.md files. 
+
+You have access to these skills:
+$(Get-PSAISkillFrontmatter -SkillsRoot "./skills" -Compress)
+"@
+
+$tools = @('Invoke-Expression', 'Read-PSAISkill')
+
+$agent = New-Agent -Tools $tools -Instructions $instructions -Name 'PSSkillsAgent'
+
+# Use the agent
+$agent | Get-AgentResponse "How do I read a file in PowerShell?"
+```
+
+### Creating Custom Skills
+
+Each skill is a directory containing a `SKILL.md` file with YAML frontmatter:
+
+```markdown
+---
+name: Your Skill Name
+description: What this skill does and when to use it
+---
+
+# Your Skill Name
+
+## Quick start
+[Step-by-step guidance with code examples]
+
+## Best practices
+[Tips and recommendations]
+```
+
+For more information, see the [Skills README](skills/README.md) and the example script [Use-PSAISkills.ps1](examples/Use-PSAISkills.ps1).
+
+### References
+
+- [Anthropic Claude Skills Documentation](https://docs.claude.com/en/docs/agents-and-tools/agent-skills/overview)
+- [Anthropic Skills GitHub Repository](https://github.com/anthropics/skills)
 
 ## What Are Autonomous Agents?
 
diff --git a/SKILLS_IMPLEMENTATION.md b/SKILLS_IMPLEMENTATION.md
new file mode 100644
index 0000000..78b8251
--- /dev/null
+++ b/SKILLS_IMPLEMENTATION.md
@@ -0,0 +1,220 @@
+# PSAI Skills Implementation Summary
+
+## Overview
+
+This document summarizes the implementation of Anthropic Claude Skills pattern in PSAI, enabling PowerShell-based AI agents to use modular, filesystem-based capabilities with progressive disclosure.
+
+## What Was Implemented
+
+### Core Functions
+
+1. **Get-PSAISkillFrontmatter** (`Public/Get-PSAISkillFrontmatter.ps1`)
+   - Scans a directory for SKILL.md files
+   - Extracts YAML frontmatter (name and description)
+   - Returns skill metadata as JSON or PowerShell objects
+   - Implements Level 1 loading (metadata discovery)
+
+2. **Read-PSAISkill** (`Public/Read-PSAISkill.ps1`)
+   - Reads the complete content of a skill file
+   - Returns file content as raw string
+   - Implements Level 2 loading (on-demand instructions)
+
+### Module Integration
+
+- Added functions to `PSAI.psm1` module loader
+- Exported functions in `PSAI.psd1` manifest
+- Functions follow existing PSAI naming conventions and patterns
+- Integrated seamlessly with existing New-Agent and Get-AgentResponse functions
+
+### Testing
+
+Created comprehensive test suites:
+- `__tests__/Get-PSAISkillFrontmatter.tests.ps1` (6 tests)
+- `__tests__/Read-PSAISkill.tests.ps1` (5 tests)
+- All tests pass (197 total tests in the suite)
+
+### Sample Skills
+
+Created three example skills in `skills/public/`:
+
+1. **read-file** - File reading operations
+2. **write-file** - File writing operations  
+3. **process-management** - Process information and management
+
+Each skill demonstrates:
+- Proper YAML frontmatter structure
+- Clear, actionable instructions
+- Code examples with PowerShell syntax
+- Best practices sections
+
+### Documentation
+
+1. **skills/README.md**
+   - Comprehensive guide to PSAI Skills
+   - Architecture explanation (3-level loading)
+   - Usage examples with code
+   - Skill creation guidelines
+   - Best practices
+
+2. **README.md** (main)
+   - Added PSAI Skills section
+   - Quick start examples
+   - Integration with agents
+   - References to Anthropic documentation
+
+3. **examples/Use-PSAISkills.ps1**
+   - Complete working example
+   - Shows agent creation with skills
+   - Interactive and prompt-based usage
+   - Properly documented with help text
+
+## Anthropic Claude Skills Pattern
+
+The implementation follows the three-level loading architecture:
+
+### Level 1: Metadata (Always Loaded)
+- YAML frontmatter in SKILL.md files
+- Contains `name` and `description` fields
+- Loaded at agent initialization
+- Enables skill discovery without full content
+
+### Level 2: Instructions (Loaded On-Demand)
+- Main body of SKILL.md files
+- Contains workflows, examples, and guidance
+- Loaded when agent determines skill is relevant
+- Uses Read-PSAISkill function
+
+### Level 3: Resources (Loaded As Needed)
+- Additional markdown files
+- Scripts and utilities
+- Reference materials
+- Future enhancement opportunity
+
+## Key Design Decisions
+
+1. **Function Naming**: Used `PSAI` prefix to distinguish from spike implementation
+2. **Parameter Consistency**: Matched existing PSAI parameter patterns
+3. **Error Handling**: Graceful handling of missing directories and files
+4. **Flexibility**: Support for both JSON and PSCustomObject output
+5. **Documentation**: Comprehensive inline help following PowerShell standards
+
+## How It Works
+
+### Discovery Phase
+```powershell
+$skillsMetadata = Get-PSAISkillFrontmatter -SkillsRoot "./skills"
+```
+Agent receives compact metadata about all available skills.
+
+### Loading Phase
+```powershell
+Read-PSAISkill -Fullname $skill.fullname
+```
+Agent loads full instructions only when needed.
+
+### Agent Integration
+```powershell
+$instructions = @"
+You have access to these skills:
+$(Get-PSAISkillFrontmatter -SkillsRoot "./skills" -Compress)
+"@
+
+$agent = New-Agent -Tools @('Read-PSAISkill') -Instructions $instructions
+```
+
+## Benefits
+
+1. **Progressive Disclosure**: Only loads content as needed
+2. **Modular Design**: Easy to add/remove skills
+3. **Reusability**: Skills can be shared across agents
+4. **Discoverability**: Metadata makes skills easily findable
+5. **Maintainability**: Each skill is self-contained
+6. **Extensibility**: Clear pattern for creating new skills
+
+## Usage Example
+
+```powershell
+# Import the module
+Import-Module PSAI
+
+# Create a skills-enabled agent
+$instructions = @"
+You are a PowerShell Skills AI Assistant.
+Use Read-PSAISkill to access skill content when needed.
+Available skills: $(Get-PSAISkillFrontmatter -SkillsRoot "./skills" -Compress)
+"@
+
+$agent = New-Agent `
+    -Tools @('Invoke-Expression', 'Read-PSAISkill') `
+    -Instructions $instructions `
+    -Name 'PSSkillsAgent'
+
+# Ask the agent a question
+$agent | Get-AgentResponse "How do I read a file in PowerShell?"
+```
+
+## Comparison with Spike Implementation
+
+The spike implementation in `spikes/PowerShell-Skills/PSSkills.ps1` was used as reference but this implementation differs in:
+
+1. **Function Names**: `Get-PSAISkillFrontmatter` vs `Get-SkillFrontmatter`
+2. **Integration**: Fully integrated into PSAI module vs standalone script
+3. **Testing**: Comprehensive test coverage added
+4. **Documentation**: Full inline help and documentation
+5. **Examples**: Structured examples with proper commenting
+
+## Files Changed/Added
+
+### New Files
+- `Public/Get-PSAISkillFrontmatter.ps1`
+- `Public/Read-PSAISkill.ps1`
+- `__tests__/Get-PSAISkillFrontmatter.tests.ps1`
+- `__tests__/Read-PSAISkill.tests.ps1`
+- `examples/Use-PSAISkills.ps1`
+- `skills/README.md`
+- `skills/public/read-file/SKILL.md`
+- `skills/public/write-file/SKILL.md`
+- `skills/public/process-management/SKILL.md`
+
+### Modified Files
+- `PSAI.psm1` - Added function imports
+- `PSAI.psd1` - Added function exports
+- `README.md` - Added Skills section
+
+## Testing Results
+
+All tests pass successfully:
+- Total Tests: 197
+- Passed: 197
+- Failed: 0
+- New Tests Added: 11
+
+## References
+
+- [Anthropic Claude Skills Documentation](https://docs.claude.com/en/docs/agents-and-tools/agent-skills/overview)
+- [Anthropic Skills GitHub](https://github.com/anthropics/skills)
+- [PSAI Wiki](https://github.com/dfinke/PSAI/wiki)
+
+## Future Enhancements
+
+Potential areas for future development:
+
+1. **Level 3 Resources**: Support for bundled scripts and resources
+2. **Skill Registry**: Central catalog of available skills
+3. **Skill Templates**: Scaffolding for creating new skills
+4. **Skill Validation**: Automated checking of skill structure
+5. **Remote Skills**: Loading skills from remote repositories
+6. **Skill Dependencies**: Skills that reference other skills
+7. **Skill Categories**: Organizing skills by domain
+
+## Security Considerations
+
+- Read-PSAISkill should only be used to read skill files
+- Agent instructions enforce this constraint
+- No external dependencies added
+- No network access required
+- All code is local and auditable
+
+## Conclusion
+
+The PSAI Skills implementation successfully ports the Anthropic Claude Skills architecture pattern to PowerShell, providing a robust, tested, and well-documented framework for creating modular AI agent capabilities. The implementation maintains consistency with existing PSAI patterns while introducing powerful new functionality for building specialized agents.
diff --git a/__tests__/Get-PSAISkillFrontmatter.tests.ps1 b/__tests__/Get-PSAISkillFrontmatter.tests.ps1
new file mode 100644
index 0000000..90ec645
--- /dev/null
+++ b/__tests__/Get-PSAISkillFrontmatter.tests.ps1
@@ -0,0 +1,104 @@
+Describe "Get-PSAISkillFrontmatter" -Tag Get-PSAISkillFrontmatter {
+    BeforeAll {
+        Import-Module "$PSScriptRoot/../PSAI.psd1" -Force
+        
+        # Create a temporary skills directory for testing
+        $script:testSkillsRoot = Join-Path $TestDrive "test-skills"
+        New-Item -ItemType Directory -Path $script:testSkillsRoot -Force | Out-Null
+        
+        # Create a test skill
+        $skill1Path = Join-Path $script:testSkillsRoot "read-file"
+        New-Item -ItemType Directory -Path $skill1Path -Force | Out-Null
+        
+        $skill1Content = @"
+---
+name: Read File
+description: Read content from a file and return it as text.
+---
+
+# Read File
+
+## Quick start
+
+Use ``Get-Content`` to read text from a file.
+"@
+        
+        Set-Content -Path (Join-Path $skill1Path "SKILL.md") -Value $skill1Content
+        
+        # Create another test skill
+        $skill2Path = Join-Path $script:testSkillsRoot "write-file"
+        New-Item -ItemType Directory -Path $skill2Path -Force | Out-Null
+        
+        $skill2Content = @"
+---
+name: Write File
+description: Write content to a file.
+---
+
+# Write File
+
+## Quick start
+
+Use ``Set-Content`` to write text to a file.
+"@
+        
+        Set-Content -Path (Join-Path $skill2Path "SKILL.md") -Value $skill2Content
+    }
+    
+    It "should have these parameters" {
+        $actual = Get-Command Get-PSAISkillFrontmatter -ErrorAction SilentlyContinue
+     
+        $actual | Should -Not -BeNullOrEmpty
+
+        $keyArray = $actual.Parameters.Keys -as [array]
+
+        $keyArray | Should -Contain 'SkillsRoot'
+        $keyArray | Should -Contain 'AsPSCustomObject'
+        $keyArray | Should -Contain 'Compress'
+        
+        $actual.Parameters.AsPSCustomObject.SwitchParameter | Should -Be $true
+        $actual.Parameters.Compress.SwitchParameter | Should -Be $true
+    }
+    
+    It "should return JSON by default" {
+        $result = Get-PSAISkillFrontmatter -SkillsRoot $script:testSkillsRoot
+        
+        $result | Should -Not -BeNullOrEmpty
+        { $result | ConvertFrom-Json } | Should -Not -Throw
+    }
+    
+    It "should return PSCustomObject when specified" {
+        $result = Get-PSAISkillFrontmatter -SkillsRoot $script:testSkillsRoot -AsPSCustomObject
+        
+        $result | Should -Not -BeNullOrEmpty
+        $result | Should -BeOfType [PSCustomObject]
+        $result.Count | Should -Be 2
+    }
+    
+    It "should extract skill name and description correctly" {
+        $result = Get-PSAISkillFrontmatter -SkillsRoot $script:testSkillsRoot -AsPSCustomObject
+        
+        $readFileSkill = $result | Where-Object { $_.name -eq "Read File" }
+        $readFileSkill | Should -Not -BeNullOrEmpty
+        $readFileSkill.description | Should -Be "Read content from a file and return it as text."
+        $readFileSkill.fullname | Should -Not -BeNullOrEmpty
+        
+        $writeFileSkill = $result | Where-Object { $_.name -eq "Write File" }
+        $writeFileSkill | Should -Not -BeNullOrEmpty
+        $writeFileSkill.description | Should -Be "Write content to a file."
+    }
+    
+    It "should handle non-existent directory gracefully" {
+        $result = Get-PSAISkillFrontmatter -SkillsRoot "C:\NonExistentPath\Skills" -AsPSCustomObject
+        
+        $result | Should -BeNullOrEmpty
+    }
+    
+    It "should return compressed JSON when specified" {
+        $compressed = Get-PSAISkillFrontmatter -SkillsRoot $script:testSkillsRoot -Compress
+        $uncompressed = Get-PSAISkillFrontmatter -SkillsRoot $script:testSkillsRoot
+        
+        $compressed | Should -Not -BeNullOrEmpty
+        $compressed.Length | Should -BeLessThan $uncompressed.Length
+    }
+}
diff --git a/__tests__/Read-PSAISkill.tests.ps1 b/__tests__/Read-PSAISkill.tests.ps1
new file mode 100644
index 0000000..73d274f
--- /dev/null
+++ b/__tests__/Read-PSAISkill.tests.ps1
@@ -0,0 +1,71 @@
+Describe "Read-PSAISkill" -Tag Read-PSAISkill {
+    BeforeAll {
+        Import-Module "$PSScriptRoot/../PSAI.psd1" -Force
+        
+        # Create a temporary skill file for testing
+        $script:testSkillFile = Join-Path $TestDrive "test-skill.md"
+        
+        $testContent = @"
+---
+name: Test Skill
+description: A test skill for unit testing.
+---
+
+# Test Skill
+
+## Quick start
+
+This is a test skill with some example content.
+
+``````powershell
+Get-Content -Path "test.txt"
+``````
+
+## More information
+
+Additional details about using this skill.
+"@
+        
+        Set-Content -Path $script:testSkillFile -Value $testContent
+    }
+    
+    It "should have these parameters" {
+        $actual = Get-Command Read-PSAISkill -ErrorAction SilentlyContinue
+     
+        $actual | Should -Not -BeNullOrEmpty
+
+        $keyArray = $actual.Parameters.Keys -as [array]
+
+        $keyArray | Should -Contain 'Fullname'
+        
+        $actual.Parameters.Fullname.Attributes.Mandatory | Should -Be $true
+    }
+    
+    It "should read file content as raw string" {
+        $result = Read-PSAISkill -Fullname $script:testSkillFile
+        
+        $result | Should -Not -BeNullOrEmpty
+        $result | Should -BeOfType [string]
+        $result | Should -Match "Test Skill"
+        $result | Should -Match "Quick start"
+    }
+    
+    It "should include frontmatter in the output" {
+        $result = Read-PSAISkill -Fullname $script:testSkillFile
+        
+        $result | Should -Match "---"
+        $result | Should -Match "name: Test Skill"
+        $result | Should -Match "description: A test skill for unit testing."
+    }
+    
+    It "should handle non-existent file with error" {
+        { Read-PSAISkill -Fullname "C:\NonExistent\File.md" -ErrorAction Stop } | Should -Throw
+    }
+    
+    It "should read complete file including code blocks" {
+        $result = Read-PSAISkill -Fullname $script:testSkillFile
+        
+        $result | Should -Match "Get-Content -Path"
+        $result | Should -Match "More information"
+    }
+}
diff --git a/examples/Use-PSAISkills.ps1 b/examples/Use-PSAISkills.ps1
new file mode 100644
index 0000000..c611980
--- /dev/null
+++ b/examples/Use-PSAISkills.ps1
@@ -0,0 +1,83 @@
+<#
+.SYNOPSIS
+Example script demonstrating how to use PSAI Skills with an AI agent.
+
+.DESCRIPTION
+This script shows how to create an AI agent that can discover and use PSAI Skills
+to answer questions about PowerShell. It implements the Anthropic Claude Skills
+pattern for progressive disclosure.
+
+.PARAMETER Prompt
+The initial prompt to send to the agent. If not provided, starts an interactive session.
+
+.PARAMETER SkillsRoot
+The root directory containing skills. Defaults to "../skills" relative to this script.
+
+.PARAMETER ShowToolCalls
+Display tool calls made by the agent for debugging.
+
+.EXAMPLE
+PS> .\Use-PSAISkills.ps1 -Prompt "How do I read a file in PowerShell?"
+
+.EXAMPLE
+PS> .\Use-PSAISkills.ps1
+Starts an interactive conversation with the skills agent.
+#>
+param(
+    [string]$Prompt,
+    [string]$SkillsRoot = (Join-Path $PSScriptRoot "../skills"),
+    [switch]$ShowToolCalls
+)
+
+# Ensure PSAI is loaded
+Import-Module PSAI -ErrorAction Stop
+
+# Build instructions for the agent
+$instructions = @"
+You are a PowerShell Skills AI Assistant. 
+
+When a user provides a request, analyze the request to determine which skills are relevant.
+
+**ONLY USE** Read-PSAISkill to read the SKILL.md file. 
+**DO NOT USE** Read-PSAISkill to read any other type of file. 
+
+Use code blocks in the SKILL.md file as examples to form your response. 
+
+Use Invoke-Expression to run PowerShell code found in the SKILL.md file when appropriate.
+
+Do one task at a time, then move on to the next, reading the SKILL.md files as needed.
+
+You have access to the skills:
+**Skills**
+
+$(Get-PSAISkillFrontmatter -SkillsRoot $SkillsRoot -Compress)
+
+"@
+
+# Define tools available to the agent
+$tools = @(
+    'Invoke-Expression'
+    'Read-PSAISkill'
+)
+
+# Create the agent
+$agent = New-Agent `
+    -LLM (New-OpenAIChat) `
+    -Name 'PSSkillsAgent' `
+    -ShowToolCalls:$ShowToolCalls `
+    -Tools $tools `
+    -Instructions $instructions
+
+# Use the agent
+if ($Prompt) {
+    $agent | Get-AgentResponse $Prompt
+}
+else {
+    Write-Host "Starting interactive conversation with PSAI Skills Agent..." -ForegroundColor Cyan
+    Write-Host "Available commands:" -ForegroundColor Yellow
+    Write-Host "  /clear - Clear the screen" -ForegroundColor Yellow
+    Write-Host "  Enter  - Copy last response and quit" -ForegroundColor Yellow
+    Write-Host ""
+    
+    $agent | Start-Conversation
+}
diff --git a/skills/README.md b/skills/README.md
new file mode 100644
index 0000000..49ffc6c
--- /dev/null
+++ b/skills/README.md
@@ -0,0 +1,149 @@
+# PSAI Skills
+
+This directory contains PSAI Skills, which implement the Anthropic Claude Skills pattern for PowerShell. Skills are modular capabilities that extend AI agent functionality with domain-specific expertise.
+
+## What are Skills?
+
+Skills are reusable, filesystem-based resources that provide AI agents with:
+- Domain-specific workflows and best practices
+- On-demand loading (progressive disclosure)
+- Structured guidance through YAML frontmatter and markdown content
+
+## Skills Architecture
+
+The PSAI Skills implementation follows a three-level loading pattern:
+
+### Level 1: Metadata (always loaded)
+The YAML frontmatter in `SKILL.md` files provides discovery information:
+```yaml
+---
+name: Skill Name
+description: What this skill does and when to use it
+---
+```
+
+### Level 2: Instructions (loaded on-demand)
+The main body of `SKILL.md` contains procedural knowledge:
+- Workflows and step-by-step guidance
+- Code examples and best practices
+- Usage patterns and tips
+
+### Level 3: Resources (loaded as needed)
+Additional files can be included:
+- Related markdown files for specialized guidance
+- Scripts and utilities
+- Reference materials and examples
+
+## Using Skills with PSAI
+
+### Discovering Skills
+
+Use `Get-PSAISkillFrontmatter` to scan for available skills:
+
+```powershell
+# Get all skills as JSON
+Get-PSAISkillFrontmatter -SkillsRoot "./skills"
+
+# Get skills as PowerShell objects
+Get-PSAISkillFrontmatter -SkillsRoot "./skills" -AsPSCustomObject
+```
+
+### Reading Skill Content
+
+Use `Read-PSAISkill` to load full skill instructions:
+
+```powershell
+$skills = Get-PSAISkillFrontmatter -SkillsRoot "./skills" -AsPSCustomObject
+$readSkill = $skills | Where-Object { $_.name -eq "Read File" }
+Read-PSAISkill -Fullname $readSkill.fullname
+```
+
+### Creating an Agent with Skills
+
+Integrate skills into an AI agent:
+
+```powershell
+$instructions = @"
+You are a PowerShell Skills AI Assistant. 
+
+When a user provides a request, analyze it to determine which skills are relevant.
+
+**ONLY USE** Read-PSAISkill to read SKILL.md files. 
+**DO NOT USE** Read-PSAISkill to read any other type of file. 
+
+Use code blocks in the SKILL.md file as examples to form your response. 
+
+You have access to these skills:
+$(Get-PSAISkillFrontmatter -SkillsRoot "./skills" -Compress)
+"@
+
+$tools = @(
+    'Invoke-Expression'
+    'Read-PSAISkill'
+)
+
+$agent = New-Agent -Tools $tools -Instructions $instructions -Name 'PSSkillsAgent'
+
+# Use the agent
+$agent | Get-AgentResponse "How do I read a file in PowerShell?"
+```
+
+## Skill Structure
+
+Each skill should be organized as a directory containing at minimum a `SKILL.md` file:
+
+```
+skills/
+├── public/
+│   ├── read-file/
+│   │   └── SKILL.md
+│   ├── write-file/
+│   │   └── SKILL.md
+│   └── process-management/
+│       └── SKILL.md
+└── README.md
+```
+
+### SKILL.md Format
+
+Every skill requires YAML frontmatter with these fields:
+
+```markdown
+---
+name: Your Skill Name (max 64 characters)
+description: Brief description of what this skill does and when to use it (max 1024 characters)
+---
+
+# Your Skill Name
+
+## Quick start
+[Step-by-step guidance]
+
+## Examples
+[Concrete examples with code blocks]
+
+## Best practices
+[Tips and recommendations]
+```
+
+## Creating Custom Skills
+
+1. Create a new directory under `skills/public/` (or your custom location)
+2. Create a `SKILL.md` file with proper frontmatter
+3. Write clear, actionable instructions with code examples
+4. Test with `Get-PSAISkillFrontmatter` and `Read-PSAISkill`
+5. Integrate into your agent's instructions
+
+## Best Practices
+
+- **Clear descriptions**: Make skill descriptions specific about when to use them
+- **Actionable content**: Provide step-by-step guidance and working examples
+- **Code examples**: Include PowerShell code blocks that can be used directly
+- **Scoped skills**: Keep each skill focused on a specific capability
+- **Consistent structure**: Follow the Quick start → Examples → Best practices pattern
+
+## References
+
+- Anthropic Claude Skills documentation: https://docs.claude.com/en/docs/agents-and-tools/agent-skills/overview
+- GitHub repository: https://github.com/anthropics/skills
+- PSAI documentation: https://github.com/dfinke/PSAI/wiki
diff --git a/skills/public/process-management/SKILL.md b/skills/public/process-management/SKILL.md
new file mode 100644
index 0000000..e5a11ec
--- /dev/null
+++ b/skills/public/process-management/SKILL.md
@@ -0,0 +1,48 @@
+---
+name: Process Management
+description: Retrieve and manage information about running processes. Use when working with system processes or monitoring applications.
+---
+
+# Process Management
+
+## Quick start 
+
+Use `Get-Process` to retrieve information about running processes:
+
+```powershell
+Get-Process
+```
+
+## Getting specific processes
+
+Filter by process name:
+
+```powershell
+Get-Process -Name "pwsh"
+Get-Process | Where-Object { $_.CPU -gt 100 }
+```
+
+## Process details
+
+Get detailed information about a process:
+
+```powershell
+Get-Process -Name "pwsh" | Select-Object Id, ProcessName, CPU, WorkingSet, StartTime
+```
+
+## Stopping processes
+
+To stop a process (use with caution):
+
+```powershell
+Stop-Process -Name "notepad" -Force
+Stop-Process -Id 1234
+```
+
+## Best practices
+
+- Always verify process name before stopping processes
+- Use `-WhatIf` parameter to preview actions
+- Check process ownership and permissions
+- Be cautious with system processes
+- Use `Get-Process` first to identify correct process before stopping
diff --git a/skills/public/read-file/SKILL.md b/skills/public/read-file/SKILL.md
new file mode 100644
index 0000000..a14fa6b
--- /dev/null
+++ b/skills/public/read-file/SKILL.md
@@ -0,0 +1,37 @@
+---
+name: Read File
+description: Read content from a file and return it as text. Use when working with text files or when the user needs to view file contents.
+---
+
+# Read File 
+
+## Quick start 
+
+Use `Get-Content` to read text from a file:
+
+```powershell
+Get-Content -Path "input.txt"
+```
+
+## Reading specific lines
+
+To read a specific range of lines:
+
+```powershell
+Get-Content -Path "input.txt" -TotalCount 10  # First 10 lines
+Get-Content -Path "input.txt" -Tail 5         # Last 5 lines
+```
+
+## Reading as raw string
+
+To read the entire file as a single string:
+
+```powershell
+Get-Content -Path "input.txt" -Raw
+```
+
+## Best practices
+
+- Always check if the file exists before reading: `Test-Path -Path $filePath`
+- Handle large files carefully to avoid memory issues
+- Use `-ErrorAction` parameter for proper error handling
diff --git a/skills/public/write-file/SKILL.md b/skills/public/write-file/SKILL.md
new file mode 100644
index 0000000..f1186bf
--- /dev/null
+++ b/skills/public/write-file/SKILL.md
@@ -0,0 +1,46 @@
+---
+name: Write File
+description: Write content to a file. Use when creating new files or updating existing file contents.
+---
+
+# Write File 
+
+## Quick start 
+
+Use `Set-Content` to write text to a file:
+
+```powershell
+Set-Content -Path "output.txt" -Value "Hello, World!"
+```
+
+## Appending to a file
+
+To add content without overwriting:
+
+```powershell
+Add-Content -Path "output.txt" -Value "New line"
+```
+
+## Writing arrays
+
+When writing arrays, each element becomes a line:
+
+```powershell
+$lines = @("Line 1", "Line 2", "Line 3")
+Set-Content -Path "output.txt" -Value $lines
+```
+
+## Writing with encoding
+
+Specify encoding for special characters:
+
+```powershell
+Set-Content -Path "output.txt" -Value "Content" -Encoding UTF8
+```
+
+## Best practices
+
+- Use `Set-Content` to overwrite existing files
+- Use `Add-Content` to append to files
+- Always specify `-Path` explicitly for clarity
+- Consider using `-Force` to create parent directories if needed