@fprad0/skill-master-mcp 0.0.12 → 1.0.1

package/docs/skill-candidates/v0.0.12/csharp-senior-master-engineering/SKILL.md

@@ -1,32 +1,32 @@
----
-name: csharp-senior-master-engineering
-description: "Senior master C# and .NET engineering for clean, fast, secure and maintainable C# applications, ASP.NET Core services, CLIs, libraries, data access and background workers. Use when writing, organizing, refactoring, optimizing, testing or hardening C# code."
----
-
-# C# Senior Master Engineering
-
-Use this skill for C# and .NET work with production-grade expectations.
-
-## Workflow
-
-- Inspect solution structure, target framework, project files, dependency injection, configuration and test projects.
-- Keep domain logic separate from controllers, transport, persistence and infrastructure.
-- Use nullable reference types, async/await, cancellation tokens and dependency lifetimes deliberately.
-- Prefer simple services and explicit models before complex inheritance or reflection.
-- Validate with `dotnet test`, `dotnet build`, analyzers or targeted smoke execution.
-
-## Optimization Rules
-
-- Avoid sync-over-async, unnecessary allocations, repeated serialization, N+1 data access and overbroad service lifetimes.
-- Use spans, pooling or low-level optimizations only when profiling or hot path evidence supports them.
-- Keep LINQ readable and check generated database behavior when using ORMs.
-
-## Security Rules
-
-- Validate request/input boundaries, preserve auth/authorization, avoid injection and protect secrets in configuration.
-- Use parameterized queries and safe serializers.
-- Keep logging useful without exposing tokens, passwords or personal data.
-
-## Completion Standard
-
-- State behavior, validation, performance reasoning and remaining operational risks.
+---
+name: csharp-senior-master-engineering
+description: "Senior master C# and .NET engineering for clean, fast, secure and maintainable C# applications, ASP.NET Core services, CLIs, libraries, data access and background workers. Use when writing, organizing, refactoring, optimizing, testing or hardening C# code."
+---
+
+# C# Senior Master Engineering
+
+Use this skill for C# and .NET work with production-grade expectations.
+
+## Workflow
+
+- Inspect solution structure, target framework, project files, dependency injection, configuration and test projects.
+- Keep domain logic separate from controllers, transport, persistence and infrastructure.
+- Use nullable reference types, async/await, cancellation tokens and dependency lifetimes deliberately.
+- Prefer simple services and explicit models before complex inheritance or reflection.
+- Validate with `dotnet test`, `dotnet build`, analyzers or targeted smoke execution.
+
+## Optimization Rules
+
+- Avoid sync-over-async, unnecessary allocations, repeated serialization, N+1 data access and overbroad service lifetimes.
+- Use spans, pooling or low-level optimizations only when profiling or hot path evidence supports them.
+- Keep LINQ readable and check generated database behavior when using ORMs.
+
+## Security Rules
+
+- Validate request/input boundaries, preserve auth/authorization, avoid injection and protect secrets in configuration.
+- Use parameterized queries and safe serializers.
+- Keep logging useful without exposing tokens, passwords or personal data.
+
+## Completion Standard
+
+- State behavior, validation, performance reasoning and remaining operational risks.

package/docs/skill-candidates/v0.0.12/css-senior-master-engineering/SKILL.md

