slop

Reviews code functions for single-level-of-abstraction violations and layered error handling.

18|8|Updated Jun 17, 2026
One-click install
npx skills add https://github.com/PyModel/pythinker-code --skill slop-pymodel
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: slop
Source: https://github.com/PyModel/pythinker-code/tree/main/.agents/skills/agent-core-review/slop
Command: npx skills add https://github.com/PyModel/pythinker-code --skill slop-pymodel

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Code reviews often lack a consistent, objective way to judge whether a function mixes abstraction levels or handles errors inline. This Skill applies the Single Level of Abstraction (SLAP) and layered error handling lens to produce factual, reproducible review evidence instead of subjective severity opinions. ## Core Features & Use Cases - Abstraction Level Detection: Identifies statements that sit above or below a function's own layer, with file:line evidence for each violation. - Raw Quantification: Reports mechanically countable metrics such as body size, control-flow keywords, catch clauses, and named syntactic shapes without subjective classification. - Refactoring Directions: Proposes concrete moves for each foreign concern, pushing details down into value/parser/infra helpers or up into edge handlers. - Use Case: When a user asks to review whether a function does too much, the agent returns per-function level statements, check results, measurements, exemption flags, and proposed moves while leaving severity grading to a downstream rubric or human. ## Quick Start Ask the agent to review this function through the single level of abstraction and layered error handling lens.

Frequently Asked Questions about slop

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I check if a function mixes levels of abstraction?

Ask for a review through the single level of abstraction lens. The agent classifies each statement as core, down, up, or cross-cutting, then reports every place where a high-level intent line sits next to low-level mechanics with file:line evidence.

What is the single level of abstraction principle in code review?

SLAP requires every statement in a function to sit at the same conceptual level, so high-level intent is never interleaved with low-level mechanics. Error handling is treated as a separate concern that lives in a dedicated handler above or below the business logic.

When should I use this abstraction review lens?

Use it only when you explicitly want this perspective, such as asking whether a function does too much or whether errors are handled at the right layer. General reviews and refactors are intentionally left to other lenses.

Does this review assign severity grades like block or nit?

No. The agent reports only detections, raw counts, move directions, and exemption flags. Severity grades are produced downstream by a deterministic rubric, anchored examples, or a human reviewer to avoid uncalibrated labeling.

What refactoring output does the review produce?

For each foreign concern it proposes a concrete move: push down into a value, parser, or infrastructure helper, or push up into the edge handler that maps failures to status codes or messages. Each move is tied to file:line evidence.

When is mixing abstraction levels acceptable in a function?

The exemption checklist covers tiny functions, functions whose single job is the foreign concern itself, atomicity or correctness requirements, and edge-translator handlers. Exemptions are recorded as facts and used downstream to cap the grade.