Scan for hidden failures: swallowed errors (empty catch, || true, 2>/dev/null) and silent degradation (success on zero results). Use when failures vanish or success masks empty output.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
Scan for hidden failures: swallowed errors (empty catch, || true, 2>/dev/null) and silent degradation (success on zero results). Use when failures vanish or success masks empty output.
name
code-hidden-failures
model
opus
Hidden-Failure Scanner
Detect code that fails without saying so. Two tracks:
Logical โ an operation "succeeds" with empty/useless output because a precondition was silently unmet
success toast on count === 0, if (!apiKey) return [], a 1-of-3 detector run with no indication
The two were previously separate skills (code-error-swallowing +
code-silent-degradation); they are the same user intent โ "the work
reported success but nothing real happened" โ so they live in one scanner
with a --track selector.
--track <errors|degradation|both>: which track to run (default both)
--lang <shell|js|py|go|rust|auto>: errors track โ restrict to one language (default auto)
--severity <low|med|high>: minimum severity to report (default med)
--emit-patch: errors track โ emit a unified-diff patch on stdout (no in-place mutation; apply with git apply)
--fix: degradation track โ apply recommended fixes in place (precondition checks, status indicators, distinguishing copy)
--emit-patch and --fix are mutually exclusive โ the errors track reviews
its surfacing copy via a patch, the degradation track applies structural
fixes directly.
Execution
Run the selected track(s). Default both: run errors first, then degradation,
then a combined summary.
Track A โ Error swallowing
Run when --track is errors or both.
Step A1: Detect languages and app context
From the context commands above, determine which language matchers to run.
For the app-context matrix (signals โ surfacing channel), load
REFERENCE-surfacing.md.
Step A2: Run the matchers
The AST-shaped swallowed-error patterns (js/ts, python, go, rust) live as an
ast-grep rule project in rules/ (one *.yml per pattern under
rules/lib/, each with a valid/invalid fixture in rules/tests/). Run the whole
catalog in one deterministic pass โ do not re-type sg -p 'โฆ' per language:
Graceful degradation โ if ast-grep (packaged as ast-grep or sg) is not
installed, fall back to the per-pattern flow: read the REFERENCE-{js,python,go, rust}.md files (each links its patterns to the rule .yml) and run the
individual sg -p '<pattern>' --lang <lang> commands by hand. Prefer the repo's
own errcheck/staticcheck (Go) or cargo clippy (Rust) when configured โ the
rule project surfaces what those linters would catch, it does not replace them.
For every finding, capture: file:line, matched snippet, surrounding function
name if discoverable.
Step A3: Classify severity
For every raw finding, assign Low / Medium / High:
Severity
Criteria
Examples
Low
Matches a documented allowlist entry or the catch block has a log call + rethrow.
Frontmatter extraction || true (see .claude/rules/shell-scripting.md lines 135โ162); except FileNotFoundError: pass around an optional cache.
Medium
Error suppressed with no log, no fallback value, no surfacing, on a recoverable operation.
catch (e) {} around a UI-layer fetch; || true after make lint.
High
Suppression around a required operation: data writes, auth, secret handling, config loading, release builds, push/deploy.
npm publish 2>/dev/null || true; except: pass around a DB commit; _ = os.Remove(tmpPath) on a path the caller assumed was cleaned.
Apply the per-language allowlist rules from each REFERENCE-*.md before
assigning Low.
Step A4: Recommend a surfacing channel
For each Medium/High finding, consult REFERENCE-surfacing.md to pick the
channel appropriate to the detected app context โ do not recommend a
uniform "log and rethrow":
App context
Recommended channel
CLI / shell
echo "warn: ..." >&2 + non-zero exit on High
Web frontend
console.error + user-facing toast/banner with sanitized copy
Re-raise / return Result / propagate โ do not surface to user
CI / build script
echo "::error::..." (GitHub) or stderr + non-zero exit
Step A5: Apply privacy redaction
Every suggested replacement (report and--emit-patch) MUST pass through
the redaction rules in REFERENCE-surfacing.md ยงPrivacy:
Redact env values by name pattern (*TOKEN*, *KEY*, *SECRET*, *PASSWORD*, GH_*, ANTHROPIC_*, AWS_*) โ [REDACTED].
Rewrite absolute home paths ($HOME, /Users/โฆ, /home/โฆ) โ ~.
Truncate message payloads at 200 characters.
Prefer action-oriented copy over raw stderr forwarding.
Never forward set -x / xtrace output.
For web frontend, split: verbose detail โ console.error; short sanitized
copy โ UI channel.
Step A6: Emit patch (if --emit-patch)
Generate a unified diff to stdout (not written to files) that covers only
Medium/High findings, applies the app-context-appropriate channel, runs every
inserted string through the Step A5 redaction, and adds a
# TODO(hidden-failures): review wording comment next to each generated
user-facing message. Remind the user: git apply <patchfile>.
Track B โ Silent degradation
Run when --track is degradation or both. Detection patterns, severity
guide, and fixes live in REFERENCE-degradation.md.
Step B1: Discover source files
Glob **/*.{ts,tsx,js,jsx,py,go,rs} in the target path, excluding
node_modules, dist, build, .git, vendor, __pycache__.
Step B2: Scan for the five degradation patterns
Match the five pattern categories from
REFERENCE-degradation.md: silent config skip,
success on zero results, silent step skipping, missing precondition
validation, hidden degraded mode. For each finding capture file:line, which
pattern, what the user experiences, and the preconditions the code needs.
Step B3: Classify (degradation severity)
High = success messaging when nothing worked (patterns 2, 3); Medium =
functionality silently disabled by config/env (patterns 1, 5); Low = missing
upfront validation (pattern 4).
Step B4: Apply fixes (if --fix)
Apply the per-pattern fixes from
REFERENCE-degradation.md ยง Recommended Fixes in
place, then list every change with file:line references.
Combined Report
Group by severity descending; omit Low unless --severity low. Tag each row
with its track.
rules/ โ the executable ast-grep catalog for the errors track (sgconfig.yml + rules/lib/*.yml + rules/tests/*-test.yml); run ast-grep test -c rules/sgconfig.yml --skip-snapshot-tests to verify every rule against its fixtures
/code:antipatterns โ delegates here for the error-swallowing category
/code:review โ prose code review
.claude/rules/shell-scripting.md โ canonical allowlist for shell \|\| true / 2>/dev/null
