From sd0x-dev-flow
Detects when Claude forgot a rule or skipped a required step, auto-loads relevant rule files, and immediately executes the correction. Use proactively after editing files to catch drift.
How this skill is triggered — by the user, by Claude, or both
Slash command
/sd0x-dev-flow:remindThis skill is limited to the following tools:
The summary Claude sees in its skill listing — used to decide when to auto-load this skill
Detect what rules or steps the model forgot, auto-load the relevant rule files, and **execute the correction immediately**. Think of this as a "conscience check" that reads the actual rules rather than relying on memory.
Detect what rules or steps the model forgot, auto-load the relevant rule files, and execute the correction immediately. Think of this as a "conscience check" that reads the actual rules rather than relying on memory.
/remind is an executor, not a reporter. After detecting a violation:
Skill: /codex-review-doc| Prohibited | Correct |
|---|---|
| ❌ "要執行 /codex-review-doc 嗎?" | ✅ Output findings → immediately invoke /codex-review-doc |
| ❌ Output table then stop | ✅ Output table → invoke correction Skill → report result |
| ❌ "建議執行..." / "Next step: run..." | ✅ Execute the correction, don't suggest it |
| ❌ Ask user for permission | ✅ Auto-loop rules mandate execution without permission |
Exception: Only stop without executing when findings are ### All Clear ✅ (nothing to fix).
| Scenario | Alternative |
|---|---|
| Full code review | /codex-review-fast |
| What to do next | /next-step |
| Workflow progression | /feature-dev |
| Adversarial debate | /codex-brainstorm |
| Mode | Trigger | Behavior |
|---|---|---|
| Smart detect | /remind (no args) | Read state + git → detect violations → auto-load relevant rules |
| Specific rule | /remind auto-loop | Read rules/auto-loop.md → summarize + check violations |
| Nuclear | /remind --all | Read CLAUDE.md + ALL rules → full compliance report |
When invoked without arguments, run detection heuristics then dynamically load the relevant rules for each finding.
# State file
STATE_FILE_EXISTS=$(test -f .claude_review_state.json && echo "true" || echo "false")
STATE=$(cat .claude_review_state.json 2>/dev/null || echo "{}")
HAS_CODE=$(echo "$STATE" | jq -r '.has_code_change // false')
HAS_DOC=$(echo "$STATE" | jq -r '.has_doc_change // false')
CODE_REVIEW=$(echo "$STATE" | jq -r '.code_review.passed // false')
DOC_REVIEW=$(echo "$STATE" | jq -r '.doc_review.passed // false')
PRECOMMIT=$(echo "$STATE" | jq -r '.precommit.passed // false')
# Git
BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null)
DIRTY=$(git status --porcelain 2>/dev/null)
For each detected issue, Read the mapped rule file and extract the key section:
| # | Detection | Condition | Rule to Load | Section to Extract |
|---|---|---|---|---|
| 1 | Code changed, no review | HAS_CODE=true + CODE_REVIEW=false | rules/auto-loop.md | "Prohibited Behaviors" + "Auto-Trigger" table |
| 2 | Doc changed, no review | HAS_DOC=true + DOC_REVIEW=false | rules/auto-loop.md | ".md" row in Auto-Trigger table |
| 3 | Review passed, no precommit | CODE_REVIEW=true + PRECOMMIT=false | rules/auto-loop.md | "precommit Pass" row |
| 4 | State drift | State says changes but git clean | — | Suggest reset state file |
| 5 | On main branch | BRANCH=main|master | rules/git-workflow.md | Branch naming + protected branches |
| 6 | Dirty worktree, no state | Git dirty + no state file | CLAUDE.md | "Required Checks" table |
For each finding, quote the relevant rule text inline so the model re-ingests the rule:
## Reminder
### Findings
| # | Priority | Rule | Issue | Correction |
|---|----------|------|-------|------------|
| 1 | P0 | auto-loop | Code changed but review not passed | `/codex-review-fast` |
### Rule Context (auto-loaded)
> **auto-loop.md — Prohibited Behaviors**:
> - ❌ Declaring ≠ Executing: Saying "need to run X" without actually invoking the tool
> - ❌ Summary ≠ Completion: Outputting a summary then stopping
>
> **Required action**: Execute `/codex-review-fast` in this reply, do not stop.
### Corrections (copy-pasteable)
1. `/codex-review-fast`
When no findings: output ### All Clear ✅ with a brief status summary.
/remind <rule>)When user provides a rule name:
rules/<rule>.md → if not found, try rules/<rule>-project.md → if not found, list available via Glob("rules/*.md")/remind --all)When the model keeps drifting despite specific reminders:
CLAUDE.md: Extract ## Required Checks table + ## Workflow section + ## Auto-Loop Rule sectionGlob("rules/*.md") → Read each fileThis is the "nuclear option" — high token cost but guarantees the model re-ingests all project rules. Use when repeated /remind calls haven't fixed the drift.
| Flag | Default | Description |
|---|---|---|
<rule> | — | Specific rule name (e.g., auto-loop, git-workflow) |
--all | false | Load ALL rules + CLAUDE.md (nuclear mode) |
| (no args) | — | Smart detection with context-aware rule loading |
| Failure | Behavior |
|---|---|
| jq unavailable | Skip state file parsing, git-only checks |
| State file missing | Git-only checks + suggest starting review loop |
| Rule file not found | List available rules via Glob("rules/*.md") |
The reminder output isn't just informational — it's a correction directive with mandatory execution:
/codex-review-fast" — invoke Skill: /codex-review-fast now, not laterThe whole point of /remind is that the model's memory of rules has drifted. The quoted rule text is the source of truth, not the model's recollection of what the rules say.
Correct flow:
/remind → detect doc-no-review → output findings table → invoke Skill(/codex-review-doc) → report result
/remind → detect code-no-review → output findings table → invoke Skill(/codex-review-fast) → report result
/remind → no findings → output "### All Clear ✅" → stop (no correction needed)
Input: /remind
Output: Smart detection finds code changed without review → loads auto-loop.md → quotes Prohibited Behaviors → outputs `/codex-review-fast`
Input: /remind auto-loop
Output: Reads rules/auto-loop.md → summarizes 8 prohibited behaviors + auto-trigger table → checks state file → reports current compliance
Input: /remind --all
Output: Reads CLAUDE.md + all rules/*.md → produces full compliance matrix → flags all violations with correction commands
Input: /remind git-workflow
Output: Reads rules/git-workflow.md → summarizes branch naming + forbidden operations → checks current branch → warns if on main
git add / git commit / git push executedreferences/detection-rules.md — Detection → rule mapping table + extraction patternsnpx claudepluginhub sd0xdev/sd0x-dev-flow --plugin sd0x-dev-flowCaptures lessons from code reviews and error corrections as persistent rules. Activates on /evolve or when user says 'we should remember this'.
Extracts reusable rules from developer corrections during a coding session and persists them to CLAUDE.md or memory for future sessions.
Verifies Claude Code adherence to project instruction rules via conformance checks on codebase structure, imports, configs or session history analysis with alignkit.