principle-outcome-oriented-execution

Guides planned rewrites and migrations toward verified end-state architectures.

1|Updated Aug 26, 2026
One-click install
npx skills add https://github.com/edivad1999/stuc-stack --skill principle-outcome-oriented-execution-edivad1999
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: principle-outcome-oriented-execution
Source: https://github.com/edivad1999/stuc-stack/tree/main/skills/principle-outcome-oriented-execution
Command: npx skills add https://github.com/edivad1999/stuc-stack --skill principle-outcome-oriented-execution-edivad1999

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 target architecture instead of preserving smooth transitional states. - Scoped Breakage Guardrails: Declares where temporary, planned, and reversible 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 of an Android app to a new architecture, apply this principle to accept planned intermediate breakage between phases while enforcing full verification at the end of the plan. ## Quick Start Apply the outcome-oriented execution principle to my planned migration so we converge on the target architecture with verification at each phase boundary.

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 manage a large code migration without breaking everything?▼

Define explicit phase boundaries and converge on the target architecture rather than keeping every intermediate state stable. Accept planned, scoped, reversible breakage between phases, and run full static and runtime verification at plan completion.

When should I avoid keeping backward compatibility during a rewrite?▼

Avoid throwaway compatibility code during planned rewrites with explicit phase boundaries, since temporary shims often become long-lived debt. Prioritize end-state integrity and prove correctness at verification boundaries instead.

Is intermediate breakage acceptable during a phased migration?▼

Yes, intermediate breakage is acceptable when it is planned, scoped, and reversible. Declare where temporary breakage is allowed and keep high-signal checks running for actively touched areas while migrating.

When not to use outcome-oriented execution?▼

Do not use it for unplanned changes or work without explicit phase boundaries. It is designed for deliberate rewrites and migrations where verification boundaries can be defined and enforced.

What verification is required before declaring a migration done?▼

Full static and runtime verification must pass at plan completion before declaring done. Final verification proves the target architecture is correct, not just that intermediate steps were stable.