struere

Detects per-function design issues like hidden mutations and misleading signatures.

Updated May 20, 2026
One-click install
npx skills add https://github.com/watmin/datamancy.dev --skill struere
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: struere
Source: https://github.com/watmin/datamancy.dev/tree/main/struere
Command: npx skills add https://github.com/watmin/datamancy.dev --skill struere

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Struere focuses on the integrity of per-function design by flagging hidden mutations, misleading signatures, and abstractions that leak infrastructure into function boundaries, ensuring that a function's behavior remains observable through its inputs and outputs.

Core Features & Use Cases

  • Per-function contract validation: detects mutation, side effects, and non-obvious state changes that violate the function's public contract.
  • Honest abstractions: enforces that a function's signature communicates its intent and limits exposure of internal details.
  • Appropriate level engineering: assists code reviews, API design, and refactoring to maintain composability and predictability.

Quick Start

Analyze a sample function by providing its code and usage context to receive feedback on mutability, clarity, and boundary cleanliness.

Frequently Asked Questions about struere

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

FAQPage Schema
How do I detect hidden mutations and side effects in a function during code review?

To detect hidden mutations during a code review, you analyze the function's code and usage context to validate its mutability contracts, ensuring behavior remains observable strictly through inputs and outputs.

What is a misleading function signature and how does it impact API design?

A misleading function signature fails to communicate its true intent, often leaking internal infrastructure details at the boundary. Validating signatures enforces honest abstractions and maintains API composability and predictability.

How do I enforce single-responsibility and explicit mutability contracts across my modules?

You enforce single-responsibility and explicit mutability contracts by applying per-function contract validation across modules and libraries, flagging non-obvious state changes that violate the function's public design.

Can I analyze function-level code quality in a codebase where functions are the primary unit of composition?

Yes, you can analyze function-level code quality by validating type-level invariants and boundary cleanliness across typical codebases where functions are the primary composition unit, supporting refactors and design decisions.

What is the best way to identify overexposed infrastructure at function boundaries?

The best way to identify overexposed infrastructure at function boundaries is to analyze the function's code to ensure its signature limits exposure of internal details, guaranteeing the abstraction remains honest.

Why does my function design break down under load and violate its public contract?

Function design breaks down when hidden mutations and side effects violate the public contract. Analyzing per-function integrity flags these non-obvious state changes, ensuring behavior remains predictable under load.