@@ -1,32 +1,32 @@
----
-name: css-senior-master-engineering
-description: "Senior master CSS engineering for layout, responsive behavior, design systems, performance, accessibility and maintainable styling. Use when writing, organizing, refactoring, optimizing or hardening CSS, SCSS, modules, utility styles or component styling."
----
-
-# CSS Senior Master Engineering
-
-Use this skill when styling must remain responsive, maintainable and efficient.
-
-## Workflow
-
-- Inspect the styling model: global CSS, modules, utility classes, CSS-in-JS, tokens or design system.
-- Fix layout structure before adding decorative overrides.
-- Use stable sizing constraints, logical properties, container-aware layouts and accessible focus states.
-- Keep selectors predictable and avoid specificity escalation.
-- Validate in relevant viewport sizes and interaction states.
-
-## Optimization Rules
-
-- Remove duplicate declarations, dead selectors, overbroad transitions and layout thrashing triggers.
-- Prefer CSS variables and tokens for repeated design decisions.
-- Avoid one-off hacks when a reusable component or layout primitive is clearer.
-
-## Security Rules
-
-- Avoid rendering untrusted content into CSS values.
-- Do not use remote assets or fonts without considering privacy, reliability and CSP.
-- Keep hidden content and focus order accessible.
-
-## Completion Standard
-
-- State layout impact, responsive behavior and validation evidence.
+---
+name: css-senior-master-engineering
+description: "Senior master CSS engineering for layout, responsive behavior, design systems, performance, accessibility and maintainable styling. Use when writing, organizing, refactoring, optimizing or hardening CSS, SCSS, modules, utility styles or component styling."
+---
+
+# CSS Senior Master Engineering
+
+Use this skill when styling must remain responsive, maintainable and efficient.
+
+## Workflow
+
+- Inspect the styling model: global CSS, modules, utility classes, CSS-in-JS, tokens or design system.
+- Fix layout structure before adding decorative overrides.
+- Use stable sizing constraints, logical properties, container-aware layouts and accessible focus states.
+- Keep selectors predictable and avoid specificity escalation.
+- Validate in relevant viewport sizes and interaction states.
+
+## Optimization Rules
+
+- Remove duplicate declarations, dead selectors, overbroad transitions and layout thrashing triggers.
+- Prefer CSS variables and tokens for repeated design decisions.
+- Avoid one-off hacks when a reusable component or layout primitive is clearer.
+
+## Security Rules
+
+- Avoid rendering untrusted content into CSS values.
+- Do not use remote assets or fonts without considering privacy, reliability and CSP.
+- Keep hidden content and focus order accessible.
+
+## Completion Standard
+
+- State layout impact, responsive behavior and validation evidence.

package/docs/skill-candidates/v0.0.12/go-senior-master-engineering/SKILL.md

@@ -1,32 +1,32 @@
----
-name: go-senior-master-engineering
-description: "Senior master Go engineering for clean package design, services, CLIs, concurrency, performance, security and maintainability. Use when writing, refactoring, organizing, testing or hardening Go code, APIs, workers or command-line tools."
----
-
-# Go Senior Master Engineering
-
-Use this skill for Go work that must be simple, explicit and reliable.
-
-## Workflow
-
-- Inspect `go.mod`, package boundaries, commands, tests and runtime entrypoints.
-- Keep errors wrapped with context and returned deliberately.
-- Treat `context.Context`, goroutine lifecycle, channels and cancellation as design concerns.
-- Prefer concrete types until an interface removes real coupling.
-- Validate with `go test ./...`, `go test -race` when concurrency changed, `go vet` or targeted command execution.
-
-## Optimization Rules
-
-- Avoid unnecessary allocations, reflection, global state, goroutine leaks and repeated network/database work.
-- Keep packages small and cohesive; avoid deep folder taxonomies.
-- Use benchmarks only when performance claims matter.
-
-## Security Rules
-
-- Validate external input, file paths, HTTP parameters and SQL arguments.
-- Avoid command injection, unsafe temporary files and silent auth failures.
-- Keep timeouts and cancellation explicit around external calls.
-
-## Completion Standard
-
-- Explain validation run, concurrency assumptions and operational risks.
+---
+name: go-senior-master-engineering
+description: "Senior master Go engineering for clean package design, services, CLIs, concurrency, performance, security and maintainability. Use when writing, refactoring, organizing, testing or hardening Go code, APIs, workers or command-line tools."
+---
+
+# Go Senior Master Engineering
+
+Use this skill for Go work that must be simple, explicit and reliable.
+
+## Workflow
+
+- Inspect `go.mod`, package boundaries, commands, tests and runtime entrypoints.
+- Keep errors wrapped with context and returned deliberately.
+- Treat `context.Context`, goroutine lifecycle, channels and cancellation as design concerns.
+- Prefer concrete types until an interface removes real coupling.
+- Validate with `go test ./...`, `go test -race` when concurrency changed, `go vet` or targeted command execution.
+
+## Optimization Rules
+
+- Avoid unnecessary allocations, reflection, global state, goroutine leaks and repeated network/database work.
+- Keep packages small and cohesive; avoid deep folder taxonomies.
+- Use benchmarks only when performance claims matter.
+
+## Security Rules
+
+- Validate external input, file paths, HTTP parameters and SQL arguments.
+- Avoid command injection, unsafe temporary files and silent auth failures.
+- Keep timeouts and cancellation explicit around external calls.
+
+## Completion Standard
+
+- Explain validation run, concurrency assumptions and operational risks.

