Analyzes a .NET 8 codebase and produces analysis findings for upgrading to .NET 10. Uses pm7y-ralph-planner to generate TASKS.md with validation requirements and learnings tracking for autonomous execution. Use when planning a .NET 10 upgrade.
Analyzes .NET 8 codebases and generates upgrade plans for .NET 10 migration.
/plugin marketplace add pm7y/pm7y-marketplace/plugin install pm7y-pm7y-claude-code@pm7y/pm7y-marketplaceThis skill is limited to using the following tools:
Analyzes your codebase and produces findings for upgrading from .NET 8 to .NET 10. Passes findings to pm7y-ralph-planner for TASKS.md generation.
This skill performs codebase analysis and passes findings to pm7y-ralph-planner, which generates a TASKS.md file with validation requirements and learnings tracking for autonomous execution via pm7y-ralph-loop.
You do NOT perform the upgrade. You create the plan.
Workflow:
/pm7y-dotnet-upgrade to analyze the codebasepm7y-ralph-planner to generate TASKS.mdTASKS.md as neededpwsh ./ralph-loop.ps1 to execute the upgradeBefore generating tasks, analyze the codebase to discover:
Find and document:
.sln and .csproj filesDirectory.Build.props (centralized build properties)Directory.Packages.props (central package management)global.json (SDK version pinning)Determine:
Locate:
.github/workflows/*.yml, azure-pipelines.yml, etc.)Categorize all packages from .csproj files and/or Directory.Packages.props:
Search for:
Use these to gather information:
# Find all solution and project files
find . -name "*.sln" -o -name "*.csproj" 2>/dev/null
# Check current target frameworks
grep -r "TargetFramework" --include="*.csproj" --include="Directory.Build.props" .
# Find Dockerfiles
find . -name "Dockerfile*" 2>/dev/null
# Find CI/CD files
find . \( -path "*/.github/workflows/*.yml" -o -name "azure-pipelines.yml" \) 2>/dev/null
# Check for global.json
cat global.json 2>/dev/null || echo "No global.json found"
# Check for Directory.Build.props
cat Directory.Build.props 2>/dev/null || echo "No Directory.Build.props found"
# Check for Directory.Packages.props
cat Directory.Packages.props 2>/dev/null || echo "No Directory.Packages.props found"
# List all NuGet packages
grep -rh "PackageReference\|PackageVersion" --include="*.csproj" --include="Directory.Packages.props" . 2>/dev/null | sort -u
After completing the analysis, invoke the pm7y-ralph-planner agent using the Task tool. Pass your findings as structured input so the planner can generate a proper TASKS.md with validation requirements and learnings tracking.
CRITICAL: Each finding must be:
(verify: ...) where build/test verification is neededInvoke pm7y-ralph-planner with this prompt:
Generate a TASKS.md for .NET 10 upgrade.
## Goal
Upgrade codebase from .NET {CURRENT_VERSION} to .NET 10.
## Project Context
- **Source Framework:** .NET {CURRENT_VERSION}
- **Target Framework:** .NET 10
- **Build command:** dotnet build
- **Test command:** dotnet test
- **Solution files:** [list of .sln files]
- **Project files:** [list of .csproj files]
## Findings
### Critical [P0] - Framework Version Changes
These tasks update the target framework. Must complete before any package updates.
- Update global.json to pin .NET 10 SDK version 10.0.100 with rollForward: latestFeature (verify: dotnet --version)
- Update TargetFramework from net8.0 to net10.0 in {FILE_PATH} (verify: dotnet build)
[REPEAT FOR EACH CSPROJ OR DIRECTORY.BUILD.PROPS]
### Critical [P0] - Infrastructure Updates
- Update Dockerfile at {PATH} to use mcr.microsoft.com/dotnet/sdk:10.0 and runtime:10.0 base images (verify: docker build .)
[REPEAT FOR EACH DOCKERFILE]
- Update GitHub Actions workflow at {PATH} to use dotnet-version: '10.0.x' (verify: cat {PATH} | grep dotnet)
[REPEAT FOR EACH CI/CD FILE]
### High [P1] - Build Verification
- Run full solution build and fix any compilation errors caused by framework upgrade (verify: dotnet build)
- Run all tests and fix any failures caused by framework upgrade (verify: dotnet test)
### High [P1] - Microsoft Package Updates
Update Microsoft packages first as other packages may depend on them.
- Update {PACKAGE_NAME} from {CURRENT_VERSION} to latest .NET 10 compatible version in {FILE_PATH} (verify: dotnet build)
[REPEAT FOR EACH MICROSOFT.EXTENSIONS.* PACKAGE]
### High [P1] - Azure SDK Updates
- Update {PACKAGE_NAME} from {CURRENT_VERSION} to latest version in {FILE_PATH} (verify: dotnet build)
[REPEAT FOR EACH AZURE.* PACKAGE]
### Medium [P2] - Testing Package Updates
- Update {PACKAGE_NAME} from {CURRENT_VERSION} to latest version in {FILE_PATH} (verify: dotnet test)
[REPEAT FOR EACH TESTING PACKAGE]
### Medium [P2] - Third-Party Package Updates
- Update {PACKAGE_NAME} from {CURRENT_VERSION} to latest .NET 10 compatible version in {FILE_PATH} (verify: dotnet build)
[REPEAT FOR EACH THIRD-PARTY PACKAGE]
### Medium [P2] - Breaking Change Fixes
[ONLY INCLUDE IF BREAKING CHANGES DETECTED]
- Update usage of {DEPRECATED_API} to {NEW_API} in {FILE_PATH}:{LINE_RANGE} (verify: dotnet build)
### Low [P3] - Centralized Build Configuration
[INCLUDE APPROPRIATE TASKS BASED ON CURRENT STATE]
If Directory.Build.props does NOT exist:
- Create Directory.Build.props with centralized TargetFramework, LangVersion, Nullable, and analyzer settings
- Remove TargetFramework property from {CSPROJ_PATH} (now centralized) (verify: dotnet build)
If Directory.Packages.props does NOT exist:
- Create Directory.Packages.props with ManagePackageVersionsCentrally enabled and all current package versions
- Remove Version attribute from PackageReference elements in {CSPROJ_PATH} (verify: dotnet restore)
If global.json does NOT exist:
- Create global.json to pin SDK version to 10.0.100 with rollForward: latestFeature
### Low [P3] - Documentation
- Create UPGRADE_NET10.md documenting all changes made during this upgrade
### Low [P3] - Final Verification
- Run full build to confirm upgrade is complete (verify: dotnet build --no-incremental)
- Run all tests to confirm everything passes (verify: dotnet test)
- Verify no warnings are treated as errors or resolve any that are (verify: dotnet build -warnaserror)
Why use pm7y-ralph-planner:
The planner will:
(verify: dotnet build) or (verify: dotnet test)After invoking pm7y-ralph-planner:
pwsh ./ralph-loop.ps1 to execute the upgrade (set up scripts with /pm7y-ralph-loop if needed)"This skill should be used when the user asks to "create a hookify rule", "write a hook rule", "configure hookify", "add a hookify rule", or needs guidance on hookify rule syntax and patterns.
Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.