skills.rest
ElNiak
ElNiakCOMMUNITY
Explore all skills by this author →
𝕏@CyberElNiakGitHub

incremental-spec-dev

Guide incremental add-verify-iterate loops for Ivy formal specifications.

Updated Feb 25, 2026
Search Tags:#specification#verification#iterative development#formal methods#protocol testing#ivy language
One-click install
npx skills add https://github.com/ElNiak/panther-ivy-plugin --skill incremental-spec-dev
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: incremental-spec-dev
Source: https://github.com/ElNiak/panther-ivy-plugin/tree/main/plugins/panther-ivy-plugin/skills/incremental-spec-dev
Command: npx skills add https://github.com/ElNiak/panther-ivy-plugin --skill incremental-spec-dev

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill streamlines the process of developing formal specifications by guiding users through an iterative cycle of adding requirements, verifying them, and tracking progress, ensuring correctness and maintainability.

Core Features & Use Cases

  • Incremental Development: Add one requirement at a time to Ivy specifications.
  • Guided Verification Loop: Follows a structured 9-step cycle including linting, formal verification, and coverage tracking.
  • Use Case: When developing a new protocol specification in Ivy, use this skill to systematically add each RFC requirement, verify its correctness against the existing model, and ensure it's properly covered before proceeding to the next.

Quick Start

Use the incremental-spec-dev skill to add the next uncovered MUST requirement for the 'quic' protocol.

Frequently Asked Questions about incremental-spec-dev

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

FAQPage Schema
How do I iteratively build and verify formal specifications in Ivy?▼

Iterative formal specification development in Ivy is achieved by adding one requirement at a time and verifying it. This structured approach uses a 9-step cycle including linting, formal verification, and coverage tracking to ensure correctness before proceeding.

What is the best way to add RFC requirements to a protocol specification?▼

Adding RFC requirements to a protocol specification is best handled incrementally. You add one uncovered MUST requirement, verify its correctness against the existing model, and track coverage progress before moving to the next requirement.

How does incremental formal specification development track coverage progress?▼

Incremental formal specification development tracks coverage progress by enforcing quality gates throughout the development lifecycle. It ensures each requirement is properly covered and verified before allowing the addition of subsequent requirements.

Can I use this iterative verification loop for protocol testing in the Ivy language?▼

Yes, the iterative verification loop is designed for protocol testing in the Ivy language. It systematically guides you through adding requirements, running formal verification, and checking coverage to validate protocol correctness.

Why should I add only one requirement at a time when developing formal specs?▼

Adding one requirement at a time when developing formal specs ensures correctness and maintainability. It isolates verification failures, making it easier to identify formal specification errors against the existing model during the iterative cycle.

Related Skills

Explore More Software Engineering Skills→
ElNiakElNiak

ivy-lsp-walkthrough

Demonstrate formal protocol testing with Ivy LSP navigation and MCP verification.

Community
Advanced
ElNiakElNiak

workflow-reference

Translate RFC normative language into formal Ivy constructs and run verification.

Community
Advanced
ElNiakElNiak

nct-methodology

Guide the 10-step NCT workflow for formal protocol testing with Ivy.

Community
Advanced
santosomarsantosomar
1

formal-spec-generator

Routes formal specification requests to appropriate tools like TLA+ and Dafny based on input type and verification goals.

Community
Intermediate