Skip to content
Skills Library
Programming · Review & audit

unslopify

/unslopify

Review code for weak type or data contracts, mixed responsibilities, hidden failures, workaround-driven error handling, and duplicated knowledge. Use for tactical code-quality review, pull-request review, pre-commit cleanup, refactoring assessment, or requests about type strictness, single responsibility, fail-fast behavior, defensive fallbacks, and DRY. Works across programming languages and mixed-language repositories.

Repository
skills ↗
Licence
MIT
Last repository change
15.07.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
11
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 15.07.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Review code for weak type or data contracts, mixed responsibilities, hidden failures, workaround-driven error handling, and duplicated knowledge. Use for tactical code-quality review, pull-request review, pre-commit cleanup, refactoring assessment, or requests about type strictness, single responsibility, fail-fast behavior, defensive fallbacks, and DRY. Works across programming languages and mixed-language repositories.

Original author description

Review code for weak type or data contracts, mixed responsibilities, hidden failures, workaround-driven error handling, and duplicated knowledge. Use for tactical code-quality review, pull-request review, pre-commit cleanup, refactoring assessment, or requests about type strictness, single responsibility, fail-fast behavior, defensive fallbacks, and DRY. Works across programming languages and mixed-language repositories.

How it works

  1. Select the scope
  2. Apply the review lenses
  3. Remain language-agnostic
  4. Validate candidates
  5. Report findings
  6. Claude Code adapter
Original SKILL.md headings · 109 lines, 785 words
SKILL.md preview
---
name: unslopify
description: Review code for weak type or data contracts, mixed responsibilities, hidden failures, workaround-driven error handling, and duplicated knowledge. Use for tactical code-quality review, pull-request review, pre-commit cleanup, refactoring assessment, or requests about type strictness, single responsibility, fail-fast behavior, defensive fallbacks, and DRY. Works across programming languages and mixed-language repositories.
---

# Unslopify

Review tactical code quality through four complementary lenses:

- **Contract strength:** Do types, schemas, validation, and invariants express valid states?
- **Single responsibility:** Does each unit have a coherent reason to change?
- **Failure integrity:** Are failures handled deliberately rather than hidden?
- **Knowledge duplication:** Is the same rule encoded in multiple places?

Perform a review by default. Do not edit code unless the user explicitly asks for changes.

## Select the scope

Honor an explicit user-provided review scope before applying defaults. Accept files,
directories, snippets, diffs, commits, branches, pull-request refs, or the whole repository.
A comparison-base option by itself configures branch comparison; it is not a review scope.

When the user does not specify a scope:

1. In a Git repository, inspect working-tree changes relative to `HEAD`.
2. If the working tree is clean, resolve the comparison base in this order: a comparison-base
   option supplied by the user, the remote's symbolic default branch, then the configured
   upstream when no remote default can be determined. Never assume `main`.
3. Compute the merge base between that ref and `HEAD`, then review from the merge base through
   `HEAD`. This includes already-pushed feature commits instead of comparing a feature branch
   only with its same-named remote tracking branch.
4. If no base or meaningful diff can be determined, ask for a scope or report that there is
   nothing to review.
5. Outside Git with no explicit review scope, ask the user for files, a directory, a diff, or a
   snippet to review.

Read enough surrounding code, tests, configuration, and documentation to validate each
finding. Distinguish problems introduced by the selected changes from relevant pre-existing
context. Exclude generated, vendored, minified, lock, and snapshot files unless requested.

## Apply the review lenses

Run all four lenses unless the user selects one. If independent workers or subagents are
available, the lenses may run in parallel with the same scope. Otherwise, run them
sequentially. Parallelism is an optimization, not a requirement.

1. Read [contracts.md](references/contracts.md) for type, schema, validation, nullability,
   state-modeling, and boundary-contract issues.
2. Read [responsibility.md](references/responsibility.md) for mixed change vectors,
   abstraction levels, and orchestration that contains unrelated policy.
3. Read [failure-integrity.md](references/failure-integrity.md) for swallowed failures,
   unbounded recovery, invalid defaults, and workaround-driven control flow.
4. Read [duplication.md](references/duplication.md) for duplicated knowledge and missed shared
   sources of truth without encouraging premature abstraction.
