Skip to content
Back to search

claude-skills

SkillWorks with Claude CodeGitHub

Claude skills I'm experimenting with. Please review carefully before use.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/honnibal--claude-skills/badge.svg)](/listings/honnibal--claude-skills)

HTML

<a href="/listings/honnibal--claude-skills"><img src="/api/listings/honnibal--claude-skills/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 150 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # claude-skills
  2. Reusable [Claude Code](https://docs.anthropic.com/en/docs/claude-code) slash
  3. command skills. To install a skill, copy it to `~/.claude/commands/` (rename
  4. from `.md.txt` to `.md`).
  5. The skills and parts of the project documentation were produced semi-automatically
  6. using Claude Code. You can read more about the general thinking behind these skills
  7. on [my blog](https://honnibal.dev).
  8. ## Skills
  9. All skills accept an optional argument to scope the work to specific files or
  10. directories. If no argument is given, they work through the project or ask you
  11. to choose a starting scope.
  12. The skills are set to `disable-model-invocation: true` by default. This means
  13. installing them shouldn't pollute your context. You can change this if you want
  14. the model to invoke them automatically.
  15. ### `tighten-types.md.txt`
  16. Systematically review Python source files and tighten type annotations.
  17. Works through a prioritised checklist: missing class attribute annotations,
  18. vague `Any` types replaced with concrete library types, structured dicts
  19. promoted to Pydantic models or `TypedDict`, `@overload` signatures for
  20. narrowable unions, redundant in-body annotations fixed at the root cause, and
  21. style modernisation (`Optional[X]` → `X | None`, etc.).
  22. ```
  23. /tighten-types src/mypackage/core.py
  24. ```
  25. ### `contract-docstrings.md.txt`
  26. Write docstrings that document each function's **contract** --- what it requires
  27. of callers, what it guarantees, and how it fails. Analyses four dimensions:
  28. input invariants (preconditions beyond the type signature), errors raised on
  29. violation (explicit checks vs. implicit crashes vs. silent wrong results),
  30. errors from external state (filesystem, network, databases), and silenced errors
  31. (broad `except` blocks, `.get()` defaults, `suppress()`). Produces a structured
  32. `Contract:` section with `Preconditions:`, `Raises:`, and `Silences:`
  33. subsections.
  34. ```
  35. /contract-docstrings src/mypackage/pipeline.py
  36. ```
  37. ### `hypothesis-tests.md.txt`
  38. Generate property-based tests using [Hypothesis](https://hypothesis.readthedocs.io/).
  39. Reads production code, designs input strategies in `tests/strategies.py` that
  40. model the valid search-space for each function (encoding constraints rather than
  41. filtering), then writes minimal, behaviour-focused tests. Tests target core
  42. contracts --- roundtrips, idempotence, invariant preservation, equivalence to
  43. reference implementations --- rather than structural trivia or reimplementations
  44. of the function under test.
  45. ```
  46. /hypothesis-tests src/mypackage/scoring.py
  47. ```
  48. ### `mutation-testing.md.txt`
  49. Assess test suite strength by introducing deliberate bugs (mutations) one at a
  50. time and checking whether any test catches each one. Mutations are chosen from a
  51. catalogue (delete side effects, negate conditions, change boundaries, hardcode
  52. returns, remove guards, swap operators, modify defaults, swap argument order).
  53. Each mutation is applied, tests are run, and the mutation is reverted. Produces
  54. a summary table with mutation score, uncaught gaps, diagnostic quality ratings,
  55. and recommended tests. Optionally implements missing tests for survived
  56. mutations.
  57. ```
  58. /mutation-testing src/mypackage/
  59. ```
  60. ### `pre-mortem.md.txt`
  61. Imagine future bug post-mortems for the codebase. Reads production code and
  62. identifies fragile areas --- implicit ordering dependencies, shared mutable
  63. state, stringly-typed contracts, baked-in data assumptions, coincidental
  64. correctness, non-atomic operations, invisible invariants, load-bearing defaults,
  65. implicit resource lifecycles, and version-coupled assumptions. Writes realistic
  66. incident reports (severity, cause, why it broke, how it was caught, hardening
  67. suggestions) for bugs that haven't happened yet but plausibly could from
  68. reasonable future edits. Outputs a `PRE-MORTEM.md` report.
  69. ```
  70. /pre-mortem src/mypackage/
  71. ```
  72. ### `stub-package.md.txt`
  73. Generate a condensed structural overview of a Python package or module ---
  74. signatures, imports, class attributes, and docstrings only, with function bodies
  75. replaced by `...`. Uses `stub_package.py` (included in this repo) to parse
  76. source with `ast` and emit a compact representation. Supports `--no-docstrings`
  77. for a more compact view and `--no-private` to show only public API.
  78. ```
  79. /stub-package src/mypackage/
  80. ```
  81. ### `try-except.md.txt`
  82. Audit `try/except` blocks for overly broad scope, by-catch risk, and catches of
  83. built-in exceptions that should be conditional checks. Evaluates whether
  84. try/except is the right mechanism (external state and validation-as-parsing vs.
  85. local value checks), whether the try block is minimally scoped, whether the
  86. except clause is too broad, and whether the handler masks failure. Tightens each
  87. block so the `try` covers only the operation that can actually raise the
  88. expected exception.
  89. ```
  90. /try-except src/mypackage/pipeline.py
  91. ```
  92. ## Why `.md.txt` instead of `.md`?
  93. **Skill files are served with a `.md.txt` extension intentionally.** A Claude
  94. Code skill is a markdown document that gets injected into the LLM's prompt
  95. verbatim. Markdown can contain HTML comments (`<!-- ... -->`) that are invisible
  96. when rendered by GitHub but are still present in the raw text --- and therefore
  97. still processed by the model. A malicious skill could embed hidden instructions
  98. that you would never see when previewing the file on GitHub.
  99. **Skill files are maximum privilege remote code execution.** Claude Code operates
  100. with broad access to your machine --- your filesystem, your shell, your git
  101. credentials, your environment variables. A skill that says "helpful refactoring
  102. assistant" in its visible text could contain a hidden HTML comment telling the
  103. model to exfiltrate files, install packages, or modify code in ways you didn't
  104. ask for.
  105. By shipping files as `.md.txt`, GitHub will render them as plain text rather
  106. than as formatted markdown, allowing you to see the content in full.
  107. **Before installing any skill from this repo (or anywhere else):**
  108. 1. Read the **raw** file contents. Do not trust a rendered markdown preview.
  109. 2. Look for HTML comments, invisible unicode characters, or instructions that
  110. don't match the stated purpose.
  111. 3. Understand that once installed, the skill's full text is handed to an LLM
  112. that can execute arbitrary commands on your behalf.
  113. ## License
  114. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.