vanixiets

Index curated reference corpora into a searchable knowledge graph via the cognee engine, then query it to ground technical writing, review, and analysis. Use when ingesting reference documents into named datasets or retrieving grounding context for tasks like drafting or reviewing a manuscript. A reference-knowledge index, explicitly not agent session memory.

Nix development conventions for flakes, derivations, modules, and code style. Use when authoring flake.nix files, writing derivations or builders, designing NixOS/nix-darwin/home-manager modules, or following nix formatting and naming conventions. For check architecture and CI integration, see preferences-nix-checks-architecture and preferences-nix-ci-cd-integration.

Approximately-verifiable, refinement-driven development for type-driven domain-driven design. Use when modeling a domain as a dependently-typed Lean 4 specification, refining/lowering it to a Rust implementation, lifting the implementation back via Charon and Aeneas to check spec<->implementation correspondence (translation validation) — mechanically when tractable, otherwise via differential testing or LLM comparison — or when generating and diffing type-system diagrams of the model and implementation to track their evolution. Mechanical on-the-nose proof is the precise ideal, not a requirement; its absence is not a failure of the method.

Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.

Algebraic data type patterns including sum types, product types, and pattern matching across languages. Load when designing type hierarchies or working with discriminated unions.

Algebraic laws including functor/monad laws and property-based testing strategies. Load when verifying algebraic properties or writing property tests.

Architectural patterns including hexagonal architecture, CQRS, and event-driven design. Load when making architectural decisions or reviewing system design.

Bounded context design including context mapping, integration patterns, and anti-corruption layers. Load when designing service boundaries or system integration.

Collaborative modeling techniques including EventStorming and Domain Storytelling. Load when facilitating discovery workshops or modeling domain processes.

Data modeling conventions including Arrow-based columnar interchange, DuckDB/DuckLake lakehouse patterns, SQLMesh transformations, and scientific data contracts. Load when designing database structures, data pipelines, cross-language analytics, or data relationships.

Distributed systems patterns including consistency models, consensus, and fault tolerance. Load when designing or debugging distributed architectures.

Functional domain modeling with DDD principles, aggregate design, smart constructors, and validation patterns. Load when designing domain types or business logic.

Event sourcing patterns including event replay, state reconstruction, and CQRS. Load when implementing event-sourced aggregates or projections.

Functional reactive programming foundations including FRP semantics, arrows, and presheaf models. Load when working with reactive streams or FRP abstractions.

Haskell development conventions covering type classes, monadic composition, and GHC extensions. Load when working with .hs files or Haskell projects.

Hypermedia-driven UI development patterns including architecture, SSE streaming, Datastar framework, CSS architecture, web components, templating, and event architecture. Load when building server-driven UIs or hypermedia applications.

Python development conventions including type safety with basedpyright, beartype, and Expression library patterns. Load when working with .py files or Python projects.

Railway-oriented programming with Result types and workflow composition for error handling. Load when designing error handling pipelines or composing fallible operations.

Rust development conventions covering domain modeling, error handling, API design, testing, performance, and type-level programming. Load when working with .rs files or Rust projects.

Category-theory and type-theory foundations for compositional, correct-by-construction software architecture. Load when designing, refactoring, reviewing, or maintaining an architecture; when reasoning about abstractions, functors, optics, or type-level constructs; when choosing or justifying an effect system, or weighing a monad-transformer stack against a capability interface discharged by handlers; when drawing event-sourcing or CQRS boundaries, or making a read model a verifiable projection; when modeling a domain's effects and coeffects; when making a component's decide/evolve (Decider) structure explicit; and when retaining a type-checkable Lean architecture spec beside a non-Rust (for example Python) implementation. Pairs with refinement-driven-development, which owns the verified Lean-to-Rust round trip.

TypeScript and Node.js development conventions including strict typing, Effect-TS patterns, and build configuration. Load when working with .ts files or Node.js projects.