package/docs/skill-candidates/v0.0.12/html-senior-master-engineering/SKILL.md

@@ -1,32 +1,32 @@
----
-name: html-senior-master-engineering
-description: "Senior master HTML engineering for semantic structure, accessibility, forms, metadata, SEO-safe markup, security and maintainability. Use when writing, organizing, refactoring, validating or hardening HTML documents, templates, components or generated markup."
----
-
-# HTML Senior Master Engineering
-
-Use this skill when markup structure determines usability, accessibility or integration quality.
-
-## Workflow
-
-- Inspect the document, template system, framework and generated output path.
-- Prefer semantic elements, clear heading order, labels, landmarks and valid nesting.
-- Keep forms explicit: labels, names, autocomplete, validation messages and error associations.
-- Preserve existing component conventions and server/client rendering assumptions.
-- Validate with browser inspection, accessibility checks, tests or generated markup review when available.
-
-## Optimization Rules
-
-- Remove redundant wrapper elements, inaccessible clickable divs and invalid nesting.
-- Keep markup readable and stable for styling and automation selectors.
-- Avoid text or layout structures that break on small screens.
-
-## Security Rules
-
-- Escape untrusted text and attributes.
-- Avoid unsafe inline script/style injection.
-- Treat links, forms and embedded content as trust boundaries.
-
-## Completion Standard
-
-- State semantic, accessibility and validation impact.
+---
+name: html-senior-master-engineering
+description: "Senior master HTML engineering for semantic structure, accessibility, forms, metadata, SEO-safe markup, security and maintainability. Use when writing, organizing, refactoring, validating or hardening HTML documents, templates, components or generated markup."
+---
+
+# HTML Senior Master Engineering
+
+Use this skill when markup structure determines usability, accessibility or integration quality.
+
+## Workflow
+
+- Inspect the document, template system, framework and generated output path.
+- Prefer semantic elements, clear heading order, labels, landmarks and valid nesting.
+- Keep forms explicit: labels, names, autocomplete, validation messages and error associations.
+- Preserve existing component conventions and server/client rendering assumptions.
+- Validate with browser inspection, accessibility checks, tests or generated markup review when available.
+
+## Optimization Rules
+
+- Remove redundant wrapper elements, inaccessible clickable divs and invalid nesting.
+- Keep markup readable and stable for styling and automation selectors.
+- Avoid text or layout structures that break on small screens.
+
+## Security Rules
+
+- Escape untrusted text and attributes.
+- Avoid unsafe inline script/style injection.
+- Treat links, forms and embedded content as trust boundaries.
+
+## Completion Standard
+
+- State semantic, accessibility and validation impact.

package/docs/skill-candidates/v0.0.12/javascript-senior-master-engineering/SKILL.md

