phase7

Apply Phase 7 Concurrency Hardening by analyzing files and refactoring code to be lock-free.

Updated Jun 3, 2026
One-click install
npx skills add https://github.com/antigravityos187-sketch/universal-or-strategy --skill phase7
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: phase7
Source: https://github.com/antigravityos187-sketch/universal-or-strategy/tree/main/.bob/skills/phase7
Command: npx skills add https://github.com/antigravityos187-sketch/universal-or-strategy --skill phase7

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill automates the process of executing Phase 7 Concurrency Hardening on target files, streamlining the analysis and implementation of lock-free code patterns.

Core Features & Use Cases

  • Automated Analysis: Run a suite of analysis tools to identify bottlenecks and potential issues in target files.
  • Lock-Free Implementation Plan: Generate a detailed plan for refactoring code to be lock-free, with a structured format for bottlenecks and proposed changes.
  • Surgical Execution: Apply the approved plan with precise surgical edits to the target file, ensuring syntactic validity and adherence to lock-free constructs.
  • Post-Edit Audit: Perform a comprehensive audit to ensure no regressions in functionality or adherence to lock-free principles.
  • Handoff to Director: Once all audits pass, the skill is ready for the final step of handoff to the director for the final approval and compilation.

Quick Start

Use the phase7 skill to apply Phase 7 Concurrency Hardening to the target file 'target-code.cs'.

Frequently Asked Questions about phase7

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I automate lock-free refactoring for .NET 4.8 code?

Automate lock-free refactoring by running analysis tools to identify bottlenecks, generate an implementation plan, and apply surgical edits to target files. This process requires prior knowledge of .NET 4.8 primitives and lock-free patterns to execute correctly.

What is concurrency hardening and when do I need it?

Concurrency hardening is the process of refactoring code to be lock-free, eliminating bottlenecks and potential concurrency issues. You need it when target files require improved thread safety and performance without relying on traditional locking mechanisms.

How do I apply surgical edits to refactor code to be lock-free?

Apply surgical edits by first generating a detailed implementation plan for identified bottlenecks. Once changes are approved, precise edits refactor the target file to ensure syntactic validity and strict adherence to lock-free constructs.

Do I need to know .NET 4.8 primitives to use lock-free patterns?

Yes, you need knowledge of .NET 4.8 primitives and lock-free patterns to use this Skill effectively. The automation process relies on understanding these underlying concepts to correctly generate plans and apply concurrency hardening edits.

How does post-edit auditing work for lock-free code?

Post-edit auditing performs a comprehensive check to ensure no functional regressions occurred and that the code strictly adheres to lock-free principles. Once all audits pass, the code is ready for final handoff to the director for approval and compilation.