Add internal dev prompts and update style guide

Adds new internal documentation for pipeline output, SMO vs T-SQL usage, and SQL Server version support in .github/prompts. Updates style.md with test management guidelines and checklist. Refactors CLAUDE.md to reference new prompt files and streamline guidance on SQL version support, SMO vs T-SQL, and pipeline output.

Author: potatoqualitee

.github/prompts/pipeline-output.md

@@ -0,0 +1,126 @@
+# Pipeline Output Patterns
+
+**CRITICAL RULE**: NEVER collect objects in an ArrayList or array and output them at the end. Output objects to the pipeline immediately as they are created.
+
+## Why Immediate Output
+
+- **Memory Efficiency**: Objects are released to the pipeline immediately, not held in memory
+- **User Experience**: Users see results streaming in real-time, not waiting until the end
+- **Pipeline Compatibility**: Enables proper pipeline chaining and early termination (Ctrl+C)
+- **Error Resilience**: Partial results are available even if the command fails partway through
+
+## Correct Pattern - Output Immediately
+
+```powershell
+foreach ($instance in $SqlInstance) {
+    $server = Connect-DbaInstance -SqlInstance $instance -SqlCredential $SqlCredential
+
+    foreach ($db in $server.Databases) {
+        # Output each object immediately to the pipeline
+        [PSCustomObject]@{
+            ComputerName = $server.ComputerName
+            InstanceName = $server.ServiceName
+            SqlInstance  = $server.DomainInstanceName
+            Database     = $db.Name
+            Size         = $db.Size
+        }
+    }
+}
+```
+
+## Wrong Patterns - DO NOT USE
+
+### ArrayList Collection (OLD PATTERN)
+
+```powershell
+# WRONG - This is an outdated anti-pattern
+$results = New-Object System.Collections.ArrayList
+
+foreach ($instance in $SqlInstance) {
+    $server = Connect-DbaInstance -SqlInstance $instance -SqlCredential $SqlCredential
+
+    foreach ($db in $server.Databases) {
+        $null = $results.Add([PSCustomObject]@{
+            ComputerName = $server.ComputerName
+            Database     = $db.Name
+        })
+    }
+}
+
+# WRONG - Holding everything until the end
+$results
+```
+
+### Array Concatenation (Worst Performance)
+
+```powershell
+# WRONG - Array concatenation is extremely slow
+$results = @()
+
+foreach ($db in $databases) {
+    $results += [PSCustomObject]@{
+        Name = $db.Name
+    }
+}
+
+$results
+```
+
+## No -Detailed or -Simple Parameters
+
+Do NOT create `-Detailed` or `-Simple` switch parameters that change the output object structure. This is an outdated pattern that creates confusion and breaks pipeline expectations.
+
+```powershell
+# WRONG - Do not create output mode switches
+param(
+    [switch]$Detailed,
+    [switch]$Simple
+)
+
+if ($Detailed) {
+    # Return more properties
+} elseif ($Simple) {
+    # Return fewer properties
+}
+```
+
+Instead, return a consistent object with all relevant properties. Users can select the properties they want with `Select-Object`.
+
+## Process Block Pattern
+
+When using `ValueFromPipeline`, output in the `process` block, not `end`:
+
+```powershell
+function Get-DbaExample {
+    [CmdletBinding()]
+    param (
+        [Parameter(ValueFromPipeline)]
+        [DbaInstanceParameter[]]$SqlInstance,
+        [PSCredential]$SqlCredential
+    )
+
+    process {
+        foreach ($instance in $SqlInstance) {
+            $server = Connect-DbaInstance -SqlInstance $instance -SqlCredential $SqlCredential
+
+            foreach ($item in $server.SomeCollection) {
+                # Output immediately in process block
+                [PSCustomObject]@{
+                    ComputerName = $server.ComputerName
+                    InstanceName = $server.ServiceName
+                    SqlInstance  = $server.DomainInstanceName
+                    Name         = $item.Name
+                }
+            }
+        }
+    }
+}
+```
+
+## Summary
+
+- Output objects immediately as they are created
+- Never use ArrayList, Generic.List, or array += to collect results
+- Never use `-Detailed`/`-Simple` output mode switches
+- Process pipeline input in the `process` block, not `end`
+- Let PowerShell's pipeline handle the collection if the user needs it

.github/prompts/smo-vs-tsql.md

