oh-my-stack

Design caller-first types and modules, compare alternatives, then implement within scope.

Compare independent candidates, select a base, graft stronger ideas, and verify.

Create or revise a scoped Skill and check its behavior.

Capture a user's recurring work conventions in a personal Skill.

Run a bounded task until its completion condition is verified.

Build, review, and land a queue only with explicit authorization.

Build and review a linear change stack; leave landing to the operator.

Check or repair a pull request; require separate merge authorization.

Prove the safety assumptions and downstream risks of a change.

Restate the last answer plainly without changing its meaning.

Reproduce, fix, and independently verify a software defect.

Create and exercise a project-local user-path verification Skill.

Compare workflow variants with blinded outputs and a frozen rubric.

Add or change behavior with design and end-to-end verification.

Plan and verify a complex task with an auditable decision trail.

Improve one metric through bounded measured attempts.

Explain a code path or subsystem using verified repository evidence.

Review frozen inputs with independent reviewers and root judgment.

Answer an engineering question from evidence without changing code.

Audit and update a verification Skill using source and live behavior.

Build a local control page for an authenticated webhook.

Write a dependency plan with verifiable units and live checks.

Review comments, remove redundancy, and encode real constraints.

Prepare a reviewed pull request; publish only when explicitly requested.

Coordinate ongoing engineering work with bounded tasks and independent checks.

Checkpoint in-flight work when the user requests a pause.

Fix one performance issue with before and after traces.

Route an engineering request to the appropriate Oh My Stack workflow.

Question a shared premise after multiple fixes fail the same check.

Validate external boundaries and keep internal logic simple.

Use reusable tools for nontrivial edits, migrations, and checks.

Turn recurring corrections into executable rules.

Compare prototypes for unfamiliar UI or architecture decisions.

Prioritize polished user experience in product and scope decisions.

Reproduce a defect and repair its cause instead of hiding symptoms.

Choose core data structures and shared-state ownership before logic.

Manage context growth from large outputs, repeated reads, and fan-out.

Prefer deletion and small changes when considering abstractions.

Make retries and partial runs converge on the same result.

Migrate callers and remove the old internal API in the same change.

Reduce indirection and hidden state in hard-to-follow code.

Model state and repeated assumptions in explicit data structures.

Proceed with authorized reversible work; ask when authority is needed.

Keep phased migrations focused on the target architecture.

Verify the actual result before declaring a task complete.

Reconsider the design around a new requirement.

Separate concurrent writers before serializing shared state.

Order multi-step work into small, independently verified units.

Remove dead code and redundant structure before adding behavior.

Test observable behavior through the user's interface.