principle-outcome-oriented-execution

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

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

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 temporary, reversible breakage is acceptable during phased migrations. - Verification Boundaries: Requires full static and runtime verification at plan completion before declaring done. - Use Case: During a multi-phase migration from a legacy module to a new service architecture, apply this principle to skip building adapter shims for each phase and instead verify correctness at explicit phase boundaries. ## 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 throwaway 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 keep it scoped and reversible.

When is it acceptable to break intermediate states during a rewrite?▼

Intermediate breakage is acceptable when it is planned, scoped, and reversible within a migration that has explicit phase boundaries. Always declare the breakage zones upfront and run full verification before declaring the work done.

When should I not use outcome-oriented execution?▼

Avoid this approach for changes without explicit phase boundaries or where continuous stability is mandatory, such as live production hotfixes. It is designed for planned rewrites and migrations, not incremental maintenance work.

What verification is required before declaring a migration complete?▼

Full static and runtime verification at plan completion is required. Keep high-signal checks running for actively touched areas throughout the migration, then prove end-state correctness at the final boundary.

Why does preserving smooth intermediate states create technical debt?▼

Keeping every intermediate step fully stable requires temporary compatibility code that often survives long after the migration ends. Prioritizing end-state integrity avoids this scaffolding becoming permanent debt.