Skip to content

Adonis0123/adonis-skills / skills/workflow-gate

workflow-gate

Verified

Classify which workflow or skill should run when route choice matters: unresolved creative work, named-option decisions, explicit Goal management, destructive actions, architecture work, planning, debugging or ship checks, review handoff, and full-completion pipelines. Skip trivial one-line work and clearly matching safe named-skill requests. Treat first-principles analysis as a method, not a Challenge trigger unless the user is widening the option space.

FileKindSize
SKILL.mdskill md13.2 KB
agents/openai.yamlconfig410 B
evals/evals.jsonconfig41.7 KB
evals/trigger-eval.jsonconfig3.1 KB
references/examples-core.mdmarkdown5.2 KB
references/examples-edge.mdmarkdown14.9 KB
references/route-adjustments.mdmarkdown3.7 KB
references/workflow-systems.mdmarkdown9.5 KB

references/examples-core.md

View on GitHub
# Worked examples (core) — workflow-gate

At least one example per Route (Direct / Light / Challenge / Plan / Architecture / Review-Handoff). Mirror these when the prompt looks like the example; deviate when the Signals say otherwise. For edge cases (tiebreakers, mismatches, Rule #2 negatives, Thesis S1, Architecture diagnose vs harden, re-gating, contradictory signals), see `examples-edge.md`.

## Direct — read-only question

User: "Read me the line count of `App.tsx`."

```
Workflow Gate
- Route: Direct
- Runtime skill: none
- Fallback alias: none
- Execution path: direct local work
- Thesis: n/a
- Goal: Report the line count of apps/web/src/App.tsx.
- Signals: scope=single-file; risk=low; destructive=no; decisions=resolved; user-intent=lookup
- Assumptions: none
- Next: Count the file's lines with the local runtime's native command and return the number.
```

## Light + direct local work — typo / single-line edit

User: "Fix typo `recieve` → `receive` on apps/web/src/App.tsx:42."

```
Workflow Gate
- Route: Light
- Runtime skill: none
- Fallback alias: none
- Execution path: direct local work
- Thesis: n/a
- Goal: Apply the typo fix at apps/web/src/App.tsx:42.
- Signals: scope=single-file; risk=low; destructive=no; decisions=resolved; user-intent=implement
- Assumptions: none
- Next: Edit the line; no further verification beyond a re-read of the diff.
```

## Challenge — open / stress a thesis (user-provided)

User: "Design the sharing model for dashboards — I want workspace-scoped invites by default; public links optional. Pressure-test that before code."

```
Workflow Gate
- Route: Challenge
- Runtime skill: grilling
- Fallback alias: none
- Execution path: n/a
- Thesis: user-provided
- Goal: Stress-test workspace-scoped-invite-default sharing thesis against link / RBAC / workspace alternatives.
- Signals: scope=multi-module; risk=medium; destructive=no; decisions=unresolved; user-intent=ideate
- Assumptions: none
- Next: Load grilling; walk the decision tree against the stated thesis.
```

## Challenge (convergence) — named options, pick one

User: "Stripe or Lemon Squeezy for billing? Pricing tiers undecided too."

```
Workflow Gate
- Route: Challenge
- Runtime skill: grilling
- Fallback alias: none
- Execution path: n/a
- Thesis: agent-strawman
- Goal: Converge on a billing provider and tier shape before any implementation plan.
- Signals: scope=multi-module; risk=high; destructive=no; decisions=unresolved; user-intent=decide
- Assumptions: Options are already named — converge, do not widen.
- Next: Strawman — recommend Stripe with the decisive reason; confirm or revise; then load grilling against Lemon Squeezy only.
```

## Plan — RFC-driven task breakdown

User: "Per RFC-024, give me a task breakdown for wiring Google OAuth into apps/web — expect 5-8 files."

```
Workflow Gate
- Route: Plan
- Runtime skill: writing-plans
- Fallback alias: none
- Execution path: n/a
- Thesis: n/a
- Goal: Break the RFC-024 Google OAuth work into implementation tasks.
- Signals: scope=few-files; risk=medium; destructive=no; decisions=resolved; user-intent=plan
- Assumptions: RFC-024 is authoritative and current; the immediate request is planning, not implementation.
- Next: Load writing-plans; produce a 5-8 task breakdown grounded in the RFC.
```

## Architecture — diagnose only

User: "Don't change code yet — diagnose module boundaries and dependency direction in `apps/web` and give an architecture candidate report."

```
Workflow Gate
- Route: Architecture
- Runtime skill: improve-codebase-architecture
- Fallback alias: none
- Execution path: n/a
- Thesis: n/a
- Goal: Produce an architecture candidate report for apps/web without implementing fixes.
- Signals: scope=multi-module; risk=medium; destructive=no; decisions=unresolved; user-intent=ideate
- Assumptions: Scope is user-named apps/web; diagnose-only — do not enter hardening loop.
- Next: Load improve-codebase-architecture; explore + HTML report, then stop.
```

## Architecture — scoped harden loop

User: "Freeze scope to `apps/web/src/features/billing/**` and run the architecture harden loop until no actionable findings."

```
Workflow Gate
- Route: Architecture
- Runtime skill: architecture-hardening-loop
- Fallback alias: none
- Execution path: n/a
- Thesis: n/a
- Goal: Boundedly harden apps/web/src/features/billing until NO_ACTIONABLE_FINDINGS.
- Signals: scope=few-files; risk=medium; destructive=no; decisions=resolved; user-intent=implement
- Assumptions: Path is explicit and implement/harden intent is explicit.
- Next: Load architecture-hardening-loop with the frozen scope.
```

## Review-Handoff — fresh eyes

User: "Have a fresh agent code-review `feature/billing-redesign`, with re-review after I fix."

```
Workflow Gate
- Route: Review-Handoff
- Runtime skill: agentic-review-handoff
- Fallback alias: none
- Execution path: n/a
- Thesis: n/a
- Goal: Get an independent cross-agent review of feature/billing-redesign with re-review after fixes.
- Signals: scope=multi-module; risk=medium; destructive=no; decisions=resolved; user-intent=review
- Assumptions: Repo is a git repo (agentic-review-handoff requires it).
- Next: Load agentic-review-handoff; create a packet scoped to main…feature/billing-redesign.
```
writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deploymentStars: 322kUpdated Claude CodeCodexVerifiedInstall
xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy.Stars: 119kUpdated Claude CodeCodexVerifiedInstall
childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release.Stars: 118kUpdated Claude CodeCodexVerifiedInstall