[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7ARD5QCS50T3WR1ABSEMM03":3,"skill-same:01M7ARD5QCS50T3WR1ABSEMM03":48},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":24,"commitSha":25,"skillDirectory":26,"forksCount":27,"repositoryHtmlUrl":28,"repositoryHomepageUrl":29,"ownerHtmlUrl":30,"ownerBlogUrl":31,"ownerDescription":32,"updatedAt":33,"install":34,"resources":47},"01M7ARD5QCS50T3WR1ABSEMM03","language-runtimes-interpreters-and-jits",null,"Use when building a language runtime or execution engine. Covers memory management and garbage collection (tracing, generational, reference counting, ownership), the object model, concurrency models (threads, async\u002Fawait, green threads, actors), errors and unwinding, FFI, the interpreter performance ladder, interpreter techniques worth knowing (bytecode design, dispatch, inline caching), JIT compilation (baseline and optimizing tiers, tracing, deoptimization), and the bootstrapping and trust problem.","the-vibey-project\u002Fvibey","the-vibey-project","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F329298758?v=4","01M7AJHGZ9722CTJ4JNQZVRH0Q","the vibey project","01M7AJHGZVMG2K7TGXQ6XFHVG3",5,"MIT","https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey\u002Fblob\u002Fdevelop\u002Fsrc\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fprogramming-language-development\u002Fskills\u002Flanguage-runtimes-interpreters-and-jits\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: language-runtimes-interpreters-and-jits\ndescription: \"Use when building a language runtime or execution engine. Covers memory management and garbage collection (tracing, generational, reference counting, ownership), the object model, concurrency models (threads, async\u002Fawait, green threads, actors), errors and unwinding, FFI, the interpreter performance ladder, interpreter techniques worth knowing (bytecode design, dispatch, inline caching), JIT compilation (baseline and optimizing tiers, tracing, deoptimization), and the bootstrapping and trust problem.\"\n---\n\n# Programming Language Development: Runtime Systems, Interpreters, and JITs\n\n> **Part 3 of 5** of the *Programming Language Development* reference (plugin `programming-language-development`), covering §8–§9. Sibling skills: `language-design-parsing-and-types` (§0–§4), `language-irs-optimization-and-backends` (§5–§7), `language-diagnostics-tooling-and-evolution` (§10–§14), `language-development-reference` (§15–§20). Section numbers are shared across the set; a reference written as §N → `skill` points into that sibling skill.\n>\n> **Currency:** Verified August 2026. See §17 → `language-development-reference` for the currency snapshot and what goes stale first.\n\n> **How to read this.** Reference, not tutorial. Sections are independent. Three markers:\n> - **[DURABLE]** — theory, algorithms, or a lesson every language implementation has\n>   independently learned. Does not expire.\n> - **[VERSIONED]** — depends on a specific toolchain, standard, or project's current\n>   state. Verify against its docs.\n> - **[CONTESTED]** — competent language designers disagree, publicly and permanently.\n>   Both cases given.\n>\n> **⚠️ GOTCHA** boxes mark the design mistakes that are cheap to make on day one and\n> impossible to undo on day one thousand.\n>\n> **The framing that organizes everything below: a language is a set of promises you can\n> never take back.** Syntax you can deprecate. Semantics you cannot. Every hard decision\n> in this document is really the question *\"what am I willing to be permanently\n> responsible for?\"* — and the languages people love and the languages people resent are\n> distinguished mostly by how carefully their designers answered it early.\n\n---\n\n## §8. Runtime Systems\n\n### 8.1 Memory management\n\n| Strategy | Cost | Used by |\n|---|---|---|\n| **Manual** | Zero runtime cost; UAF, leaks, double-free | C |\n| **RAII + ownership** | Zero runtime cost; compile-time complexity | C++, Rust |\n| **Reference counting** | Cheap latency, no pauses; **cycles leak**; refcount traffic is real, and atomic refcounts are expensive | Swift (ARC), CPython, Objective-C |\n| **Tracing GC** | Handles cycles; throughput good; **pauses**; needs precise root\u002Fpointer identification | Java, Go, C#, JS, Haskell |\n| **Arena\u002Fregion** | Very fast alloc, bulk free; needs a lifetime discipline | Zig allocators, compilers themselves, request-scoped servers |\n\n**Tracing GC design axes** [DURABLE]: **generational** (most objects die young — the\nsingle most valuable GC insight ever), **moving vs. non-moving** (moving enables bump\nallocation and compaction but requires precise pointer maps and read\u002Fwrite barriers),\n**concurrent\u002Fincremental** (Go's low-latency collector; ZGC and Shenandoah's sub-millisecond\npauses), and **conservative vs. precise** (Boehm scans the stack conservatively — easy to\nretrofit onto C, but can retain garbage and cannot move objects).\n\n**[DURABLE] Your GC choice constrains your language design, not just your runtime.**\nPrecise GC requires the compiler to emit **stack maps** at every safepoint, which\nconstrains your calling convention, your optimizer (it must maintain the maps across\ntransformations), and your FFI (native code doesn't have maps — hence handles\u002Fpinning).\nDeciding on GC late is not really possible.\n\n### 8.2 The object model\n\nDecisions here propagate everywhere: boxed vs. unboxed values (and whether small integers\nare tagged — **NaN-boxing** is the standard trick in dynamic-language VMs, packing pointers\nand integers into the unused bit patterns of IEEE-754 doubles), object headers (type,\nGC mark bits, hash, lock word — every byte is multiplied by every object), field layout\n(declared order or optimized packing; Rust reorders by default, C does not), method\ndispatch (vtable, inline cache, hash lookup), and **hidden classes \u002F shape trees**\n(V8's mechanism for making dynamically-typed property access fast — arguably the single\nbiggest idea in modern dynamic-language performance).\n\n### 8.3 Concurrency\n\n| Model | Notes |\n|---|---|\n| OS threads + locks | Simple mapping; expensive; data races |\n| **Green threads \u002F goroutines** | M:N scheduling; **requires runtime support and growable stacks**; Go's segmented→copying stack evolution is instructive |\n| **async\u002Fawait** | No runtime threads needed; **function colouring** |\n| Actors | Isolation by construction (Erlang, Akka) |\n| CSP \u002F channels | Go, Occam |\n| Structured concurrency | Lifetimes of tasks bounded by scope. **The clear modern direction** — Kotlin, Swift, Java's virtual threads, Trio |\n| Algebraic effects | OCaml 5 — concurrency without colouring (§4.9 → `language-design-parsing-and-types`) |\n\n**[CONTESTED] Function colouring.** async\u002Fawait splits your function universe in two:\nasync functions can only be awaited by async functions, so any library that becomes async\nforces its callers to. *Against*: it fragments ecosystems (Python and Rust both have\nvisible sync\u002Fasync library splits), and it's an ad-hoc effect system with none of the\npolymorphism. *For*: it's explicit about where suspension happens, needs no runtime, works\nin `no_std` and embedded contexts, and makes cost visible. Green threads\u002Fvirtual threads\navoid colouring at the cost of requiring runtime support — which is precisely why Rust\nremoved green threads before 1.0 and Java added them in 2023.\n\n### 8.4 Errors and unwinding\n\n**Exceptions**: zero-cost when not thrown (table-driven unwinding; the tables live in\n`.eh_frame`\u002F`.gcc_except_table`), expensive when thrown. Requires unwinding-table\ngeneration in the back end and destructor\u002Fcleanup landing pads — this is a *significant*\nback-end feature, not a library concern.\n\n**Result\u002FOption types**: explicit, composable, no unwinder needed, but verbose without\nsugar (`?` in Rust, `try` in Swift\u002FZig). **[DURABLE] The ergonomics live or die on the\npropagation operator** — Go's pre-1.13 `if err != nil` verbosity is the standard cautionary\nexample.\n\n**Panics\u002Faborts** for unrecoverable errors. Decide early whether panics unwind or abort;\nit affects the ABI, FFI safety (**unwinding across an FFI boundary into C is UB unless\nboth sides agreed**), and whether destructors run.\n\n### 8.5 FFI\n\n**[DURABLE] Your C FFI is the interface to forty years of existing software, and it will\nbe used more than you expect.** The hard parts: type mapping (especially strings — length\nvs. NUL-terminated, and encoding), ownership across the boundary (who frees?), callbacks\ninto managed code (GC roots! stack maps!), thread attachment, error propagation, and\n**never letting an exception or panic escape into C**.\n\nDesign decisions worth copying: Rust's `extern \"C\"` + `#[repr(C)]` (explicit ABI opt-in\nper type and function), Zig's ability to `@cImport` C headers directly, and Swift's\ngenerated header approach. **The single best decision is making the unsafe boundary\nsyntactically visible** so it's greppable and reviewable.\n\n---\n\n## §9. Interpreters and JITs\n\n### 9.1 The performance ladder\n\n```\nAST tree-walking       1×      Easiest to write. Correct. Slow. Start here.\nBytecode + switch      3–10×   The standard baseline.\nComputed goto\u002Fthreaded 1.5–2×  over switch. Better branch prediction. GCC\u002FClang extension.\nRegister bytecode      1.2–1.5× over stack bytecode. Fewer dispatches.\nInline caching         2–10×   on dynamic dispatch. The big win for dynamic languages.\nTemplate\u002Fbaseline JIT  2–5×    over interpreter. Fast to compile, no optimization.\nOptimizing JIT         10–100× With type feedback + speculation + deopt.\nAOT + PGO              comparable to JIT for static languages, no warmup\n```\n\n### 9.2 Interpreter techniques worth knowing\n\n- **Direct threading \u002F computed goto** — replace the dispatch `switch` with a jump table\n  and a `goto *ip` at the end of each handler, giving the branch predictor one indirect\n  branch per opcode instead of one shared branch. Typically 20–50%.\n- **Superinstructions** — fuse common opcode pairs into one, cutting dispatch count.\n- **Inline caching** — cache the result of a dynamic lookup at the call site.\n  Monomorphic → polymorphic → megamorphic. **This plus hidden classes (§8.2) is why\n  JavaScript is fast.**\n- **NaN-boxing \u002F pointer tagging** — avoid allocating for small values.\n- **Register-based bytecode** — Lua's design; fewer instructions than a stack machine.\n\n### 9.3 JIT\n\n**Tiered execution** is the standard architecture: interpret first (fast start, gather\nprofile), then a baseline JIT for warm code, then an optimizing JIT for hot code, using\nthe profile to **speculate** — assume this call site is monomorphic, assume this integer\ndoesn't overflow, assume this type is stable — and **guard** each assumption, with\n**deoptimization** back to the interpreter when a guard fails.\n\n**[DURABLE] Deoptimization is the hardest part of a JIT.** You must be able to reconstruct\nthe exact interpreter state (locals, stack, PC) at any guard from optimized machine-code\nstate — which means every optimization must maintain that mapping. Get it wrong and you\nget silent wrong answers, the worst possible failure mode.\n\n**JIT-specific concerns**: W^X (memory must never be simultaneously writable and\nexecutable), icache invalidation on ARM, on-stack replacement (OSR) for long-running loops,\ncode cache management, and the fact that a JIT is a **JIT-spraying attack surface**.\n\n### 9.4 The bootstrapping and trust problem\n\nIf you write your compiler in your own language, you need an existing binary to build it —\nand **Ken Thompson's \"Reflections on Trusting Trust\" (1984)** shows a compiler can be\nbackdoored such that the backdoor survives recompilation from clean source and is invisible\nin the source. The practical answers: keep a documented bootstrap chain from a\nminimal seed (Zig cites trivial bootstrapping as a *benefit* of dropping LLVM),\n**reproducible builds**, and **diverse double-compiling** (David A. Wheeler's technique —\ncompile with two independent compilers and compare the outputs).\n","# Programming Language Development: Runtime Systems, Interpreters, and JITs\n\n> **Part 3 of 5** of the *Programming Language Development* reference (plugin `programming-language-development`), covering §8–§9. Sibling skills: `language-design-parsing-and-types` (§0–§4), `language-irs-optimization-and-backends` (§5–§7), `language-diagnostics-tooling-and-evolution` (§10–§14), `language-development-reference` (§15–§20). Section numbers are shared across the set; a reference written as §N → `skill` points into that sibling skill.\n>\n> **Currency:** Verified August 2026. See §17 → `language-development-reference` for the currency snapshot and what goes stale first.\n\n> **How to read this.** Reference, not tutorial. Sections are independent. Three markers:\n> - **[DURABLE]** — theory, algorithms, or a lesson every language implementation has\n>   independently learned. Does not expire.\n> - **[VERSIONED]** — depends on a specific toolchain, standard, or project's current\n>   state. Verify against its docs.\n> - **[CONTESTED]** — competent language designers disagree, publicly and permanently.\n>   Both cases given.\n>\n> **⚠️ GOTCHA** boxes mark the design mistakes that are cheap to make on day one and\n> impossible to undo on day one thousand.\n>\n> **The framing that organizes everything below: a language is a set of promises you can\n> never take back.** Syntax you can deprecate. Semantics you cannot. Every hard decision\n> in this document is really the question *\"what am I willing to be permanently\n> responsible for?\"* — and the languages people love and the languages people resent are\n> distinguished mostly by how carefully their designers answered it early.\n\n---\n\n## §8. Runtime Systems\n\n### 8.1 Memory management\n\n| Strategy | Cost | Used by |\n|---|---|---|\n| **Manual** | Zero runtime cost; UAF, leaks, double-free | C |\n| **RAII + ownership** | Zero runtime cost; compile-time complexity | C++, Rust |\n| **Reference counting** | Cheap latency, no pauses; **cycles leak**; refcount traffic is real, and atomic refcounts are expensive | Swift (ARC), CPython, Objective-C |\n| **Tracing GC** | Handles cycles; throughput good; **pauses**; needs precise root\u002Fpointer identification | Java, Go, C#, JS, Haskell |\n| **Arena\u002Fregion** | Very fast alloc, bulk free; needs a lifetime discipline | Zig allocators, compilers themselves, request-scoped servers |\n\n**Tracing GC design axes** [DURABLE]: **generational** (most objects die young — the\nsingle most valuable GC insight ever), **moving vs. non-moving** (moving enables bump\nallocation and compaction but requires precise pointer maps and read\u002Fwrite barriers),\n**concurrent\u002Fincremental** (Go's low-latency collector; ZGC and Shenandoah's sub-millisecond\npauses), and **conservative vs. precise** (Boehm scans the stack conservatively — easy to\nretrofit onto C, but can retain garbage and cannot move objects).\n\n**[DURABLE] Your GC choice constrains your language design, not just your runtime.**\nPrecise GC requires the compiler to emit **stack maps** at every safepoint, which\nconstrains your calling convention, your optimizer (it must maintain the maps across\ntransformations), and your FFI (native code doesn't have maps — hence handles\u002Fpinning).\nDeciding on GC late is not really possible.\n\n### 8.2 The object model\n\nDecisions here propagate everywhere: boxed vs. unboxed values (and whether small integers\nare tagged — **NaN-boxing** is the standard trick in dynamic-language VMs, packing pointers\nand integers into the unused bit patterns of IEEE-754 doubles), object headers (type,\nGC mark bits, hash, lock word — every byte is multiplied by every object), field layout\n(declared order or optimized packing; Rust reorders by default, C does not), method\ndispatch (vtable, inline cache, hash lookup), and **hidden classes \u002F shape trees**\n(V8's mechanism for making dynamically-typed property access fast — arguably the single\nbiggest idea in modern dynamic-language performance).\n\n### 8.3 Concurrency\n\n| Model | Notes |\n|---|---|\n| OS threads + locks | Simple mapping; expensive; data races |\n| **Green threads \u002F goroutines** | M:N scheduling; **requires runtime support and growable stacks**; Go's segmented→copying stack evolution is instructive |\n| **async\u002Fawait** | No runtime threads needed; **function colouring** |\n| Actors | Isolation by construction (Erlang, Akka) |\n| CSP \u002F channels | Go, Occam |\n| Structured concurrency | Lifetimes of tasks bounded by scope. **The clear modern direction** — Kotlin, Swift, Java's virtual threads, Trio |\n| Algebraic effects | OCaml 5 — concurrency without colouring (§4.9 → `language-design-parsing-and-types`) |\n\n**[CONTESTED] Function colouring.** async\u002Fawait splits your function universe in two:\nasync functions can only be awaited by async functions, so any library that becomes async\nforces its callers to. *Against*: it fragments ecosystems (Python and Rust both have\nvisible sync\u002Fasync library splits), and it's an ad-hoc effect system with none of the\npolymorphism. *For*: it's explicit about where suspension happens, needs no runtime, works\nin `no_std` and embedded contexts, and makes cost visible. Green threads\u002Fvirtual threads\navoid colouring at the cost of requiring runtime support — which is precisely why Rust\nremoved green threads before 1.0 and Java added them in 2023.\n\n### 8.4 Errors and unwinding\n\n**Exceptions**: zero-cost when not thrown (table-driven unwinding; the tables live in\n`.eh_frame`\u002F`.gcc_except_table`), expensive when thrown. Requires unwinding-table\ngeneration in the back end and destructor\u002Fcleanup landing pads — this is a *significant*\nback-end feature, not a library concern.\n\n**Result\u002FOption types**: explicit, composable, no unwinder needed, but verbose without\nsugar (`?` in Rust, `try` in Swift\u002FZig). **[DURABLE] The ergonomics live or die on the\npropagation operator** — Go's pre-1.13 `if err != nil` verbosity is the standard cautionary\nexample.\n\n**Panics\u002Faborts** for unrecoverable errors. Decide early whether panics unwind or abort;\nit affects the ABI, FFI safety (**unwinding across an FFI boundary into C is UB unless\nboth sides agreed**), and whether destructors run.\n\n### 8.5 FFI\n\n**[DURABLE] Your C FFI is the interface to forty years of existing software, and it will\nbe used more than you expect.** The hard parts: type mapping (especially strings — length\nvs. NUL-terminated, and encoding), ownership across the boundary (who frees?), callbacks\ninto managed code (GC roots! stack maps!), thread attachment, error propagation, and\n**never letting an exception or panic escape into C**.\n\nDesign decisions worth copying: Rust's `extern \"C\"` + `#[repr(C)]` (explicit ABI opt-in\nper type and function), Zig's ability to `@cImport` C headers directly, and Swift's\ngenerated header approach. **The single best decision is making the unsafe boundary\nsyntactically visible** so it's greppable and reviewable.\n\n---\n\n## §9. Interpreters and JITs\n\n### 9.1 The performance ladder\n\n```\nAST tree-walking       1×      Easiest to write. Correct. Slow. Start here.\nBytecode + switch      3–10×   The standard baseline.\nComputed goto\u002Fthreaded 1.5–2×  over switch. Better branch prediction. GCC\u002FClang extension.\nRegister bytecode      1.2–1.5× over stack bytecode. Fewer dispatches.\nInline caching         2–10×   on dynamic dispatch. The big win for dynamic languages.\nTemplate\u002Fbaseline JIT  2–5×    over interpreter. Fast to compile, no optimization.\nOptimizing JIT         10–100× With type feedback + speculation + deopt.\nAOT + PGO              comparable to JIT for static languages, no warmup\n```\n\n### 9.2 Interpreter techniques worth knowing\n\n- **Direct threading \u002F computed goto** — replace the dispatch `switch` with a jump table\n  and a `goto *ip` at the end of each handler, giving the branch predictor one indirect\n  branch per opcode instead of one shared branch. Typically 20–50%.\n- **Superinstructions** — fuse common opcode pairs into one, cutting dispatch count.\n- **Inline caching** — cache the result of a dynamic lookup at the call site.\n  Monomorphic → polymorphic → megamorphic. **This plus hidden classes (§8.2) is why\n  JavaScript is fast.**\n- **NaN-boxing \u002F pointer tagging** — avoid allocating for small values.\n- **Register-based bytecode** — Lua's design; fewer instructions than a stack machine.\n\n### 9.3 JIT\n\n**Tiered execution** is the standard architecture: interpret first (fast start, gather\nprofile), then a baseline JIT for warm code, then an optimizing JIT for hot code, using\nthe profile to **speculate** — assume this call site is monomorphic, assume this integer\ndoesn't overflow, assume this type is stable — and **guard** each assumption, with\n**deoptimization** back to the interpreter when a guard fails.\n\n**[DURABLE] Deoptimization is the hardest part of a JIT.** You must be able to reconstruct\nthe exact interpreter state (locals, stack, PC) at any guard from optimized machine-code\nstate — which means every optimization must maintain that mapping. Get it wrong and you\nget silent wrong answers, the worst possible failure mode.\n\n**JIT-specific concerns**: W^X (memory must never be simultaneously writable and\nexecutable), icache invalidation on ARM, on-stack replacement (OSR) for long-running loops,\ncode cache management, and the fact that a JIT is a **JIT-spraying attack surface**.\n\n### 9.4 The bootstrapping and trust problem\n\nIf you write your compiler in your own language, you need an existing binary to build it —\nand **Ken Thompson's \"Reflections on Trusting Trust\" (1984)** shows a compiler can be\nbackdoored such that the backdoor survives recompilation from clean source and is invisible\nin the source. The practical answers: keep a documented bootstrap chain from a\nminimal seed (Zig cites trivial bootstrapping as a *benefit* of dropping LLVM),\n**reproducible builds**, and **diverse double-compiling** (David A. Wheeler's technique —\ncompile with two independent compilers and compare the outputs).\n",{"name":5,"description":7},"develop","ae32736a1aabddabca5d2c96d665aa0ebc7d8700","src\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fprogramming-language-development\u002Fskills\u002Flanguage-runtimes-interpreters-and-jits",3,"https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey","https:\u002F\u002Fthe-vibey-project.github.io\u002Fvibey\u002F","https:\u002F\u002Fgithub.com\u002Fthe-vibey-project","https:\u002F\u002Fvibewithadam.matthewsteinberger.com","freedom for software engineers","2026-11-15 05:47:42",{"source":8,"skillName":5,"commands":35,"prompt":45,"zipAvailable":46},[36,39,42],{"tool":37,"command":38},"npx","npx skills add the-vibey-project\u002Fvibey --skill language-runtimes-interpreters-and-jits",{"tool":40,"command":41},"bunx","bunx skills add the-vibey-project\u002Fvibey --skill language-runtimes-interpreters-and-jits",{"tool":43,"command":44},"pnpm","pnpm dlx skills add the-vibey-project\u002Fvibey --skill language-runtimes-interpreters-and-jits","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey\u002Fblob\u002Fdevelop\u002Fsrc\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fprogramming-language-development\u002Fskills\u002Flanguage-runtimes-interpreters-and-jits\u002FSKILL.md",true,[],[49,56,63,70,77,84],{"skillNo":50,"name":51,"nameZh":6,"description":52,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":53,"categories":54,"keywords":55,"publishedAt":19},"01M7AT1FQJAE1FQYAMDTF490Y4","white-paper-writing","Use when writing white papers, technical reports, policy documents, thought leadership pieces, or any long-form authoritative document. Triggers on requests to write, structure, outline, or review white papers, technical reports, position papers, policy briefs, or evidence-driven arguments. Also use for B2B content marketing strategy, technical documentation requiring authority, academic-style reports, or any document that must educate while persuading. Use when someone asks \"how should I structure this\" for a long-form document.","https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey\u002Fblob\u002Fdevelop\u002Fsrc\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fwriting-craft\u002Fskills\u002Fwhite-paper-writing\u002FSKILL.md",[],[],{"skillNo":57,"name":58,"nameZh":6,"description":59,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":60,"categories":61,"keywords":62,"publishedAt":19},"01M7AT16BJRJJKK2MASXRZS76G","prose-technical-mechanics","Use when editing or writing prose at a technical\u002Fmechanical level: choosing between Anglo-Saxon and Latinate diction, placing information in topic vs stress positions, writing periodic vs cumulative sentences, handling sentence rhythm, punctuation as logic, transitions, paragraph structure, or phonesthetics. Use when someone wants to understand WHY prose works or doesn't, not just surface-level style advice. Triggers on word choice, sentence structure, emphasis, rhythm, diction, or any deep writing mechanics question.","https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey\u002Fblob\u002Fdevelop\u002Fsrc\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fwriting-craft\u002Fskills\u002Fprose-technical-mechanics\u002FSKILL.md",[],[],{"skillNo":64,"name":65,"nameZh":6,"description":66,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":67,"categories":68,"keywords":69,"publishedAt":19},"01M7AT0W9HT0ZZ9Y287NW99MR3","prose-mechanics","Use when writing, editing, or analyzing prose style; when trying to avoid generic AI-sounding writing; when applying specific prose styles such as journalistic, academic, narrative, KJV biblical, Hemingway plain, Latinate\u002FJamesian, Orwellian, Augustan, Victorian, Early Modern (Bacon, Browne, Milton), or free indirect discourse; or when coaching someone on writing voice and mechanics. Triggers on any request to improve, analyze, or write in a specific prose style, to fix \"AI-sounding\" writing, to make prose more vivid or concrete, to vary sentence rhythm, or to understand how a particular writer achieves their effects.","https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey\u002Fblob\u002Fdevelop\u002Fsrc\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fwriting-craft\u002Fskills\u002Fprose-mechanics\u002FSKILL.md",[],[],{"skillNo":71,"name":72,"nameZh":6,"description":73,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":74,"categories":75,"keywords":76,"publishedAt":19},"01M7AT0KR635JX66X2X6F3E2CP","narrative-structure","Use when structuring stories, pitches, presentations, white papers, or any persuasive narrative; analyzing the hero's journey in fiction or non-fiction; applying StoryBrand for business communication; designing narrative arcs for thought leadership; or understanding Vogler, Snyder, Propp, or Campbell frameworks. Triggers on any narrative structure, storytelling, pitch structure, StoryBrand, hero's journey, three-act structure, Freytag, Save the Cat, narrative arc, or \"how should I structure this story\u002Fpitch\u002Fpresentation\" request.","https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey\u002Fblob\u002Fdevelop\u002Fsrc\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fwriting-craft\u002Fskills\u002Fnarrative-structure\u002FSKILL.md",[],[],{"skillNo":78,"name":79,"nameZh":6,"description":80,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":81,"categories":82,"keywords":83,"publishedAt":19},"01M7AT0AKGW09NKKZDYBT8VRDE","legal-brief-writing","Use when writing legal briefs, motions, or any court filing; when analyzing judicial cognition and persuasion; when applying elite brief-writing techniques from Roberts, Clement, Kagan, Garner; or when structuring legal arguments for maximum persuasion. Also use for autistic\u002Fneurodivergent advocates who need to understand how their natural communication style maps to elite legal advocacy. Triggers on any legal writing, brief drafting, motion preparation, or legal argument structuring request.","https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey\u002Fblob\u002Fdevelop\u002Fsrc\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fwriting-craft\u002Fskills\u002Flegal-brief-writing\u002FSKILL.md",[],[],{"skillNo":85,"name":86,"nameZh":6,"description":87,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":88,"categories":89,"keywords":90,"publishedAt":19},"01M7AT00VWPS4Q8B5VEMXX9NQT","journal-publishability-criteria","Use whenever a research paper, article or preprint is being written, revised, reviewed or published, and specifically before every publication of docs\u002Fpaper.md. Covers what legitimate journals actually gate on, in order of gating — the editor's desk screen (scope, novelty, package problems), what reviewers judge (methodological soundness, claims the evidence can carry, statistical and qualitative reporting), EQUATOR reporting guidelines, the ICMJE authorship criteria, COPE's view of text recycling, the near-universal generative-AI policy (no AI author, disclosure, author responsibility), TOP 2025 transparency standards, how to verify a journal is legitimate, submitting without an institution, and a pre-submission checklist. Triggers on requests to evaluate, review, prepare or submit a paper, to judge publishability, to write a declarations or data-availability section, to disclose AI use, or to check a journal.","https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey\u002Fblob\u002Fdevelop\u002Fsrc\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fwriting-craft\u002Fskills\u002Fjournal-publishability-criteria\u002FSKILL.md",[],[]]