jaydubya818/software-factory-skills

Use when a non-trivial change needs types and module boundaries designed before code.

Use when an important artifact needs independent solutions compared and synthesized.

Use when the user wants working preferences captured in a reusable mode skill.

Use when an authorized pull request needs ongoing CI and review follow-through.

Capture before/after screenshots of pages, elements, or images. Use when UI changes need visual comparison or pull-request evidence.

Use when a change needs downstream risks traced and its key safety assumption proved.

Use when the previous technical answer needs a direct, jargon-free restatement.

Separate orchestration from reusable mechanics while preserving transactions. Use when workflows duplicate operational logic.

Use when a repository needs a repeatable driver that proves real UI, CLI, or service behavior.

Use when code needs generated clutter removed and structure simplified without behavior changes.

Capture observable runtime proof with video, screenshots, or measured output. Use when a change needs evidence beyond test reports.

Use when novel or multi-phase work needs an auditable workflow and no narrower playbook fits.

Use when failing pull-request checks need a root-cause fix and a verified rerun.

Use when a branch needs conflicts resolved and the merged result verified.

Use when pull-request feedback needs to be fetched and summarized for action.

Run bounded Greptile review-and-fix cycles on a PR, MR, or shelved change. Use when Greptile is an explicit delivery gate.

Run greploop through @greptile-apps when the normal trigger rejects a large PR. Use only with the companion greploop skill.

Use for runtime, ownership, layering, code-walkthrough, and placement questions.

Use when a change's assumptions, evidence, or design need adversarial review.

Use when a project's verification driver or feature map may be stale.

Use when a correct pull request needs clearer history, description, or reviewer guidance.

Preserve Mission-to-release lineage, evidence, and authority boundaries. Use when Mission Control or a similar software factory governs the work.

Create or use a task-owned Git worktree for repository edits. Use for features, fixes, or documentation changes; skip read-only work.

Use when code comments need structural review, root-cause fixes, and constraint encoding.

Use when non-trivial work should follow the smallest rigorous Jstack workflow.

Apply when repeated fixes fail and a shared assumption may be wrong.

Apply when validation or adapters leak from external boundaries into core logic.

Apply when a rerunnable script, codemod, generator, or check makes work auditable.

Apply when a repeated instruction should become enforceable in tests, lint, metadata, or tools.

Apply when a novel design needs concrete candidates compared before selection.

Apply when scope threatens a polished, clear, and trustworthy user experience.

Apply when a workaround would hide a defect that can be reproduced and traced.

Apply when core types, data structures, or shared-state boundaries will shape the system.

Apply when large files, logs, or broad exploration threaten reasoning focus.

Apply when a refactor is adding wrappers or abstractions instead of simplifying.

Apply when an operation must tolerate retries after partial completion.

Apply when replacing an internal API without leaving ambiguous dual paths.

Apply when layers, wrappers, or hidden state make simple behavior hard to follow.

Apply when repeated state conditionals reveal a missing domain model.

Apply when safe reversible implementation details can proceed inside scope.

Apply when a bounded rewrite should converge without throwaway compatibility layers.

Apply when the actual candidate and observable result still need verification.

Apply when a requirement breaks a foundational assumption and needs coherent redesign.

Apply when concurrent actors share mutable files, branches, keys, or objects.

Apply when multi-step work must end each ordered unit in a verified state.

Apply when new work would otherwise build on dead or redundant structure.

Apply when tests mirror internals instead of asserting observable outcomes.

Apply when typed APIs or schemas should make invalid states unrepresentable.

Use when resuming work or reconstructing project context from workspace-scoped history.

Use when approved session lessons should become durable workflow improvements.

Use when the user wants to configure Jstack's per-role Claude models.

Use when long-running work needs an auditable decision and evidence log.

Use when authorized independent workers can run without shared mutable state.

Use when TDD is requested or a bug has a cheap, direct regression target.

Use when runtime behavior and design rationale should become one clear mental model.

Use when docs, RFCs, READMEs, PRs, or commits need structured and direct prose.

Use when the user requests an intentionally strict maintainability review.

Use when TypeScript needs focused type-safety, API, or error-handling guidance.

Remove filler and generic AI phrasing from human-facing text. Use before sending or committing prose you edited.

Use when authored work needs a concise summary for a concrete time window.

Use when design rationale must be recovered from source history and available records.