principle-outcome-oriented-execution

Guides planned rewrites and migrations toward target architecture with explicit verification boundaries.

2|Updated Jun 27, 2026
One-click install
npx skills add https://github.com/imjasonh/playground --skill principle-outcome-oriented-execution-imjasonh
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: principle-outcome-oriented-execution
Source: https://github.com/imjasonh/playground/tree/main/.cursor/skills/principle-outcome-oriented-execution
Command: npx skills add https://github.com/imjasonh/playground --skill principle-outcome-oriented-execution-imjasonh

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Planned rewrites and migrations often accumulate throwaway compatibility code because teams try to keep every intermediate state fully stable, turning temporary scaffolding into long-lived technical debt. ## Core Features & Use Cases - End-State Prioritization: Converges work on the intended, verifiable target architecture instead of preserving smooth intermediate states. - Scoped Breakage Policy: Accepts intermediate breakage only when it is planned, scoped, and reversible, with declared boundaries. - Verification Gates: Requires full static and runtime verification at plan completion before declaring the work done. - Use Case: During a multi-phase migration from a legacy module to a new service layer, apply this principle to skip building temporary adapter shims and instead verify correctness at each explicit phase boundary. ## Quick Start Apply the outcome-oriented execution principle to plan my migration from the legacy auth module to the new identity service with explicit phase boundaries.

Frequently Asked Questions about principle-outcome-oriented-execution

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

FAQPage Schema
How do I plan a code migration without building temporary compatibility code?▼

Converge directly on the target architecture and verify correctness at explicit phase boundaries instead of keeping every intermediate state stable. Declare where temporary breakage is acceptable and ensure it stays scoped and reversible.

When is intermediate breakage acceptable during a rewrite?▼

Intermediate breakage is acceptable when it is planned, scoped, and reversible within a migration that has explicit phase boundaries. It should never be used as an excuse to skip final verification of the end state.

When should I not use outcome-oriented execution?▼

Avoid this approach for unplanned changes, hotfixes on live systems, or work without explicit phase boundaries. It is designed for deliberate rewrites and migrations where verification gates can be defined in advance.

How do I verify a migration is complete?▼

Run full static and runtime verification at plan completion before declaring done. Keep high-signal checks active for actively touched areas throughout the migration to catch regressions early.

Why does compatibility code become technical debt?▼

Temporary shims built to keep intermediate states stable often survive past the migration because removing them feels risky. Prioritizing end-state integrity avoids creating this throwaway code in the first place.