Algebraic and categorical reading of data/pipeline workflow orchestrators (Dagster, Flyte) through the Build Systems à la Carte lens, plus the functional-programming and CCV discipline for the gaps the orchestrator does not enforce itself. Scoped to data-pipeline orchestration, not agent/subagent workflow DAGs. Load when mapping a Dagster asset graph to a free-term / store-interpreter structure, choosing between asset-based and task-based orchestrators, writing a lawful IO manager, reasoning about static-vs-dynamic dependencies in a pipeline, or enforcing type-safe FP discipline on Dagster or Flyte pipelines in Python.

State-machine router across a Linear-canonical board with an AFK/HIL/Manual execution-mode fork. Load when selecting an execution mode for a change, driving the agentic planning-and-development board, or routing a change between board states.

linear-cli-driven Linear-to-OpenSpec lifecycle sync overlay that binds one Linear story per OpenSpec change, supports concurrent changes across multiple Linear teams and projects in one monorepo via the openspec/linear.yaml registry, mirrors lifecycle phase to Linear state, and runs the archive-time document upsert. Load when binding a Linear story to an OpenSpec change, mirroring lifecycle phase to Linear state, or running the archive-time document upsert.

Human-facing project-management hub for the Linear Method ontology, conventions, and the workspace safety gate. Load when reasoning about project/issue structure, Linear conventions, or how OpenSpec, beads, and GitHub relate as PM layers.

Documentation conventions including structure, formatting, and maintenance practices. Load when writing or reviewing documentation.

Style and formatting conventions for code, documentation, naming, and file organization. Load when reviewing style consistency or setting up new files.

Agent team orchestration conventions for persistent multi-agent coordination via shared task lists and messaging.

Team-level orchestrator initialization for missions requiring multi-pair coordination. Establishes the strategic frame, authority hierarchy, wrapper canon, and decomposition discipline for a planning master orchestrator spawning repo-coupled AC↔WO pairs across one or more target repositories.

Complete reference for translating git interactive rebase operations to Jujutsu equivalents.

Jujutsu history cleanup patterns for rewriting and reorganizing change history.

Jujutsu workflow summary with essential paradigm shifts and decision guide. Reference for quick jj orientation.

Jujutsu version control conventions and workflow patterns.

Jujutsu atomic workflow with full operational reference for jj-based repositories.

Git history cleanup patterns for rewriting, squashing, and reorganizing commit history. Load when cleaning up branch history before merge.

Git version control conventions including atomic commits, branch workflow, and commit formatting. Load when making commits or managing branches.

Generate annotated resume command and add to atuin history for session continuation. Triggered by requests to prepare, save, or checkpoint a session for resumption, or "prepare this session for resumption".

Team-level checkpoint and handoff for missions coordinated through the master orchestrator pattern. Captures cross-cycle accumulated state across the master plus retired ACs and their WO cycles, producing a handoff payload that the next master session can resume via /meta-orchestrator-initiate. Two variants: handoff (mid-mission) and closure (mission completion).

Evaluate repository size metrics to determine whether worktrees should use sparse checkout. **Invoke only in git-native mode (no `.jj/` directory) when creating a `git worktree`, OR in jj mode when the user has explicitly requested workspace isolation by name and only to size a `jj workspace add` invocation.** `git worktree add` is hook-blocked in jj-managed repositories (see the no-worktree-in-jj-mode directive in the global CLAUDE.md); this skill does not apply to that case. In jj mode without an explicit workspace request, parallel work uses the diamond workflow's development join, not worktrees — see `~/.claude/skills/jj-version-control/tiered-ceremony.md`. Also invoke for periodic re-evaluation when a repo has grown significantly.

Compositional Continuous Verification (CCV) — theoretical anchor for system-level approximate correctness via operating-envelope-plus-regulator pairs that compose into a single closure operator. Distinct from narrow Continuous Validation (Rosenthal–Jones runtime sense). Load when designing flake checks, reasoning about coverage and traceability, proposing new regulators, auditing whether a system's verification apparatus closes, or framing the agent-side enumerate-and-audit habit on `.#checks`.