@@ -0,0 +1,246 @@
+# SMO vs T-SQL Usage Guide
+
+**GUIDING PRINCIPLE**: Default to using SMO (SQL Server Management Objects) first. Only use T-SQL when SMO doesn't provide the functionality or when T-SQL offers better performance or user experience.
+
+## Why SMO First
+
+- **Abstraction**: SMO provides object-oriented interface that handles version differences automatically
+- **Type Safety**: Strong typing reduces errors compared to dynamic T-SQL strings
+- **Built-in Methods**: Common operations (Create, Drop, Alter, Script) are provided out-of-the-box
+- **Consistency**: SMO ensures consistent behavior across SQL Server versions
+- **Less Code**: Often requires fewer lines than equivalent T-SQL
+
+## When to Use SMO
+
+### 1. Object Manipulation
+Creating, dropping, altering database objects:
+
+```powershell
+# PREFERRED - SMO for object manipulation
+$newdb = New-Object Microsoft.SqlServer.Management.Smo.Database($server, $dbName)
+$newdb.Collation = $Collation
+$newdb.RecoveryModel = $RecoveryModel
+$newdb.Create()
+
+# Dropping objects
+$destServer.Roles[$roleName].Drop()
+$destServer.Roles.Refresh()
+```
+
+### 2. Object Scripting
+Generating T-SQL from existing objects:
+
+```powershell
+# PREFERRED - SMO scripting with execution via Query
+$sql = $currentRole.Script() | Out-String
+Write-Message -Level Debug -Message $sql
+$destServer.Query($sql)
+
+# Another example
+$destServer.Query($currentEndpoint.Script()) | Out-Null
+```
+
+### 3. Object Enumeration
+Accessing collections and properties:
+
+```powershell
+# PREFERRED - SMO for object access
+$databases = $server.Databases
+$database = $server.Databases[$dbName]
+$isSystemDb = $database.IsSystemObject
+$members = $currentRole.EnumMemberNames()
+```
+
+### 4. Object Properties
+Reading and setting object attributes:
+
+```powershell
+# PREFERRED - SMO for property access
+$recoveryModel = $db.RecoveryModel
+$owner = $db.Owner
+$lastBackup = $db.LastBackupDate
+$size = $db.Size
+```
+
+## When T-SQL is Appropriate
+
+### 1. System Views and DMVs
+When SMO doesn't expose the data efficiently:
+
+```powershell
+# T-SQL for system catalog queries
+$sql = @"
+SELECT
+    p.name AS ProcedureName,
+    SCHEMA_NAME(p.schema_id) AS SchemaName,
+    p.object_id,
+    m.definition AS DllPath
+FROM sys.procedures p
+INNER JOIN sys.all_objects o ON p.object_id = o.object_id
+LEFT JOIN sys.sql_modules m ON p.object_id = m.object_id
+WHERE p.type = 'X'
+    AND p.is_ms_shipped = 0
+ORDER BY p.name
+"@
+$sourceXPs = $sourceServer.Query($sql)
+```
+
+### 2. Performance-Critical Queries
+When retrieving large result sets:
+
+```powershell
+# T-SQL for efficient data retrieval
+$querylastused = "SELECT dbname, max(last_read) last_read FROM sys.dm_db_index_usage_stats GROUP BY dbname"
+$dblastused = $server.Query($querylastused)
+```
+
+### 3. Version-Specific Logic
+Different queries for different SQL Server versions:
+
+```powershell
+# T-SQL when version-specific system tables/views are needed
+if ($server.VersionMajor -eq 8) {
+    # SQL Server 2000 uses system tables
+    $backed_info = $server.Query("SELECT name, SUSER_SNAME(sid) AS [Owner] FROM master.dbo.sysdatabases")
+} else {
+    # SQL Server 2005+ uses catalog views
+    $backed_info = $server.Query("SELECT name, SUSER_SNAME(owner_sid) AS [Owner] FROM sys.databases")
+}
+```
+
+### 4. System Stored Procedures
+When the operation requires a specific system proc:
+
+```powershell
+# T-SQL for system procedures that have no SMO equivalent
+$dropSql = "EXEC sp_dropextendedproc @functname = N'$xpFullName'"
+$null = $destServer.Query($dropSql)
+
+$createSql = "EXEC sp_addextendedproc @functname = N'$xpFullName', @dllname = N'$destDllPath'"
+$null = $destServer.Query($createSql)
+```
+
+### 5. User-Friendly Features
+When T-SQL makes the command more intuitive:
+
+```powershell
+# Sometimes T-SQL provides better UX than SMO
+# Example: Parameterized queries for filtering
+$splatQuery = @{
+    SqlInstance  = $instance
+    Query        = "SELECT * FROM users WHERE Givenname = @name"
+    SqlParameter = @{ Name = "Maria" }
+}
+$result = Invoke-DbaQuery @splatQuery
+```
+
+## Hybrid Pattern (Most Common)
+
+Most dbatools commands use both SMO and T-SQL strategically:
+
+```powershell
+# Get SMO server object
+$sourceServer = Connect-DbaInstance -SqlInstance $Source -SqlCredential $SourceSqlCredential
+
+# Use SMO for object enumeration
+$sourceRoles = $sourceServer.Roles | Where-Object IsFixedRole -eq $false
+
+# Use T-SQL for complex permission queries
+$splatPermissions = @{
+    SqlInstance        = $sourceServer
+    IncludeServerLevel = $true
+}
+$sourcePermissions = Get-DbaPermission @splatPermissions | Where-Object Grantee -eq $roleName
+
+# Use SMO for object manipulation
+foreach ($currentRole in $sourceRoles) {
+    # Script the object using SMO
+    $sql = $currentRole.Script() | Out-String
+
+    # Execute via T-SQL
+    $destServer.Query($sql)
+
+    # Use SMO methods for membership
+    $members = $currentRole.EnumMemberNames()
+    foreach ($member in $members) {
+        $destServer.Roles[$roleName].AddMember($member)
+    }
+}
+```
+
+## Decision Tree
+
+1. **Does SMO expose the functionality cleanly?**
+   - YES → Use SMO
+   - NO → Continue to #2
+
+2. **Is this a data retrieval operation from system views/DMVs?**
+   - YES → Use T-SQL via `$server.Query()`
+   - NO → Continue to #3
+
+3. **Does the operation require a system stored procedure?**
+   - YES → Use T-SQL via `$server.Query()`
+   - NO → Continue to #4
+
+4. **Would T-SQL significantly improve user experience?**
+   - YES → Use T-SQL (document why in comments)
+   - NO → Use SMO
+
+## Common Patterns
+
+```powershell
+# Pattern 1: SMO object with T-SQL execution of Script()
+$sql = $smoObject.Script() | Out-String
+$destServer.Query($sql)
+
+# Pattern 2: T-SQL for discovery, SMO for manipulation
+$objects = $server.Query("SELECT name FROM sys.objects WHERE type = 'U'")
+foreach ($obj in $objects) {
+    $table = $server.Databases[$dbName].Tables[$obj.name]
+    $table.Drop()  # SMO method
+}
+
+# Pattern 3: SMO with T-SQL fallback
+try {
+    $database = $server.Databases[$dbName]  # SMO
+} catch {
+    # Fallback to T-SQL if SMO fails
+    $result = $server.Query("SELECT name FROM sys.databases WHERE name = '$dbName'")
+}
+```
+
+## Anti-Patterns to Avoid
+
+```powershell
+# WRONG - Using T-SQL when SMO provides the functionality
+$result = $server.Query("ALTER DATABASE [$dbName] SET RECOVERY FULL")
+
+# CORRECT - Use SMO
+$db = $server.Databases[$dbName]
+$db.RecoveryModel = "Full"
+$db.Alter()
+
+# WRONG - Using T-SQL for object enumeration
+$databases = $server.Query("SELECT name FROM sys.databases")
+
+# CORRECT - Use SMO
+$databases = $server.Databases
+
+# WRONG - Concatenating T-SQL strings without parameters (SQL injection risk)
+$result = $server.Query("SELECT * FROM users WHERE name = '$userName'")
+
+# CORRECT - Use parameterized queries
+$splatQuery = @{
+    Query        = "SELECT * FROM users WHERE name = @userName"
+    SqlParameter = @{ userName = $userName }
+}
+$result = Invoke-DbaQuery @splatQuery -SqlInstance $server
+```
+
+## Summary
+
+- **Default to SMO** for object-oriented operations (Create, Drop, Alter, Script, property access)
+- **Use T-SQL** for system views, DMVs, complex queries, system stored procedures, and version-specific logic
+- **Combine both** in a hybrid approach when it provides the best balance of functionality and usability
+- **Always prefer parameterized queries** when using T-SQL with dynamic values
+- **Document your choice** when T-SQL is used instead of SMO for non-obvious reasons