secare

Detect disjoint-write violations across parallel iteration and async-task boundaries.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Secare verifies that parallel code boundaries guarantee disjoint writes, preventing subtle data races when code runs in parallel.

Core Features & Use Cases

  • Structural analysis of common parallel patterns to ensure disjoint writes
  • Guidance on safe partitioning of per-iteration outputs and aggregation outside the parallel region
  • Practical runbook templates for verifying thread-safety across languages

Quick Start

Provide a concrete example demonstrating a disjoint parallel boundary with per-slot writes.

Frequently Asked Questions about secare

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

FAQPage Schema
How do I prevent data races when using parallel iterators?

To prevent data races with parallel iterators, enforce disjoint writes by ensuring each iteration outputs to separate slots. Aggregate results outside the parallel region using structural guarantees like collect to avoid concurrent mutation.

What is a disjoint write boundary in parallel code?

A disjoint write boundary is a structural guarantee in parallel code where concurrent iterations touch only isolated state. It prevents data races by validating that no shared memory mutation occurs during the parallel execution phase.

How do I verify thread safety for async tasks and thread pools?

Verify thread safety for async tasks and thread pools by analyzing parallel boundaries for disjoint writes. Use runbook templates to validate that per-iteration outputs remain structurally separated and no concurrent mutation happens.

Does this static analysis work with Rust concurrency patterns?

Yes, this static analysis applies to Rust concurrency patterns. It examines parallel iterators, thread pools, and async tasks to validate that structural guarantees enforce disjoint writes and prevent data races.

When do I need static analysis to prevent concurrent mutation?

You need static analysis to prevent concurrent mutation when codebases use parallel iterators, thread pools, or async tasks. It identifies subtle data races by verifying that iterations touch shared state through strictly disjoint boundaries.

What is the best way to ensure safe partitioning of per-iteration outputs?

The best way to ensure safe partitioning of per-iteration outputs is to enforce disjoint writes across parallel boundaries. Use structural guarantees like collect or per-slot writes, then aggregate the partitioned data outside the parallel region.