sequi

Enforce explicit state threading through transformation chains in typed systems.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

State that follows visibly through a chain of transformations prevents the common pitfall where state leaks into the flow via globals, making reasoning about behavior difficult. Sequi enforces explicit threading of state so readers can understand how data evolves across each step.

Core Features & Use Cases

  • Visible state threading in function signatures to ensure end-to-end traceability.
  • Detection and warning about hidden coordination or global state that breaks composition.
  • Guidance for refactoring code to propagate state explicitly through chain steps.
  • Applicable to typed systems (e.g., Rust) where signatures enforce state flow across transformations.

Quick Start

Create a small chain where each function takes a state and returns a new state, then observe that the final state reflects all steps.

Frequently Asked Questions about sequi

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

FAQPage Schema
How do I enforce explicit state threading through a chain of transformations in Rust?

Explicit state threading in Rust requires each transformation function to accept a state and return a new state in its signature. This makes state evolution visible end-to-end, preventing hidden coordination across chained steps.

Why does hidden global state make reasoning about chained transformations difficult?

Hidden global state makes reasoning about chained transformations difficult because state leaks into the flow invisibly, breaking composition. It obscures how data evolves across each step and prevents readers from tracing behavior.

How do I refactor code to propagate state explicitly through chain steps?

To refactor code to propagate state explicitly, update function signatures to show input and output state, removing hidden coordination. This ensures visible traceability and proper state passing across chain steps.

Does type-safety in Rust help detect hidden coordination across chained steps?

Type-safety in Rust detects hidden coordination by requiring every transformation to thread state through its type signature. This enforces explicit state passing and warns about global state that breaks composition.

Can I use explicit state passing for any codebase requiring end-to-end visibility of state?

Yes, explicit state passing applies to any codebase requiring end-to-end visibility of state. It works in typed systems like Rust, ensuring each step's signature shows input and output state across chained transformations.