abstraction-laws
Law-driven abstraction protocol: evidence first, seam test, minimal algebra, executable law check.
Best use case
abstraction-laws is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Law-driven abstraction protocol: evidence first, seam test, minimal algebra, executable law check.
Teams using abstraction-laws should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/abstraction-laws/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How abstraction-laws Compares
| Feature / Agent | abstraction-laws | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Law-driven abstraction protocol: evidence first, seam test, minimal algebra, executable law check.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Abstraction Laws ## When to use - You see the same code shape in 3+ places and want to unify it. - Refactors stall on “how general should this be?”. - Parameter clusters repeat across modules. - Algebraic cues show up (map/fold/compose, identity/associativity, combine/merge ops). ## Quick start 1. Collect 3+ concrete instances (file:line). 2. Classify similarity: essential (domain) vs accidental (incidental implementation). 3. Run the seam test (can callers stay ignorant of the concrete variant?). 4. Name the abstraction by behavior. 5. If algebraic, pick the minimal construction and add one executable law check. ## Evidence table ``` | Instance | Location | Shared Shape | Variance Point | |----------|----------|--------------|----------------| | A | file:line| ... | ... | | B | file:line| ... | ... | | C | file:line| ... | ... | ``` ## Essential vs accidental - Essential: the shared shape exists because of domain rules. - Accidental: the shared shape exists because of today’s implementation. - If accidental, prefer duplication (or a smaller helper) until the domain forces convergence. ## Seam test (yes/no) 1. Can callers use the abstraction without knowing the concrete variant? 2. Can you describe it in one sentence without naming a current implementation? 3. Would a new instance fit without adding flags or branching? If any answer is “no”, extract a smaller helper or keep duplication. ## Abstraction template ``` Name: <behavioral name> Fixed parts: - ... Variance points: - ... Interface sketch: - ... Break-glass: - <next likely change that makes this harmful> ``` ## Universalist pass (only if algebraic) Map to the smallest construction: - Product (record/struct) for independent fields - Coproduct (tagged union) for alternatives - Semigroup/monoid for combine operations - Functor/applicative/monad only if you can state and test the laws ## Law check (make it executable) Pick one and implement it where the repo can run it: - Identity: `op(x, identity) == x` - Associativity: `op(a, op(b, c)) == op(op(a, b), c)` - Functor identity: `map(id, x) == x` - Functor composition: `map(f, map(g, x)) == map(compose(f, g), x)` Verification: - Prefer property tests if the repo already has them. - Otherwise add a small set of representative cases (include an edge case). ## Deliverable format - Evidence table (3+ instances). - Essential vs accidental verdict. - Proposed abstraction (fixed vs variance points) + break-glass scenario. - One executable law check. ## Activation cues - "this looks like that" - "duplicate pattern" - "shared shape" - "extract abstraction" - "monoid/fold/compose"
Related Skills
acc-check-leaky-abstractions
Detects leaky abstractions in PHP code. Identifies implementation details exposed in interfaces, concrete returns from abstract methods, framework leakage into domain, and infrastructure concerns in application layer.
abstraction-concrete-examples
Use when explaining concepts at different expertise levels, moving between abstract principles and concrete implementation, identifying edge cases by testing ideas against scenarios, designing layered documentation, decomposing complex problems into actionable steps, or bridging strategy-execution gaps. Invoke when user mentions abstraction levels, making concepts concrete, or explaining at different depths.
astro
This skill provides essential Astro framework patterns, focusing on server-side rendering (SSR), static site generation (SSG), middleware, and TypeScript best practices. It helps AI agents implement secure authentication, manage API routes, and debug rendering behaviors within Astro projects.
modal-deployment
Run Python code in the cloud with serverless containers, GPUs, and autoscaling using Modal. This skill enables agents to generate code for deploying ML models, running batch jobs, serving APIs, and scaling compute-intensive workloads.
lets-go-rss
A lightweight, full-platform RSS subscription manager that aggregates content from YouTube, Vimeo, Behance, Twitter/X, and Chinese platforms like Bilibili, Weibo, and Douyin, featuring deduplication and AI smart classification.
whisper-transcribe
Transcribes audio and video files to text using OpenAI's Whisper CLI, enhanced with contextual grounding from local markdown files for improved accuracy.
chrome-debug
This skill empowers AI agents to debug web applications and inspect browser behavior using the Chrome DevTools Protocol (CDP), offering both collaborative (headful) and automated (headless) modes.
vly-money
Generate crypto payment links for supported tokens and networks, manage access to X402 payment-protected content, and provide direct access to the vly.money wallet interface.
thor-skills
An entry point and router for AI agents to manage various THOR-related cybersecurity tasks, including running scans, analyzing logs, troubleshooting, and maintenance.
ontopo
An AI agent skill to search for Israeli restaurants, check table availability, view menus, and retrieve booking links via the Ontopo platform, acting as an unofficial interface to its data.
ux
This AI agent skill provides comprehensive guidance for creating professional and insightful User Experience (UX) designs, covering user research, information architecture, interaction design, visual guidance, and usability evaluation. It aims to produce actionable, user-centered solutions that avoid generic AI aesthetics.
grail-miner
This skill assists in setting up, managing, and optimizing Grail miners on Bittensor Subnet 81, handling tasks like environment configuration, R2 storage, model checkpoint management, and performance tuning.