Skip to content
Back to search

ios-logos-tweak

SkillWorks with Claude CodeGitHub

Best practices for iOS jailbreak tweaks using Theos and Logos (%hook, %hookf, %new, %orig, %init). Prefer Logos and Substrate helpers (MSHookIvar) over manual hook/ivar runtime APIs. Covers firmware checks (IS_IOS_OR_NEWER vs @available vs respondsToSelector) and bracket messaging. Use when writing or reviewing .x/.xm tweak code, MobileSubstrate/libhooker hooks, swizzling, or Theos Tweak projects.

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/poomsmart--ios-logos-tweak/badge.svg)](/listings/poomsmart--ios-logos-tweak)

HTML

<a href="/listings/poomsmart--ios-logos-tweak"><img src="/api/listings/poomsmart--ios-logos-tweak/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Clone the **whole repository** (not only `SKILL.md`) into the skill folder for your tool. Replace `<repo-url>` with your Git remote.

Personal (all projects on this machine)

git clone <repo-url> ~/.cursor/skills/ios-logos-tweak      # Cursor
git clone <repo-url> ~/.claude/skills/ios-logos-tweak      # Claude Code
git clone <repo-url> ~/.agents/skills/ios-logos-tweak      # Codex / Agent Skills layout

Pick one path per tool you use. To avoid three clones, clone once and symlink:

git clone <repo-url> ~/src/ios-logos-tweak
ln -s ~/src/ios-logos-tweak ~/.cursor/skills/ios-logos-tweak
ln -s ~/src/ios-logos-tweak ~/.claude/skills/ios-logos-tweak
ln -s ~/src/ios-logos-tweak ~/.agents/skills/ios-logos-tweak

Create parent directories if needed (`mkdir -p ~/.cursor/skills` etc.).

Project (team / one repo)

git clone <repo-url> .cursor/skills/ios-logos-tweak    # Cursor
git clone <repo-url> .claude/skills/ios-logos-tweak    # Claude Code
git clone <repo-url> .agents/skills/ios-logos-tweak    # Codex

Or add as a git submodule at the same paths. Commit the skill directory so teammates get it.

Notes

- **Claude Code:** if `~/.claude/skills` did not exist when the session started, run `/reload-skills`. - **Cursor:** user skills live under `~/.cursor/skills/`; project skills under `.cursor/skills/`. - **Editors without a skills folder** (e.g. Copilot `copilot-instructions.md`, generic `AGENTS.md`): copy the body of `SKILL.md` (below the frontmatter) into your project rules, or link to this repo in those files and ask the agent to read `SKILL.md` when working on tweaks.

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.

