Optional workflow companions

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.

8 min readUpdated

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.

Suggested optional skill handoffs by LoopLatch preset
LoopLatch presetStart withWhy
Test-FixCodeGraph + ast-grepTrace the failure path and affected callers
Feature ImplementationSpec Interviewer → Architecture CompassVerify scope, proof, and repository rules
CI AutofixCodeGraph + ast-grepMap a reproducible failure to the smallest patch
Review-FixArchitecture Compass; CodeGraph when neededPreserve intent and confirm impact
CustomSpec Interviewer; Architecture Compass when neededResolve 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 codex
Common questions

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.

Turn the guidance into a bounded local loop.

Define the task, choose the verifier, set the budgets, and review the exact bootstrap prompt before anything touches your repository.

Open the LoopLatch builder