Use Agent Skills with LoopLatch
LoopLatch controls repetition. Agent Skills provide specialized operating guidance for the work inside or before that loop. Used together, they can turn a vague request into a narrower, better-evidenced local workflow.
Two complementary layers
A loop harness and an Agent Skill solve different problems
LoopLatch defines the outer control loop: task, verifier, permissions, budgets, stop conditions, structured results, approvals, and audit files. An Agent Skill gives the coding agent specialized instructions, references, or tools for a particular kind of work. The skill may help shape the task or inspect the repository, but it does not replace the harness's verifier or safety controls.
The initial integration is deliberately visible and optional. LoopLatch shows promoted public skills, the point in the workflow where each one helps, and the exact command documented by its public catalog page. The website does not install a skill, detect local skills, fetch a remote registry, or modify the generated prompt behind the user's back.
1. Clarify fuzzy work with Codex Spec Interviewer
Use Codex Spec Interviewer when a feature, refactor, migration, or repository-wide request is missing verified requirements. It interviews the request, challenges source assumptions, identifies whether an ADR is required, and produces acceptance criteria and validation commands. That output can become a much stronger LoopLatch task, done condition, and verifier.
Skip this step when the task is already narrow and complete. The goal is not to add ceremony to a one-line fix; it is to prevent a broad loop from inventing scope. The skill can require Plan mode because user verification is part of its contract.
/plan Use $codex-spec-interviewer to turn this task into a Codex-ready implementation spec. Make the done condition externally verifiable and identify the narrowest repository validation command.2. Check architecture evidence with Architecture Compass
Use Architecture Compass when the repository has accepted ADRs, stack rules, examples, or source-boundary conventions that govern the change. The skill can audit or plan against that evidence and call out durable decisions before implementation drifts into a competing runtime, layout, dependency policy, or request pattern.
This is most useful for feature implementation, architecture-sensitive review fixes, and custom work that crosses a durable boundary. It is not necessary for tiny style-only edits with no architecture consequence. LoopLatch still owns the verifier and loop budgets; Architecture Compass improves the repository-specific plan that feeds them.
Use $architecture-compass in refactor mode to check this task against the repository's accepted ADRs, stack rules, source ownership, and validation commands before implementation.3. Map code impact with CodeGraph + ast-grep
Use CodeGraph + ast-grep when a failure or review comment points to one symbol but the likely impact spans callers, routes, or repeated code shapes. CodeGraph provides semantic relationships, while ast-grep confirms exact syntax patterns. Together they can shrink the affected file set and identify a focused verifier before a repair loop begins.
The skill may require separate analysis-tool setup, indexing, or update choices. Review those actions and do not assume every graph operation is automatically read-only or telemetry-free. The value is evidence for a smaller change, not a license to perform a broad refactor.
Use $codegraph-ast-grep to map the affected files, callers, and exact code shapes for this task before proposing the smallest safe change.Pair skills with the LoopLatch preset only when they add value
A restrained recommendation is easier to understand than a catalog dump. Test-Fix and CI Autofix usually benefit from impact mapping when the failure path is unclear. Feature Implementation benefits from specification work and an architecture check. Review-Fix often needs architecture evidence and sometimes impact mapping. Custom work benefits from specification and architecture guidance when its boundaries are still open.
LoopLatch recommends only promoted public skills in the initial product surface. Candidate skills such as CI Debugger, PR Review, and Test-First Implementation may sound relevant, but the public catalog currently marks them as incubator entries. Keeping that distinction visible prevents experimental guidance from appearing production-ready.
| LoopLatch preset | Start with | Why |
|---|---|---|
| Test-Fix | CodeGraph + ast-grep | Trace the failure path and affected callers |
| Feature Implementation | Spec Interviewer → Architecture Compass | Verify scope, proof, and repository rules |
| CI Autofix | CodeGraph + ast-grep | Map a reproducible failure to the smallest patch |
| Review-Fix | Architecture Compass; CodeGraph when needed | Preserve intent and confirm impact |
| Custom | Spec Interviewer; Architecture Compass when needed | Resolve open requirements and durable boundaries |
Review the source, then install for the intended runtime
Agent Skills are executable agent context. Review each SKILL.md, references, scripts, assets, and public evaluation proof before installing it. The commands shown by LoopLatch target a global Codex installation because they match the current promoted skill detail pages. If your team prefers project-local skills or another compatible agent runtime, use the catalog's documented runtime-specific command instead.
Installing a skill does not strengthen the Codex sandbox, prove that the skill will trigger, or guarantee a correct result. Keep LoopLatch's verifier, budgets, and review steps independent. If an install command or public path changes, the linked catalog is the source to verify before execution.
npx skills add https://github.com/stark-ai-de/agent-skills --skill codex-spec-interviewer -g -a codexA practical combined workflow
Use only the stages the task needs. A focused test regression may go directly from impact mapping to LoopLatch. A broad feature may need specification and architecture checks before the builder. At every stage, keep task content local, review generated files, and let repository-owned validation decide completion.
- 01Clarify the request and acceptance criteria when scope is fuzzy.
- 02Check accepted architecture evidence when the change affects durable boundaries.
- 03Map callers and exact code shapes when the affected area is uncertain.
- 04Choose the LoopLatch preset and enter the resulting task, done condition, and verifier.
- 05Generate and review the bootstrap prompt, then run it locally with Codex CLI.
- 06Review the repository-specific harness and every loop patch before accepting it.
Review the skill, then install it for Codex.
These commands match the current public skill detail pages and install globally for Codex. LoopLatch displays them for review; it never executes them.
Codex Spec Interviewer
ClarifyTurn a fuzzy coding request into a verified implementation spec with explicit acceptance criteria and validation commands.
Use when: The requested change is broad, ambiguous, or missing a testable done condition.
Install globally for Codex
npx skills add https://github.com/stark-ai-de/agent-skills --skill codex-spec-interviewer -g -a codexExample invocation
/plan Use $codex-spec-interviewer to turn this task into a Codex-ready implementation spec. Make the done condition externally verifiable and identify the narrowest repository validation command.Architecture Compass
Check architectureCheck implementation work against repository ADRs, stack rules, source ownership, runtime boundaries, and validation before code drifts.
Use when: The repository has architecture evidence or the change crosses a durable boundary.
Install globally for Codex
npx skills add https://github.com/stark-ai-de/agent-skills --skill architecture-compass -g -a codexExample invocation
Use $architecture-compass in refactor mode to check this task against the repository's accepted ADRs, stack rules, source ownership, and validation commands before implementation.CodeGraph + ast-grep
Map impactMap affected files, symbols, callers, and exact code shapes before a bounded repair or refactor.
Use when: The failure path or likely refactor impact is not yet clear from a focused file set.
Install globally for Codex
npx skills add https://github.com/stark-ai-de/agent-skills --skill codegraph-ast-grep -g -a codexExample invocation
Use $codegraph-ast-grep to map the affected files, callers, and exact code shapes for this task before proposing the smallest safe change.What to know before you start
Does LoopLatch install or run Agent Skills?
No. LoopLatch provides optional, curated guidance and links. Installation and skill execution happen in your own agent environment after you review the public source.
Are these official OpenAI skills?
No. They are promoted public skills maintained in the stark-ai-de Agent Skills catalog. Review their source and compatibility information before installation.
Should every LoopLatch task use all three skills?
No. Use Spec Interviewer for fuzzy work, Architecture Compass for ADR- or boundary-sensitive work, and CodeGraph + ast-grep when semantic or structural impact is unclear. A narrow, fully specified task may need none of them.