@@ -1,32 +1,32 @@
----
-name: javascript-senior-master-engineering
-description: "Senior master JavaScript and Node.js engineering for clean runtime behavior, async correctness, performance, security and maintainability. Use when writing, organizing, refactoring, optimizing, testing or hardening JavaScript in browser, Node.js, workers or tooling."
----
-
-# JavaScript Senior Master Engineering
-
-Use this skill for JavaScript work where runtime behavior matters more than type-level design.
-
-## Workflow
-
-- Identify runtime first: browser, Node.js, worker, edge, CLI or test harness.
-- Inspect `package.json`, module mode, bundler/test setup and current style.
-- Keep async flows explicit: promises, retries, cancellation, streams, events and shutdown paths.
-- Separate domain logic from transport, DOM, filesystem, database and process boundaries.
-- Validate with existing one-shot scripts, tests, build or direct execution.
-
-## Optimization Rules
-
-- Remove avoidable promise waterfalls, duplicated serialization, repeated DOM queries, needless deep cloning and unused dependencies.
-- Avoid hidden shared mutable state unless lifecycle is clear.
-- Prefer platform APIs and existing utilities over new dependencies.
-
-## Security Rules
-
-- Avoid `eval`, unsafe HTML injection, unsafe shell composition and unvalidated JSON or URL input.
-- Keep secrets out of client bundles, logs and error surfaces.
-- Preserve CORS, auth, CSRF and permission boundaries.
-
-## Completion Standard
-
-- Report behavior, validation and compatibility risks plainly.
+---
+name: javascript-senior-master-engineering
+description: "Senior master JavaScript and Node.js engineering for clean runtime behavior, async correctness, performance, security and maintainability. Use when writing, organizing, refactoring, optimizing, testing or hardening JavaScript in browser, Node.js, workers or tooling."
+---
+
+# JavaScript Senior Master Engineering
+
+Use this skill for JavaScript work where runtime behavior matters more than type-level design.
+
+## Workflow
+
+- Identify runtime first: browser, Node.js, worker, edge, CLI or test harness.
+- Inspect `package.json`, module mode, bundler/test setup and current style.
+- Keep async flows explicit: promises, retries, cancellation, streams, events and shutdown paths.
+- Separate domain logic from transport, DOM, filesystem, database and process boundaries.
+- Validate with existing one-shot scripts, tests, build or direct execution.
+
+## Optimization Rules
+
+- Remove avoidable promise waterfalls, duplicated serialization, repeated DOM queries, needless deep cloning and unused dependencies.
+- Avoid hidden shared mutable state unless lifecycle is clear.
+- Prefer platform APIs and existing utilities over new dependencies.
+
+## Security Rules
+
+- Avoid `eval`, unsafe HTML injection, unsafe shell composition and unvalidated JSON or URL input.
+- Keep secrets out of client bundles, logs and error surfaces.
+- Preserve CORS, auth, CSRF and permission boundaries.
+
+## Completion Standard
+
+- Report behavior, validation and compatibility risks plainly.

package/docs/skill-candidates/v0.0.12/json-senior-master-engineering/SKILL.md

