skills.rest
rhinoman
rhinomanCOMMUNITY
Explore all skills by this author →
WebsiteGitHub

slop

Generate contract-driven SLOP code with typed holes and C transpilation.

Updated Dec 31, 2025
Search Tags:#verification#generate#contracts#transpile#SLOP#typed-holes
One-click install
npx skills add https://github.com/rhinoman/slop-plugin --skill slop-rhinoman
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: slop
Source: https://github.com/rhinoman/slop-plugin/tree/main/skills/slop
Command: npx skills add https://github.com/rhinoman/slop-plugin --skill slop-rhinoman

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

SLOP automates the creation of contract-driven code in the SLOP language, reducing manual boilerplate while ensuring correctness through explicit pre/post contracts and typed holes for guided generation.

Core Features & Use Cases

  • Scaffold SLOP code with @intent, @spec, @pre, @post, and @example for verification-ready development.
  • Transpile SLOP to C for performance, with support for ranges, typed holes, and arena-based memory models.
  • Reference the included documentation under references/types.md and references/patterns.md for deeper guidance.

Quick Start

Request a simple scaffold: generate a function that adds two numbers with a contract, an example, and a minimal test case.

Frequently Asked Questions about slop

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

FAQPage Schema
How do I generate contract-driven code with pre and post conditions?▼

Contract-driven code generation automates scaffolding with @intent, @spec, @pre, and @post annotations to ensure correctness through explicit pre and post contracts. You simply request a function scaffold with its contract, an example, and a minimal test case.

What are typed holes and how do they guide code generation?▼

Typed holes are placeholders used during contract-driven code generation to guide the scaffolding process. They enforce missing implementation details against @pre and @post contracts, ensuring verification-ready development before finalizing the logic.

Can I transpile SLOP code to C for better performance?▼

Yes, SLOP code can be transpiled to C for performance. The transpilation process supports ranges, typed holes, and arena-based memory models to translate high-level contract-driven specifications into optimized C code.

How does example-based verification work for contract specifications?▼

Example-based verification validates generated functions against provided @example cases to ensure they satisfy the @pre and @post contracts. This mechanism reduces manual boilerplate while guaranteeing correctness through explicit, testable examples.

Do I need any external dependencies to use the SLOP transpiler?▼

No external dependencies are required to use the SLOP generation and transpilation capabilities. The skill operates independently, relying on its internal references for patterns and type definitions to scaffold and verify contract-driven code.

Related Skills

Explore More Software Engineering Skills→
JaCha00JaCha00

deep-interview

Clarify user intent through Socratic questioning to define execution-ready specifications.

Community
Advanced
ArabelaTsoArabelaTso
142

c-cpp-to-lean4-translator

Translates C and C++ programs into equivalent, well-typed, executable Lean4 code preserving semantics.

Community
Advanced
tursodatabasetursodatabase
23.8k

differential-fuzzer

Compare Turso and SQLite results for generated SQL statements.

Official
Advanced
knowletknowlet
2

enforce-contract

Enforce Design by Contract with pre-conditions, post-conditions, and invariants.

Community
Advanced