SKILL.md · Manifest · 317 lines
  1. ---
  2. name: ios-logos-tweak
  3. description: Best practices for iOS jailbreak tweaks using Theos and Logos (%hook, %hookf, %new, %orig, %init). Prefer Logos and Substrate helpers (MSHookIvar) over manual hook/ivar runtime APIs. Covers firmware checks (IS_IOS_OR_NEWER vs @available vs respondsToSelector) and bracket messaging. Use when writing or reviewing .x/.xm tweak code, MobileSubstrate/libhooker hooks, swizzling, or Theos Tweak projects.
  4. ---
  5. # iOS Logos Tweak Best Practices
  6. ## Core rule
  7. Put hooking code in **Logos files** (`.x`, `.xm`, `.xi`) and express hooks with **Logos directives**. Let the Logos preprocessor emit `MSHookMessageEx`, `MSHookFunction`, `class_addMethod`, constructors, and class registration.
  8. Do **not** hand-write Substrate hook boilerplate in tweak source unless Logos cannot express the case (rare; see [reference.md](reference.md)).
  9. ## File layout
  10. **Default: `.x`.** Most tweaks use a single `Tweak.x` (Logos + Objective-C). Theos runs Logos on the file, then compiles the result as ObjC.
  11. | Extension | Compiles as | When to use |
  12. |-----------|-------------|-------------|
  13. | **`.x`** | Objective-C | **Default.** `%hook`, `%hookf`, `%new`, `%orig`, `%property`, blocks, and normal Foundation/UIKit code. |
  14. | **`.xm`** | Objective-C++ | Only when this **translation unit** needs C++ or Substrate’s C++ APIs (see below). |
  15. | **`.xi` / `.xmi`** | Included fragments | Rare: Logos inside `#define` macros or `#include` chains; prefer splitting into separate `.x`/`.xm` files with `extern` instead ([Theos docs](https://theos.dev/docs/logos-file-extensions)). |
  16. ### Use `.xm` when this file contains
  17. - **`MSHookIvar<T>`** or **`MSIvarHook`** (implemented as C++ templates in `<substrate.h>`).
  18. - **C++** only valid in ObjC++: `std::`, `namespace`, templates, lambdas, C++ types in hook bodies.
  19. - **`%orig`** forms that embed **block literals** in the hook implementation when your toolchain/setup requires ObjC++ for those expansions (uncommon; most hooks stay in `.x`).
  20. ### Stay on `.x` when
  21. - Hooks are plain Objective-C (even with blocks, `@autoreleasepool`, etc.).
  22. - You do not call `MSHookIvar` in that file.
  23. If only one hook file needs ivar access, keep **`Tweak.x`** and add a small **`Something.xm`** (or move just those hooks to `.xm`) rather than renaming the whole project to `.xm` without reason.
  24. Keep **interfaces and constants** in normal `.h` / `.m` when they are not hooks. Keep **all hooks** in Logos (`.x` / `.xm`, not raw `.m` with `MSHook*`).
  25. Do not `#include <substrate.h>` in Logos files; Theos/Logos adds it in generated code.
  26. ## Objective-C methods: `%hook`
  27. ```logos
  28. %hook YTPlayerViewController
  29. - (void)layoutSubviews {
  30. %orig;
  31. // tweak logic
  32. }
  33. %end
  34. ```
  35. - Match the **exact** selector signature (class vs instance `+`/`-`, types, argument names).
  36. - Call the original with `%orig` or `%orig(arg1, arg2)`; never pass `self` or `_cmd`.
  37. - If you use `%orig(...)`, pass **every** user argument (Logos fills `self`/`_cmd`).
  38. - Always close with `%end`.
  39. **Avoid:** `MSHookMessageEx`, `method_setImplementation`, `method_exchangeImplementations`, or IMP trampolines for methods Logos can hook.
  40. ## Objective-C messaging
  41. Send messages with **`[receiver message]`** / **`[receiver foo:bar]`** syntax. Do not use `objc_msgSend`, `objc_msgSendSuper`, or similar runtime send helpers for calls you can express as normal Objective-C.
  42. If a symbol is undeclared in the public SDK, add a **private header** or class/category `@interface` with the method, then call it with brackets. That keeps type checking and ARC rules; `objc_msgSend` needs manual casts, is easy to get wrong on arm64, and reads worse than idiomatic ObjC.
  43. **Avoid:** `((void (*)(id, SEL, ...))objc_msgSend)(obj, @selector(foo), arg)` when `[obj foo:arg]` (after a proper declaration) works.
  44. ## C functions: `%hookf`
  45. ```logos
  46. %hookf(BOOL, MGGetBoolAnswer, CFStringRef string) {
  47. if (CFEqual(string, CFSTR("SomeKey"))) return YES;
  48. return %orig;
  49. }
  50. ```
  51. - First argument is return type; second is the **symbol name**; rest are parameters (no implicit `self`/`_cmd`).
  52. - For private symbols, resolve at init time with **`MSFindSymbol(MSGetImageByName(...), "_symbol")`**. Pass the **image that owns the symbol** as the first argument to `MSFindSymbol`; do not pass `NULL`.
  53. ```logos
  54. %ctor {
  55. void *gestalt = MSGetImageByName("/usr/lib/libMobileGestalt.dylib");
  56. %init(MGGetBoolAnswer = MSFindSymbol(gestalt, "_MGGetBoolAnswer"));
  57. }
  58. ```
  59. - **`MSFindSymbol(NULL, name)`** searches every loaded image. That pattern is **discouraged**: some runtime modification / injection setups can crash or behave badly during global symbol lookup. Always **`MSGetImageByName("/path/to/Image.dylib")`** (framework binary path as Substrate expects) and pass that `MSImageRef` to `MSFindSymbol`.
  60. - If lookup fails, guard before `%init` (skip the group or log) rather than passing a null pointer into `%init`.
  61. **Avoid:** `MSHookFunction` + manual replacement when `%hookf` + `%init` suffices; **`MSFindSymbol(NULL, ...)`** for dynamic `%hookf` targets.
  62. ## New methods and storage: `%new` and `%property`
  63. Add methods on an existing class inside `%hook`:
  64. ```logos
  65. %hook MyTargetClass
  66. %new(v@:@)
  67. - (void)myTweak_didTap:(id)sender {
  68. // no %orig — method did not exist before
  69. }
  70. %property (nonatomic, strong) UIView *myTweak_overlay;
  71. %end
  72. ```
  73. - Use `%new` for any method that **does not exist** on the class (including helpers only your tweak calls).
  74. - Always write **`%new(typeencoding)`** with the **exact** Objective-C method type encoding (e.g. `%new(v@:)` for `- (void)foo`, `%new(v@:@)` for `- (void)foo:(id)x`, `%new(@@:)` for `- (id)bar`). Bare `%new` without parentheses makes Logos **generate** an encoding from the declaration; that extra work is unnecessary when you already know the signature.
  75. - Match the encoding to the method you declare; when unsure, compile a stub and read `@encode` / `method_getTypeEncoding`, or copy from a class dump for the same selector shape.
  76. - Use `%property` for associated state on hooked classes instead of `objc_setAssociatedObject` in every hook (unless you need fine-grained control).
  77. **Avoid:** `class_addMethod` + static C functions for tweak-only ObjC methods on hooked classes.
  78. ## Instance variables: `MSHookIvar`
  79. In **tweak dylib code** linked against Cydia Substrate (Logos `.x`/`.xm`, or `.m`/`.xm` helpers in the tweak target), read and write the target app’s **existing** ivars with **`MSHookIvar`** from `<substrate.h>` (included automatically in Logos output). Do not reimplement access with `class_getInstanceVariable`, `ivar_getOffset`, manual `((char *)self + offset)`, `object_getIvar`, or `object_setIvar` unless Substrate is unavailable.
  80. ```logos
  81. %hook SomeViewController
  82. - (void)viewDidLoad {
  83. %orig;
  84. UIView *content = MSHookIvar<UIView *>(self, "_contentView");
  85. content.hidden = NO;
  86. }
  87. %end
  88. ```
  89. Inside a hook body, the **`MSIvarHook(type, name)`** macro (Substrate) is equivalent to a typed reference for an ivar whose **name matches** the stringized token (e.g. `MSIvarHook(UIView *, _contentView)`).
  90. - Use **`.xm`** for this file if it uses **`MSHookIvar`** / **`MSIvarHook`**; otherwise keep ivar-free hooks in **`.x`**.
  91. - For **state your tweak adds**, prefer **`%property`** on the hooked class, not reading/writing foreign ivars you invent.
  92. - In targets **without** Substrate (preference bundles, standalone tools, libraries not injected into processes), use the Objective-C runtime ivar APIs or public accessors; do not assume `MSHookIvar` is linked.
  93. **Avoid:** offset hunting duplicated in every call site when the tweak already links Substrate.
  94. ## When hooks run: `%group`, `%ctor`, `%init`
  95. - Ungrouped `%hook` / `%hookf` → default group; Logos emits a constructor that calls `%init` automatically.
  96. - Use `%group` when hooks must be **conditional** or **delayed**:
  97. ```logos
  98. #import <version.h>
  99. %group iOS16
  100. %hook SomeNewClass
  101. - (void)foo { %orig; }
  102. %end
  103. %end
  104. %ctor {
  105. if (IS_IOS_OR_NEWER(iOS_16_0)) %init(iOS16);
  106. }
  107. ```
  108. - Call `%init` or `%init(GroupName)` from `%ctor` (or another function) for grouped hooks; do not rely on auto-init for grouped code.
  109. - **One `%init` per `%group` in the whole file.** Logos records initialization at preprocess time. A second `%init(ThatGroup)` anywhere (including the other branch of `if`/`else`) is a **compile error** (`re-%init of %group`). Branches do not make two inits “conditional” at runtime; both directives are still seen.
  110. **OK:** different groups, one init each:
  111. ```logos
  112. %ctor {
  113. if (IS_IOS_OR_NEWER(iOS_9_0)) {
  114. %init(iOS9);
  115. } else {
  116. %init(iOS8);
  117. }
  118. }
  119. ```
  120. **Not OK:** same group twice:
  121. ```logos
  122. %ctor {
  123. if (useLegacy) {
  124. %init(SharedHooks, Foo = objc_getClass("LegacyFoo"));
  125. } else {
  126. %init(SharedHooks, Foo = objc_getClass("ModernFoo")); // re-%init error
  127. }
  128. }
  129. ```
  130. **Fix:** use separate `%group`s, or pick the `ClassName=expr` arguments once and call **`%init(SharedHooks, Foo = chosenClass)`** a single time after computing `chosenClass` in ordinary C/ObjC.
  131. - Use `%init(ClassName = objc_getClass("Swift.Module.Class"))` for Swift/mangled or awkward class names.
  132. ## Firmware and API availability
  133. Pick **one** primary strategy per code path. Mixing `IS_IOS_OR_NEWER`, `@available`, `%group`, and `respondsToSelector` on the same feature adds noise without extra safety.
  134. ### Hook groups and private behavior: `IS_IOS_OR_NEWER`
  135. Default for **`%ctor` / `%init`**, private SpringBoard/app internals, and point-release or range checks. `#import <version.h>` (Theos `vendor/include`) and compare `kCFCoreFoundationVersionNumber`:
  136. ```objc
  137. if (IS_IOS_OR_NEWER(iOS_16_0)) { ... }
  138. if (IS_IOS_BETWEEN(iOS_14_0, iOS_14_8)) { ... }
  139. ```
  140. `@available` tracks marketing OS version and SDK availability annotations. Those do not describe private classes. A high `IPHONEOS_DEPLOYMENT_VERSION` can also **compile away** `@available` checks.
  141. If `version.h` has no constant yet, **add** `kCFCoreFoundationVersionNumber_iOS_X_Y` and keep using the macros. Do not switch the whole tweak to `@available` just because one new OS is missing from the table.
  142. ### Public SDK APIs: `@available`
  143. Use `@available(iOS 16, *)` at **call sites** for APIs the SDK marks with availability (compiler warnings, weak linking). Do not use it as the gate for Logos `%group`s of private hooks.
  144. ```objc
  145. if (@available(iOS 16, *)) {
  146. [view setPreferredFrameRateRange:...];
  147. }
  148. ```
  149. ### When the deployment floor already includes the API
  150. If the tweak only runs on iOS versions where the selector **always exists** (package minimum, or hooks live in a `%group` initialized only on that OS), **call it directly**. Do not wrap every use in `respondsToSelector:` / `instancesRespondToSelector:`.
  151. Version gating at init (`%group` + `%init` with `IS_IOS_OR_NEWER`) is enough; inside those hooks, treat the method as present.
  152. ### Optional selectors without a version table: `respondsToSelector:`
  153. Use when:
  154. - The tweak supports a **wide OS range** with **few** explicit version checks, and
  155. - A selector appears only on some releases (mid-cycle add, private API drift, optional helpers), and
  156. - You are calling across classes you do not hook (not choosing whether to install a Logos hook).
  157. Prefer **class** checks (`+[SomeClass instancesRespondToSelector:]`) when the method is on the class, not per instance.
  158. ```objc
  159. if ([obj respondsToSelector:@selector(newStyleLayout)]) {
  160. [obj newStyleLayout];
  161. } else {
  162. [obj legacyLayout];
  163. }
  164. ```
  165. ### What to avoid
  166. - `@available` in `%ctor` to decide `%init` of private/internal hook groups; use `IS_IOS_OR_NEWER` / `IS_IOS_BETWEEN`.
  167. - `respondsToSelector:` before every send when `%init(iOS16)` or the package minimum already guarantees the selector.
  168. - Stacking `respondsToSelector:`, `@available`, and `IS_IOS_OR_NEWER` on the same branch unless they guard different risks.
  169. - Using runtime checks instead of `%group` for **entire hook sets** that only apply on one OS.
  170. ## Other Logos tools (prefer over manual runtime)
  171. | Need | Logos / Substrate |
  172. |------|--------|
  173. | Runtime class reference | `%c(ClassName)` or `%c(+ClassName)` for metaclass |
  174. | Log hook calls | `%log` in a method body |
  175. | Subclass at runtime | `%subclass` + `%property` + `%c()` to allocate |
  176. | Target class private ivar | `MSHookIvar` / `MSIvarHook` in tweak code (not raw runtime offset math) |
  177. | Generator backend | `%config(generator=MobileSubstrate)` (default), `libhooker`, or `internal` |
  178. Note: `%hookf` is **not** supported with `generator=internal`. Pick the generator to match the target jailbreak environment.
  179. ## Code organization
  180. - One `%hook ClassName` block per class; multiple methods inside one block.
  181. - Split large tweaks with `%group` in separate Logos files when using [hook splitting](https://theos.dev/docs/logos-hook-splitting) (`%init` from a shared constructor); use `.x` unless that file needs `.xm` for C++/`MSHookIvar`.
  182. - Declare classes you hook in headers (`@interface`) or private headers; Logos does not replace the need for correct types at compile time.
  183. - Use `logos_interface` / empty `@interface` in `.x` when you need typed calls to `%new` APIs from plain `.m` files.
  184. ## Filter plist (`.plist`)
  185. Keep the tweak **filter plist** (e.g. `MyTweak.plist`) in the repo as **XML** (`plutil` “xml1”), not binary bplist.
  186. - **Readability:** `Bundles`, `Classes`, and `Executables` filters are easy to review in git diffs.
  187. - **Release builds:** `make package FINALPACKAGE=1` already **converts plists to binary** in the packaged `.deb`; you do not need to commit binary plists for production.
  188. To convert an existing binary plist back to XML:
  189. ```bash
  190. plutil -convert xml1 MyTweak.plist
  191. ```
  192. Commit the XML source; let Theos optimize at package time.
  193. ## Common mistakes
  194. 1. **Hooking in `.m` with Substrate** while the rest of the project uses Logos — move hooks into **`Tweak.x`** (or `.xm` only if that file needs ObjC++).
  195. 2. **Missing `%end`** or nesting `%hook` inside a method (invalid; Logos errors).
  196. 3. **Calling `%orig` in a `%new` method** — unsupported; call super or another selector explicitly if needed.
  197. 4. **Forgetting `%init` for `%group`** — hooks never run.
  198. 5. **Two `%init`s for the same `%group`** (e.g. one per `if`/`else` branch) — Logos rejects `re-%init`; use separate groups or one `%init` with computed `Class=expr` args.
  199. 6. **Duplicate hooks** for the same class/method in one group — undefined behavior; merge blocks.
  200. 7. **Using `%hookf` inside `%hook`** — `%hookf` is top-level (except inside `%group`).
  201. 8. **`objc_msgSend` instead of `[obj msg]`** — declare the API and use bracket syntax.
  202. 9. **`ivar_getOffset` / `object_getIvar` in tweak code** — use `MSHookIvar` when Substrate is linked.
  203. 10. **Bare `%new` without type encoding** — use `%new(v@:)` (etc.) matching the method signature.
  204. 11. **`MSFindSymbol(NULL, …)`** — use `MSFindSymbol(MSGetImageByName("/path/to/dylib"), "_symbol")`.
  205. 12. **Binary filter `.plist` in git** — use XML in the repo; `FINALPACKAGE=1` bplist-converts on release.
  206. 13. **`@available` to `%init` private hook groups** — use `IS_IOS_OR_NEWER` from `<version.h>`.
  207. ## Review checklist
  208. When writing or reviewing tweak code:
  209. - [ ] Hooks live in `.x`/`.xm` with `%hook` / `%hookf`, not raw `MSHook*`
  210. - [ ] New tweak methods use `%new(typeencoding)` with exact encodings; ivar-like state uses `%property` where appropriate
  211. - [ ] `%orig` usage is correct; each `%group` has exactly **one** `%init` in the file (not split across `if`/`else` for the same group)
  212. - [ ] Dynamic `%hookf` symbols resolved with **`MSGetImageByName` + `MSFindSymbol(image, …)`**, never `MSFindSymbol(NULL, …)`
  213. - [ ] Default **`Tweak.x`** unless the file uses C++ or `MSHookIvar`; do not use `.xm` “just because”
  214. - [ ] Firmware / `%group` gates use **`IS_IOS_OR_NEWER`** (or `IS_IOS_BETWEEN`); `@available` only at public SDK call sites
  215. - [ ] No redundant `respondsToSelector:` where OS floor or `%group` already guarantees the API; runtime checks only where version checks are intentionally light
  216. - [ ] No `objc_msgSend` for normal calls; use `[receiver …]` with headers for private selectors
  217. - [ ] Private ivar access in the tweak dylib uses `MSHookIvar`, not manual runtime offset/`object_getIvar` (runtime OK only in non-Substrate targets)
  218. - [ ] Filter **`.plist`** is XML in source; release binary conversion comes from **`make package FINALPACKAGE=1`**
  219. ## Additional resources
  220. - Directive details and edge cases: [reference.md](reference.md)
  221. - Official syntax: https://theos.dev/docs/logos-syntax
README.md · README · 67 lines
  1. # ios-logos-tweak
  2. Agent skill: best practices for iOS jailbreak tweaks built with [Theos](https://theos.dev) and Logos. The instructions apply to any coding assistant that can load `SKILL.md`.
  3. ## Contents
  4. | File | Purpose |
  5. |------|---------|
  6. | [SKILL.md](SKILL.md) | Main instructions (Logos, Substrate, messaging, ivars) |
  7. | [reference.md](reference.md) | Logos vs manual `MSHook*` reference |
  8. ## Usage
  9. Use when writing or reviewing tweak code: **`Tweak.x`** by default, `.xm` when needed, hooks, swizzling, Theos projects.
  10. The skill name in frontmatter is **`ios-logos-tweak`**. Keep **`reference.md`** next to **`SKILL.md`** so relative links work.
  11. | Tool | How to invoke (typical) |
  12. |------|-------------------------|
  13. | [Cursor](https://cursor.com) | Attach the skill in chat, or `@ios-logos-tweak` if your setup exposes it |
  14. | [Claude Code](https://code.claude.com) | `/ios-logos-tweak`, or let Claude match from the `description` |
  15. | [Codex](https://developers.openai.com/codex) (CLI / IDE / ChatGPT desktop) | `$ios-logos-tweak`, `/skills`, or `@` skill picker |
  16. Other assistants: paste or import `SKILL.md`, or add the repo to whatever skills/rules path they support.
  17. ## Install
  18. Clone the **whole repository** (not only `SKILL.md`) into the skill folder for your tool. Replace `<repo-url>` with your Git remote.
  19. ### Personal (all projects on this machine)
  20. ```bash
  21. git clone <repo-url> ~/.cursor/skills/ios-logos-tweak # Cursor
  22. git clone <repo-url> ~/.claude/skills/ios-logos-tweak # Claude Code
  23. git clone <repo-url> ~/.agents/skills/ios-logos-tweak # Codex / Agent Skills layout
  24. ```
  25. Pick one path per tool you use. To avoid three clones, clone once and symlink:
  26. ```bash
  27. git clone <repo-url> ~/src/ios-logos-tweak
  28. ln -s ~/src/ios-logos-tweak ~/.cursor/skills/ios-logos-tweak
  29. ln -s ~/src/ios-logos-tweak ~/.claude/skills/ios-logos-tweak
  30. ln -s ~/src/ios-logos-tweak ~/.agents/skills/ios-logos-tweak
  31. ```
  32. Create parent directories if needed (`mkdir -p ~/.cursor/skills` etc.).
  33. ### Project (team / one repo)
  34. ```bash
  35. git clone <repo-url> .cursor/skills/ios-logos-tweak # Cursor
  36. git clone <repo-url> .claude/skills/ios-logos-tweak # Claude Code
  37. git clone <repo-url> .agents/skills/ios-logos-tweak # Codex
  38. ```
  39. Or add as a git submodule at the same paths. Commit the skill directory so teammates get it.
  40. ### Notes
  41. - **Claude Code:** if `~/.claude/skills` did not exist when the session started, run `/reload-skills`.
  42. - **Cursor:** user skills live under `~/.cursor/skills/`; project skills under `.cursor/skills/`.
  43. - **Editors without a skills folder** (e.g. Copilot `copilot-instructions.md`, generic `AGENTS.md`): copy the body of `SKILL.md` (below the frontmatter) into your project rules, or link to this repo in those files and ask the agent to read `SKILL.md` when working on tweaks.
  44. ## License
  45. [MIT](LICENSE)

Ratings and comments

Sign in to rate this skill.

Sign in

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