@@ -1,32 +1,32 @@
----
-name: json-senior-master-engineering
-description: "Senior master JSON contract engineering for schemas, API payloads, config files, events, validation, compatibility, naming and integration safety. Use when designing, refactoring, validating or hardening JSON structures and machine-readable contracts."
----
-
-# JSON Senior Master Engineering
-
-Use this skill for JSON contracts where compatibility and validation matter.
-
-## Workflow
-
-- Identify producers, consumers, versioning expectations and failure behavior.
-- Define required, optional, nullable and deprecated fields explicitly.
-- Keep names, casing, enum values, timestamps and identifiers consistent.
-- Prefer JSON Schema or runtime validation where payloads cross trust boundaries.
-- Validate with realistic examples, edge cases and backwards compatibility checks.
-
-## Optimization Rules
-
-- Remove redundant nesting, ambiguous duplicate fields and oversized payload fragments.
-- Keep config files readable and stable for diffs.
-- Avoid schemas that are stricter than the real producer or looser than the consumer can handle.
-
-## Security Rules
-
-- Reject unexpected fields when trust boundaries require it.
-- Do not accept unsafe URLs, paths, commands or serialized code through JSON.
-- Avoid leaking secrets in examples and fixtures.
-
-## Completion Standard
-
-- State compatibility impact, schema behavior and validation examples.
+---
+name: json-senior-master-engineering
+description: "Senior master JSON contract engineering for schemas, API payloads, config files, events, validation, compatibility, naming and integration safety. Use when designing, refactoring, validating or hardening JSON structures and machine-readable contracts."
+---
+
+# JSON Senior Master Engineering
+
+Use this skill for JSON contracts where compatibility and validation matter.
+
+## Workflow
+
+- Identify producers, consumers, versioning expectations and failure behavior.
+- Define required, optional, nullable and deprecated fields explicitly.
+- Keep names, casing, enum values, timestamps and identifiers consistent.
+- Prefer JSON Schema or runtime validation where payloads cross trust boundaries.
+- Validate with realistic examples, edge cases and backwards compatibility checks.
+
+## Optimization Rules
+
+- Remove redundant nesting, ambiguous duplicate fields and oversized payload fragments.
+- Keep config files readable and stable for diffs.
+- Avoid schemas that are stricter than the real producer or looser than the consumer can handle.
+
+## Security Rules
+
+- Reject unexpected fields when trust boundaries require it.
+- Do not accept unsafe URLs, paths, commands or serialized code through JSON.
+- Avoid leaking secrets in examples and fixtures.
+
+## Completion Standard
+
+- State compatibility impact, schema behavior and validation examples.

package/docs/skill-candidates/v0.0.12/prompt-budget-gate/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: prompt-budget-gate
+description: "Run a preflight budget check before sending a large prompt. Use when a task includes long context, many files, logs, screenshots, docs, tool schemas, or when the user asks for token savings."
+---
+
+# Prompt Budget Gate
+
+Use this skill before expensive prompts.
+
+## Preflight Checklist
+
+- Objective in one sentence.
+- Required output format.
+- Risk level.
+- Maximum useful answer length.
+- Required files or source URLs.
+- Context that can be referenced by path instead of pasted.
+- Logs that can be summarized.
+- Repeated instructions that belong in a skill/rule file.
+- Tools that are necessary for this turn.
+
+## Budget Recommendations
+
+- Tiny task: one paragraph answer, no extra research.
+- Normal coding task: targeted reads, concise summary, tests only when useful.
+- Research task: official sources first, short synthesis, source list.
+- Handoff task: create `.md` artifact instead of filling chat.
+- High-risk task: preserve evidence; economy is secondary.
+
+## Output Template
+
+```text
+Token budget mode: light | balanced | aggressive
+Context to keep:
+Context to drop/summarize:
+Files/sources to inspect:
+Expected answer size:
+Risk notes:
+```
+
+## Guardrails
+
+- Do not block the user for tiny tasks.
+- Do not ask for clarification when a safe assumption is obvious.
+- Do not estimate provider-specific token counts as exact unless using the provider tokenizer/API.
+- Do not store secrets or private content in summaries.

package/docs/skill-candidates/v0.0.12/python-senior-master-engineering/SKILL.md