5. Merge overlapping observations into one finding and name the primary root cause.

## Remain language-agnostic

Evaluate contracts and behavior relative to the repository's language and conventions.

- In statically typed code, use the available type system to judge whether invalid states are
  representable unnecessarily.
- In dynamically typed code, consider annotations, schemas, validators, tests, protocols, and
  runtime guards; do not require static typing merely for its own sake.
- Treat exceptions, result values, optionals, error codes, panics, retries, and fallbacks as
  different encodings of failure policy rather than universally good or bad constructs.
- Treat duplicated knowledge as the target of DRY analysis, not repeated syntax alone.
- When a language or framework is unfamiliar, inspect local usage and toolchain evidence and
  lower confidence instead of applying rules from another ecosystem.

## Validate candidates

Report a candidate only when all of the following hold:

- The evidence is observable in the selected scope and necessary context.
- The issue creates a concrete correctness, maintenance, debugging, or change-propagation cost.
- A plausible improvement reduces that cost without adding greater indirection or fragility.
- Confidence is at least 80%.

Treat file length, function length, `any`-like types, force unwraps, broad catches, fallbacks,
comments, and repeated lines as investigation signals—not automatic findings. Respect explicit
resilience boundaries, optional data, generated code, test scaffolding, and intentional local
duplication.

## Report findings

Lead with findings ordered by severity, then provide a short summary. Do not assign an overall
letter grade; severity, confidence, evidence, and impact carry the assessment.

For each finding include:

```markdown
### [high|medium|low] Concise title
- Location: `path:line`
- Lens: contracts | responsibility | failure-integrity | duplication
- Confidence: 80-100%
- Evidence: What the code does and the relevant surrounding context.
- Impact: The concrete failure mode or maintenance cost.
- Recommendation: The smallest change that addresses the cause.
```

Use **high** for likely correctness, data, or security failures; **medium** for material
maintenance, debugging, or change-propagation costs; and **low** for bounded issues worth
addressing. If no qualifying findings exist, say so directly and note any limits in scope.

## Claude Code adapter

Claude Code users may invoke `/unslopify` for a standalone install or
`/unslopify:unslopify` for the plugin, optionally with `--types`, `--srp`, `--fail-fast`, `--dry`,
or `--sequential`. Map the lens flags to contracts, responsibility, failure-integrity, and
duplication respectively; treat `--sequential` as disabling parallel workers and remaining
arguments as the explicit review scope. Other agents should follow this file directly.
Files in this package (11)
  • SKILL.md 6 KB
  • .claude-plugin/plugin.json 1 KB
  • agents/dry-analyzer.md 1 KB
  • agents/fail-fast-analyzer.md 1 KB
  • agents/openai.yaml 1 KB
  • agents/srp-analyzer.md 1 KB
  • agents/type-strictness-analyzer.md 1 KB
  • references/contracts.md 2 KB
  • references/duplication.md 2 KB
  • references/failure-integrity.md 2 KB
  • references/responsibility.md 2 KB

Versions

RepositoryScoreLicence
This page · shanev/skills100MIT
jscraik/Agent-Skills95Apache-2.0
jscraik/Agent-Skills90Apache-2.0

Database snapshot: 13.11.2026 · package version e8e0ae6fc46a (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100decomplect
    Review code and architecture for accidental complexity, mixed pure logic and effects, weak boundaries, and harmful coupling. Use for design reviews, architecture assessments, pre-refactor analysis, pull-request review, or questions about simplicity, functional core/imperative…
  • 100review-pr
    Review a pull request for code quality and security issues. Use when the user wants to review a PR, check PR code changes, or audit a pull request. Triggers on: "review PR", "review pull request", "check this PR", "the `review-pr` skill".
  • 82review-code
    Use to review code.
  • 86code-review
    Use when asked to review, audit, clean up or simplify code or a pull request.
  • 90uds-code-review
    Use when reviewing a PR or code change, investigating duplicated logic, or performing a requested focused refactor or cleanup.
  • 90python-code-review
    Reviews Python code for type safety, async patterns, error handling, and common mistakes. Use when reviewing .py files, checking type hints, async/await usage, or exception handling.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.