Claude Skills by DylanCkawalec

Write Architectural Decision Records following MADR template. Applies Definition of Done criteria, marks gaps for later completion. Use when generating ADR documents from extracted decisions.

Socratic coach for breaking down problems to fundamental truths. Use when users want to think through a problem deeply, challenge assumptions, or find innovative solutions. Triggers on requests like "help me think through this", "let's break this down", "what are my blind spots", "I'm stuck on a problem", "challenge my assumptions", or explicit requests for first-principles thinking.

Use when the user wants to build, extend, or debug the Python MCP bridge that exposes Mermate actions and stage flows to OpenClaw or other MCP clients.

Use when configuring, troubleshooting, or verifying the connection between Mermate and the Opseeq runtime gateway, including stage event reporting and pipeline orchestration.

Generate a persistent .nexus-map/ knowledge base that lets any AI session instantly understand a codebase's architecture, systems, dependencies, and change hotspots. Use when starting work on an unfamiliar repository, onboarding with AI-assisted context, preparing for a major refactoring initiative, or enabling reliable cold-start AI sessions across a team. Produces INDEX.md, systems.md, concept_model.json, git_forensics.md and more. Requires shell execution and Python 3.10+. For ad-hoc file ...

OODA loop decision framework (Observe, Orient, Decide, Act). Use for complex decisions, problem-solving, unclear situations, or when someone is jumping to solutions without analysis.

Forces the laziest solution that actually works, simplest, shortest, most minimal. Channels a senior dev who has seen everything: question whether the task needs to exist at all (YAGNI), reach for the standard library before custom code, native platform features before dependencies, one line before fifty. Supports intensity levels: lite, full (default), ultra. Use on ANY coding task: writing, adding, refactoring, fixing, reviewing, or designing code, and choosing libraries or dependencies. Al...

Guide for quality focused software architecture. This skill should be used when users want to write code, design architecture, analyze code, in any case that relates to software development.

Product-level UI/UX design, evaluation, and verification, emphasizing security value, economic clarity, and broad user comprehension. Use when evaluating UI quality, designing new surfaces, reviewing UX correctness, fixing broken UI, or verifying that a product meets comprehension and modernity standards. Triggers on: UI URL, route, "broken UI", "evaluate UI", "design review", "UX check", "is this usable", or any request involving user interface quality and design decisions.

Specialist for GPT-5.6 Sol, Terra, and Luna. Use for model selection, pricing, Responses API, reasoning effort, prompt caching, multi-agent tool calling, rate limits, and context-window decisions.

Core agentic infrastructure of the Mermate application — detached agent sessions (run/finalize/attach/stop), agent modes, depth scoring and role caps, Opseeq stage-event bridge with heartbeat lifecycle, run lineage and trace store, boot/health gates, and the Python MCP bridge. Use when working on server/routes/agent.js, opseeq-bridge.js, run tracking, server boot/health, mcp_service/, or cross-cutting pipeline behavior rather than a single tab.

Stage 1 tab (Simple Idea) of the Mermate pipeline — raw idea intake, AI enhancement, voice transcription, and the Idea → Markdown transition. Use when editing idea-stage UI, the enhance/copilot path, voice input, or the /api/analyze and /api/copilot/enhance endpoints.

Stage 2 tab (Markdown Spec) of the Mermate pipeline — markdown architecture spec intake (paste/upload .md/.markdown/.txt), agent planning and spec refinement, and the Markdown → Mermaid unlock. Use when editing md-stage UI, upload handling, or spec refinement behavior.

Stage 3 tab (Mermaid) of the Mermate pipeline — Mermaid source compile/render to mastered PNG/SVG diagrams, depth scoring, and the run artifacts that TLA+ and TypeScript build from. Use when editing render pipeline, mermaid-cli integration, depth scoring, diagram output, or /api/render behavior.

Stage 4 tab (TLA+) of the Mermate pipeline — formal spec generation from a mastered run, SANY parse, TLC model check, spec edit/revalidate, and the Specula engine bridge. Use when editing TLA+ generation, verification, repair, the /api/render/tla endpoints, or specula-engine integration. Formal-method decisions defer to the specification-master-agent tree.

Stage 5 tab (TypeScript) of the Mermate pipeline — TypeScript runtime generation from a verified TLA+ spec, tsc compile, tsx test harness, coverage, and the terminal progressionUpdate. Use when editing TS generation, the test harness, /api/render/ts endpoints, or TS↔TLA+ conformance. Refinement judgments defer to tla-refinement / specification-master-agent.