@@ -1,32 +1,32 @@
----
-name: python-senior-master-engineering
-description: "Senior master Python engineering for clean, fast, secure and maintainable Python services, CLIs, scripts, APIs, automation, packages and data workflows. Use when writing, refactoring, organizing, typing, optimizing, testing or hardening Python code."
----
-
-# Python Senior Master Engineering
-
-Use this skill for Python work that needs production-grade clarity and safety.
-
-## Workflow
-
-- Inspect runtime version, dependency manager, entrypoints, package layout and test commands.
-- Keep imports, I/O, environment reads, file access, subprocess calls and network calls explicit.
-- Use type hints where they clarify contracts; avoid type noise inside obvious local code.
-- Prefer standard library tools unless a dependency is already established or clearly justified.
-- Validate with focused tests, direct script execution, `pytest`, type checks or package build when available.
-
-## Optimization Rules
-
-- Remove unnecessary loops, repeated I/O, repeated parsing, hidden global state and expensive work at import time.
-- Use generators, streaming or batching where data size makes it useful.
-- Keep error handling precise; never hide import/runtime failures behind broad `except`.
-
-## Security Rules
-
-- Validate untrusted input, file paths, JSON, YAML, subprocess args and database parameters.
-- Avoid shell interpolation, unsafe pickle use and logging secrets.
-- Keep permissions, tokens and environment assumptions visible.
-
-## Completion Standard
-
-- State what was validated and what runtime assumptions remain.
+---
+name: python-senior-master-engineering
+description: "Senior master Python engineering for clean, fast, secure and maintainable Python services, CLIs, scripts, APIs, automation, packages and data workflows. Use when writing, refactoring, organizing, typing, optimizing, testing or hardening Python code."
+---
+
+# Python Senior Master Engineering
+
+Use this skill for Python work that needs production-grade clarity and safety.
+
+## Workflow
+
+- Inspect runtime version, dependency manager, entrypoints, package layout and test commands.
+- Keep imports, I/O, environment reads, file access, subprocess calls and network calls explicit.
+- Use type hints where they clarify contracts; avoid type noise inside obvious local code.
+- Prefer standard library tools unless a dependency is already established or clearly justified.
+- Validate with focused tests, direct script execution, `pytest`, type checks or package build when available.
+
+## Optimization Rules
+
+- Remove unnecessary loops, repeated I/O, repeated parsing, hidden global state and expensive work at import time.
+- Use generators, streaming or batching where data size makes it useful.
+- Keep error handling precise; never hide import/runtime failures behind broad `except`.
+
+## Security Rules
+
+- Validate untrusted input, file paths, JSON, YAML, subprocess args and database parameters.
+- Avoid shell interpolation, unsafe pickle use and logging secrets.
+- Keep permissions, tokens and environment assumptions visible.
+
+## Completion Standard
+
+- State what was validated and what runtime assumptions remain.

package/docs/skill-candidates/v0.0.12/react-senior-master-engineering/SKILL.md

@@ -1,32 +1,32 @@
----
-name: react-senior-master-engineering
-description: "Senior master React engineering for component architecture, rendering performance, state design, accessibility, security and maintainability. Use when writing, organizing, refactoring, optimizing, testing or hardening React components, hooks, pages and UI systems."
----
-
-# React Senior Master Engineering
-
-Use this skill for React code that must be ergonomic, fast and predictable.
-
-## Workflow
-
-- Inspect framework, React version, routing, state model, component system and test setup.
-- Keep rendering data flow explicit: props, state, effects, server/client boundaries and async loading.
-- Prefer composition over prop drilling and avoid global state unless the shared lifecycle is real.
-- Preserve existing design-system conventions.
-- Validate with typecheck, tests, build and browser or Playwright checks when UI behavior changed.
-
-## Optimization Rules
-
-- Fix unnecessary re-renders by improving state shape, component boundaries and derived data flow before adding memoization.
-- Avoid effects for pure derivation; keep side effects idempotent and cleanup-safe.
-- Use `useDeferredValue`, transitions or framework-native data loading only when they match the user experience.
-
-## Security Rules
-
-- Avoid unsafe HTML injection and untrusted URL rendering.
-- Preserve auth, route guards, CSRF assumptions and server/client data boundaries.
-- Keep secrets out of client bundles.
-
-## Completion Standard
-
-- State UI behavior changed, accessibility impact, render/performance reasoning and validation evidence.
+---
+name: react-senior-master-engineering
+description: "Senior master React engineering for component architecture, rendering performance, state design, accessibility, security and maintainability. Use when writing, organizing, refactoring, optimizing, testing or hardening React components, hooks, pages and UI systems."
+---
+
+# React Senior Master Engineering
+
+Use this skill for React code that must be ergonomic, fast and predictable.
+
+## Workflow
+
+- Inspect framework, React version, routing, state model, component system and test setup.
+- Keep rendering data flow explicit: props, state, effects, server/client boundaries and async loading.
+- Prefer composition over prop drilling and avoid global state unless the shared lifecycle is real.
+- Preserve existing design-system conventions.
+- Validate with typecheck, tests, build and browser or Playwright checks when UI behavior changed.
+
+## Optimization Rules
+
+- Fix unnecessary re-renders by improving state shape, component boundaries and derived data flow before adding memoization.
+- Avoid effects for pure derivation; keep side effects idempotent and cleanup-safe.
+- Use `useDeferredValue`, transitions or framework-native data loading only when they match the user experience.
+
+## Security Rules
+
+- Avoid unsafe HTML injection and untrusted URL rendering.
+- Preserve auth, route guards, CSRF assumptions and server/client data boundaries.
+- Keep secrets out of client bundles.
+
+## Completion Standard
+
+- State UI behavior changed, accessibility impact, render/performance reasoning and validation evidence.

