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

Ready to run

npx skills add https://github.com/rhinoman/slop-plugin --skill slop-rhinoman

💬 Prompt for ChatGPT / Claude Chat▼

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.