Master orchestrator for the Mermate application (mermaid-gpt v5.0.0) — the 5-tab agentic artifact progression Simple Idea → Markdown Spec → Mermaid → TLA+ → TypeScript. Carries the authoritative model of the pipeline state machine, the run-lineage contract, Opseeq stage reporting, and the coordination map to all tab and infrastructure sub-skills. Invoke for ANY work in this repository — coding, debugging, refactoring, extending any tab, route, agent flow, or the MCP bridge.

Forces the laziest solution that actually works, simplest, shortest, most minimal. Channels a senior dev who has seen everything: question whether the task needs to exist at all (YAGNI), reach for the standard library before custom code, native platform features before dependencies, one line before fifty. Supports intensity levels: lite, full (default), ultra. Use on ANY coding task: writing, adding, refactoring, fixing, reviewing, or designing code, and choosing libraries or dependencies. Al...

Master orchestrator for TLA+ formal specification of concurrent/distributed systems. Enforces mandatory deductive axiomatization (𝔸→ℙ→𝐋→𝐓→𝐂), discrete-state TLA+ modeling (Init, named Next actions, □Invariant, fairness), stochastic/asymptotic analysis, and refusal of unverified claims. Coordinates all TLA+ skills. Trigger on any request to write, review, improve, or reason about TLA+/PlusCal/system models/invariants/fairness/refinement or formal methods.

Modular composition of TLA+ specifications using EXTENDS INSTANCE and hiding of internal state. Use when building large specifications from smaller ones composing systems or interfaces or when controlling visibility of variables. Trigger on modular design INSTANCE EXTENDS or composing multiple components.

Mathematical foundations required for TLA+ specification. Use when the user or the agent needs clear explanations of sets functions predicates first-order logic temporal operators or the elementary mathematics that Specifying Systems assumes. Trigger on foundational math questions or when generating specs that reveal weak understanding of the underlying mathematics.

Systematic method for extracting faithful TLA+ specifications from real source code in Rust Go Erlang Python or other languages. Use when the user supplies implementation code and wants a matching formal model or when checking conformance between code and an existing spec. Trigger on code-to-spec reverse engineering or implementation-aware modeling.

Leslie Lamport’s personal workstation and external reference library for deep TLA+/PlusCal research, assumption challenging, pattern extraction, industrial stress-testing, anti-pattern detection, and expert citation. Invoke whenever the agent requires grounding in real observable examples, clarification of modeling choices, external validation of complex specification ideas, or recovery from uncertainty. This skill never rewrites or pastes examples into context; it points directly to primary ...

Writing inductive invariants safety properties liveness properties and fairness conditions in TLA+. Use when defining what must always be true what must eventually happen or how to strengthen invariants for model checking or proof. Trigger on requests for invariants temporal properties or fairness.

Bridge between ordinary programming thought and pure TLA+ via PlusCal. Use when the user wants an algorithm-style description that can be translated to TLA+ or when teaching the mapping from imperative constructs to actions and state machines. Trigger on PlusCal requests algorithm modeling or when a sequential or multi-process algorithm is easier to express first in PlusCal.

Refinement in TLA+ including refinement mappings successive refinement and proving that one specification implements another. Use when moving from a high-level specification to a lower-level one or when verifying that an implementation satisfies an abstract specification. Trigger on refinement mappings implementation proofs or stepwise refinement.

Critical evaluation judgment and review of TLA+ specifications in the style of Leslie Lamport together with practical mastery of the TLA+ Toolbox. Use when assessing the quality of a specification diagnosing problems choosing what to check next or when working with SANY TLC TLAPS configurations and model-checking strategy. Trigger on review critique judgment evaluation of a TLA+ model or Toolbox usage.

Core modeling methodology for TLA+ state machines. Use when choosing variables defining Init and Next designing actions structuring the state space or deciding abstraction level for concurrent or distributed systems. Trigger on questions about how to model a system as a state machine or how to write good actions and Next relations.

Authoritative reference and generation rules for pure TLA+ surface syntax. Use when writing or correcting TLA+ modules operators expressions modules EXTENDS INSTANCE VARIABLES Init Next Spec priming UNCHANGED fairness or any syntactic construct. Trigger on requests for correct TLA+ syntax examples or when fixing SANY errors.

Tool integration agent loops iterative repair and advanced workflows for TLA+ including SANY TLC TLAPS grammar constraints Specula-style generation and closed-loop specification agents. Use when improving generation quality with feedback when discussing model checking or when building AI agents that write and verify TLA+.