package/docs/skill-candidates/v0.0.12/ruby-senior-master-engineering/SKILL.md

@@ -1,32 +1,32 @@
----
-name: ruby-senior-master-engineering
-description: "Senior master Ruby engineering for clean, expressive, secure and maintainable Ruby scripts, gems, CLIs, services and Rails-adjacent code. Use when writing, organizing, refactoring, optimizing, testing or hardening Ruby code."
----
-
-# Ruby Senior Master Engineering
-
-Use this skill for Ruby work that needs clear behavior and runtime safety.
-
-## Workflow
-
-- Inspect Ruby version, Gemfile, entrypoints, tests and app style first.
-- Preserve idiomatic Ruby readability without hiding behavior behind excessive metaprogramming.
-- Keep side effects, filesystem access, shell calls, network calls and database calls isolated.
-- Prefer small objects or functions when they reduce coupling; avoid ceremony for small scripts.
-- Validate with existing tests, `bundle exec`, direct CLI execution or targeted smoke checks.
-
-## Optimization Rules
-
-- Remove repeated queries, repeated parsing, hidden global mutation and unnecessary gem additions.
-- Keep allocation-heavy loops and string building intentional in hot paths.
-- Match project style instead of importing patterns from other ecosystems.
-
-## Security Rules
-
-- Validate file paths, shell args, params and serialized data.
-- Avoid unsafe `eval`, unsafe YAML loading and shell interpolation.
-- Keep secrets out of logs and exceptions.
-
-## Completion Standard
-
-- Report behavior, runtime version assumptions and validation evidence.
+---
+name: ruby-senior-master-engineering
+description: "Senior master Ruby engineering for clean, expressive, secure and maintainable Ruby scripts, gems, CLIs, services and Rails-adjacent code. Use when writing, organizing, refactoring, optimizing, testing or hardening Ruby code."
+---
+
+# Ruby Senior Master Engineering
+
+Use this skill for Ruby work that needs clear behavior and runtime safety.
+
+## Workflow
+
+- Inspect Ruby version, Gemfile, entrypoints, tests and app style first.
+- Preserve idiomatic Ruby readability without hiding behavior behind excessive metaprogramming.
+- Keep side effects, filesystem access, shell calls, network calls and database calls isolated.
+- Prefer small objects or functions when they reduce coupling; avoid ceremony for small scripts.
+- Validate with existing tests, `bundle exec`, direct CLI execution or targeted smoke checks.
+
+## Optimization Rules
+
+- Remove repeated queries, repeated parsing, hidden global mutation and unnecessary gem additions.
+- Keep allocation-heavy loops and string building intentional in hot paths.
+- Match project style instead of importing patterns from other ecosystems.
+
+## Security Rules
+
+- Validate file paths, shell args, params and serialized data.
+- Avoid unsafe `eval`, unsafe YAML loading and shell interpolation.
+- Keep secrets out of logs and exceptions.
+
+## Completion Standard
+
+- Report behavior, runtime version assumptions and validation evidence.