principle-outcome-oriented-execution

Guides planned rewrites and migrations toward verified end-state architecture over transitional stability.

Updated Sep 2, 2026
One-click install
npx skills add https://github.com/jnyross/pstack-muse --skill principle-outcome-oriented-execution-jnyross
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: principle-outcome-oriented-execution
Source: https://github.com/jnyross/pstack-muse/tree/main/skills/principle-outcome-oriented-execution
Command: npx skills add https://github.com/jnyross/pstack-muse --skill principle-outcome-oriented-execution-jnyross

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 target architecture instead of preserving smooth intermediate states. - Scoped Breakage Policy: Declares where planned, reversible intermediate breakage is acceptable during phased migrations. - Verification Boundaries: Requires full static and runtime verification at explicit phase boundaries before declaring completion. - Use Case: During a multi-phase migration from a legacy module to a new service architecture, apply this principle to skip building temporary adapter layers and instead verify correctness at each 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 avoid compatibility code debt during a migration?

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

When should I use outcome-oriented execution in a rewrite?

Use it for planned rewrites and migrations with explicit phase boundaries. It is not suited for incremental changes to live systems where continuous stability is required, since it permits planned intermediate breakage.

Is intermediate breakage acceptable during a phased migration?

Yes, when the breakage is planned, scoped, and reversible. The principle requires declaring acceptable breakage zones upfront and maintaining high-signal checks on actively touched areas while migrating.

What verification is required before declaring a migration done?

Full static and runtime verification at plan completion is required. Each phase boundary acts as an explicit verification checkpoint, and no work is declared done until final verification passes.

When should I not use outcome-oriented execution?

Avoid it for unplanned or exploratory changes, hotfixes on production systems, or work without clear phase boundaries. It is designed for deliberate rewrites where the target end state is known and verifiable.