$ loading_
Create Mononoke server-side hooks with split diffs and tests.
The material indicates a prompt/document-only open-source skill with no required secrets, no declared remote endpoints, and no direct local execution or data-access capability, so the overall risk is low. The main caveat is that it helps produce server-side hook code and production enablement guidance, so any resulting implementation should be reviewed separately before deployment.
The material explicitly states that no keys or environment variables are required; it does not ask for API keys, tokens, or account credentials, so credential exposure and abuse risk appears low.
No remote endpoints are declared, and the system flags it as prompt-only; based on the material, it does not appear to send user data to external services.
The skill is described as guidance for creating a Mononoke server-side hook and reading reference documents; it appears to be a writing/process aid rather than an executable tool, and the material does not show it launching local processes, running scripts, or invoking system capabilities.
No permission to read or write local files, repositories, or other resources is declared; while the README mentions several relative-path reference documents, that is descriptive content and does not by itself grant data-access capability.
Positive signals include a GitHub-hosted open-source repository and the system's open-source flag, which improve auditability; however, this appears to be a skill within a larger repo, community adoption is shown as 0 stars, the license is undeclared, and maintenance status is unknown, so source trust is moderate and should be verified before use.
Copy the install command and let the AI configure it · recommended for beginners
Please install the "write-hook" skill from askskill: 1. Download https://raw.githubusercontent.com/facebook/sapling/main/eden/mononoke/.llms/skills/write-hook/SKILL.md 2. Save it as ~/.claude/skills/write-hook/SKILL.md 3. Reload skills and tell me it's ready
Create a Mononoke server-side hook for the following requirement, and split the output into 3 diffs: tests, wiring, and implementation. Also include unit tests and integration tests. Requirement: block changes with empty commit messages from landing on the main branch.
A hook implementation plan split into tests, wiring, and implementation, plus unit and integration tests.
I need a Mononoke hook that checks manifests or derived data. Generate the code and tests in tests, wiring, and implementation sections, taking performance constraints into account.
A hook draft that considers performance constraints, with layered test coverage.
I already have the basic logic for a Mononoke hook. Please add unit tests and integration tests, and explain what to do next to prepare for production enablement after implementation.
Suggested test code plus guidance to review production enablement configuration next.
Developers can use it to generate the implementation framework for new Mononoke repository checks, split into tests, wiring, and implementation.
When a team has settled on hook logic but still lacks unit and integration tests, this skill helps fill in the test code and structure.
If a hook touches manifests or derived data, developers can use this skill alongside the referenced guidance to avoid overlooking performance constraints.
The document outlines how to create a Mononoke server-side hook from a user request and highlights the supporting references to consult during the process. It recommends reading the implementation guide first, checking performance constraints for hooks that touch manifests or derived data, following testing patterns for unit and integration tests, reviewing common mistakes before submission, and using the configerator setup guide to enable the hook in production.
Create a server-side Mononoke hook based on the user's request.
It is used to create a Mononoke server-side hook from a request. The output focuses on changes split into tests, wiring, and implementation, along with unit and integration tests.
The excerpt says you should read the implementation guide when creating a new hook. If the logic touches manifests or derived data, also read the performance constraints guide, and refer to testing patterns when writing tests.
The excerpt says that after implementation, you should review common mistakes and then check the configerator setup to enable the hook in production. For more details, see the source repository.
Diagnose systemd-managed EdenFS failures, restarts, health, and lifecycle timelines.
Locate Eden code components, key types, and architecture before reading files.
Learn to build EdenAPI/SLAPI endpoints with streaming and non-streaming patterns.
Run Flow type checks and fix React type errors quickly.
Validate code changes before commit and check React contribution requirements.
Fix lint, formatting, and common code issues before passing CI.
Create hook JSON files for policy enforcement and agent lifecycle automation.
Detects omitted co-changing files and C# members around your code edits.
Create a draft pull request from the current session’s code changes.
Finalize completed work by committing, pushing, and opening reviewed pull requests.
Create isolated Git worktrees safely with smart directory selection.