Agent skill

Endings

by jwynia in jwynia/agent-skills

Diagnose weak endings, rushed resolutions, and arbitrary conclusions.

MITAuto-check passed

Install Endings

skills CLI
$ npx skills add jwynia/agent-skills --skill endings -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install jwynia/agent-skills endings --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/jwynia/agent-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/creative/fiction/structure/endings .claude/skills/endings && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
endings
GitHub stars
170
Token cost
~4.4k tokens
SKILL.md length
2,172 words
Files
3 (incl. scripts)
Skills in repo
111
Repo updated
First seen
Licence
MIT

At a glance

Diagnose weak endings, rushed resolutions, and arbitrary conclusions.

  • Works in 5 steps: Identify the Problem Type → Apply the Inevitable/Surprising Test → Check Character Arc Completion → …
  • Stories build well but end disappointingly
  • SKILL.md covers Core Principle, The Anatomy of an Ending, The Ending States and Ending Types Reference, plus 7 more sections
  • Runs TypeScript scripts from its folder; calls deno

What it does

Endings is an agent skill from jwynia/agent-skills. Diagnose weak endings, rushed resolutions, and arbitrary conclusions. Use when stories build well but end disappointingly, when climax feels unearned, or when resolution doesn't complete character arcs.

Its SKILL.md is about 4.4k tokens, which your agent loads only when the skill is triggered. The skill folder holds 3 other files, including scripts (for example `scripts/ending-check.ts` and `scripts/setup-payoff.ts`).

The licence is MIT.

When your agent uses it

  • Stories build well but end disappointingly
  • Climax feels unearned
  • Resolution doesnt complete character arcs

Example prompts

  • “/endings”

Requirements

  • Node.js

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Identify the Problem Type
  2. Apply the Inevitable/Surprising Test
  3. Check Character Arc Completion
  4. Check Setup/Payoff Balance
  5. Recommend Interventions

What it can do on your machine

Read from SKILL.md and the folder at commit e02ec7e. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 2 files in scripts/ (TypeScript), which the agent can run.

    Shell commands in SKILL.md call:

    • deno

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Endings loads about 4.4k tokens when it runs. Until then it costs about 53 tokens; SKILL.md has 2,172 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~53
When it runs · the whole SKILL.md, loaded when a task matches
~4.4k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from jwynia/agent-skills at commit e02ec7e, republished under its MIT licence (© jwynia). 2,172 words, ~4,444 tokens.

Download SKILL.mdSave it as .claude/skills/endings/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.
name
endings
description
Diagnose weak endings, rushed resolutions, and arbitrary conclusions. Use when stories build well but end disappointingly, when climax feels unearned, or when resolution doesn't complete character arcs.
license
MIT
metadata.author
jwynia
metadata.version
1.0
metadata.type
diagnostic
metadata.mode
diagnostic+assistive
metadata.domain
fiction

Endings: Diagnostic Skill

You diagnose ending-level problems in fiction. Your role is to identify why resolutions fail and guide writers toward endings that feel both inevitable AND surprising.

Core Principle

The best endings feel both inevitable ("of course it had to end this way") AND surprising ("I didn't see that coming").

This seeming contradiction is resolved by planting seeds throughout the story, having the ending emerge from character and theme, and subverting surface expectations while fulfilling deeper ones.

An ending that's only inevitable feels predictable. An ending that's only surprising feels arbitrary. Both together create satisfaction.


The Anatomy of an Ending

Climax

The point of highest tension where the dramatic question is answered.

Climax must:

  • Answer the central dramatic question
  • Force the protagonist's final choice
  • Result from story logic, not external intervention
  • Require the character to use what they've learned/become
Falling Action

The decompression after climax. Events settle, consequences manifest, characters process.

Falling action should:

  • Show immediate aftermath
  • Begin revealing implications
  • Let reader breathe
  • Transition toward resolution
Denouement/Resolution

The final state—where things end up.

Resolution should:

  • Provide closure on main plot
  • Address major subplots (not necessarily resolve all)
  • Show the new normal
  • End on a resonant image or moment

The Ending States

State E1: Arbitrary Ending

Symptoms: Resolution doesn't follow from what preceded it. Ending feels random or disconnected. "Where did that come from?" reaction. Seeds weren't planted.

Key Questions:

  • Does resolution follow from established character and plot?
  • Were the seeds for this ending planted earlier?
  • Is this the ending this specific story needed?
  • Could readers reread and see it coming?

Diagnostic Checklist:

  • Ending uses only elements already established
  • Character's choice at climax emerges from arc
  • Resolution matches the story's internal logic
  • On reread, foreshadowing would be visible

Interventions:

  • Identify what ending the story actually built toward
  • Plant seeds earlier for the intended ending
  • Ensure climax emerges from character growth, not plot convenience
  • Use setup-payoff tool to track what was promised

State E2: Predictable Ending

Symptoms: Reader sees ending coming from far away. No surprise at all. Genre conventions followed too literally. Surface expectations met exactly.

Key Questions:

  • Is there any element of surprise?
  • Did you follow genre expectations too closely?
  • Does surface prediction match deeper surprise?
  • Is the "how" surprising even if "what" is expected?

Diagnostic Checklist:

  • At least one element subverts expectation
  • The path to ending contains surprise
  • Genre promise fulfilled unexpectedly
  • Emotional destination reached via unexpected route

Interventions:

  • Subvert the how while fulfilling the what
  • Meet emotional expectations through unexpected means
  • Add complication that doesn't change destination but changes journey
  • Consider which genre element can be inverted

State E3: Unearned Ending

Symptoms: Deus ex machina. External force solves protagonist's problem. Resolution doesn't require protagonist's growth. Coincidence or luck saves the day.

Key Questions:

  • Did protagonist cause the resolution?
  • Were tools/growth needed for climax established earlier?
  • Did external forces solve internal problems?
  • Did the character's transformation matter to the outcome?

Diagnostic Checklist:

  • Protagonist's choice drives resolution
  • Skills/growth used at climax were shown developing
  • No new powers or allies appear to save the day
  • Character's arc completion is necessary for victory

Interventions:

  • Remove external solutions; force protagonist to solve it
  • Establish earlier whatever the character needs at climax
  • Make the character's transformation the key to resolution
  • If help arrives, ensure protagonist enabled it

State E4: Expanding Ending

Symptoms: Ending raises more questions than it answers. New mysteries introduced at resolution. Scope widens when it should narrow. Reader left confused rather than satisfied.

Key Questions:

  • Is the main dramatic question clearly answered?
  • Are new mysteries introduced too late?
  • Has scope expanded at resolution point?
  • Does ending contract toward clarity or explode into new complexity?

Diagnostic Checklist:

  • Central dramatic question definitively answered
  • No major new questions raised in final act
  • Scope narrows toward resolution
  • Loose ends are intentional, not accidental

Interventions:

  • Endings contract; they don't expand
  • Focus on resolving what was promised
  • Move new questions to earlier (or cut them)
  • Distinguish "open ending" (intentional ambiguity) from "unfinished" (accidental)

State E5: Overexplained Ending

Symptoms: Characters summarize theme. Lengthy epilogue explains everyone's fate. All threads tied too neatly. Nothing left for reader to feel or interpret.

Key Questions:

  • Are characters stating what the story meant?
  • Is there an unnecessary epilogue?
  • Are all threads tied with excessive neatness?
  • Is anything left implicit?

Diagnostic Checklist:

  • No character speeches explaining theme
  • Epilogue (if present) is brief and resonant
  • Some threads remain open or implicit
  • Final scene is action/image, not explanation

Interventions:

  • Trust readers to interpret
  • Cut theme speeches; demonstrate through action
  • End on image, not summary
  • Let some questions remain for reader contemplation

State E6: Pacing Mismatch

Symptoms: Climax works but aftermath fails. Ending feels rushed (too fast) or endless (too slow). Emotional impact lost through timing. Reader impatience or confusion in final pages.

Key Questions:

  • Is falling action too long or too short?
  • Does resolution show character's new state through action?
  • Does final image resonate?
  • Is denouement proportional to story length?

Pacing Indicators:

ProblemSymptomFix
RushedClimax → immediate endAdd falling action; let implications register
EndlessPages after tension releasedCut to essential; end on resonance
AnticlimacticResolution smaller than buildupEnsure climax matches stakes established

Interventions:

  • Rushed: Allow falling action; let reader process
  • Endless: End as quickly as possible after essential resolution
  • Sweet spot: Denouement shorter than buildup, proportional to story length

Ending Types Reference

TypeDefinitionBest ForRisks
ClosedAll major questions answeredStandalone novels, genre fictionOver-explanation, too neat
OpenSome questions left unansweredLiterary fiction, seriesFrustrating, feels unfinished
AmbiguousDeliberately unclear interpretationUnreliable narrators, philosophyUnsatisfying if arbitrary
TwistFinal revelation recontextualizesMystery, perception storiesCheap if unearned
CircularReturns to beginning, with changeCharacter arc emphasis, themeContrived if forced

Character Arc Completion

The ending must complete the character's transformation:

Arc TypeEnding RequirementTest
PositiveCharacter demonstrates new truth through actionDoes protagonist prove change through behavior?
NegativeCharacter's fall completes, consequences manifestDoes tragedy feel inevitable from character's choices?
FlatCharacter's truth vindicated, world changedDid steadfastness matter to the outcome?

Key Test: Does the protagonist at the end prove—through action, not statement—that they've changed?


Subplot Resolution Guide

Not every thread needs equal closure:

Subplot TypeResolution Needed
Main plot-connectedMust resolve, connected to climax
Character-developingShould resolve or show new state
Thematic mirrorCan be left open if theme clear
World-textureCan continue unresolved

Principle: The more space a subplot received, the more resolution it needs.


Anti-Patterns

The Deus Ex Machina

Pattern: External force solves the problem protagonist couldn't. Problem: Resolution not earned; character's journey didn't matter. Fix: Resolution must emerge from established story elements and protagonist's choices.

The Sequel Bait

Pattern: Ending exists primarily to set up next installment. Problem: This story doesn't get its own complete arc. Fix: Each story deserves satisfaction. Hook for next can exist alongside resolution.

The Epilogue Dump

Pattern: Lengthy explanation of what happened to everyone afterward. Problem: Kills pacing; removes reader's imaginative participation. Fix: End on resonant moment, not biography. Trust readers.

The Theme Speech

Pattern: Character articulates exactly what the story meant. Problem: Preachiness; treating reader as unable to interpret. Fix: Demonstrate theme through action and image, not statement.

The Perfect Resolution

Pattern: Everything works out, all threads tied, no cost or ambiguity. Problem: Feels artificial; removes the weight of the journey. Fix: Victory should cost something. Some threads can remain open.

The Nihilistic Swerve

Pattern: Dark ending that contradicts the story's emotional journey. Problem: Feels like shock value, not earned tragedy. Fix: Ending must emerge from story logic, not authorial surprise.


Genre-Specific Patterns

GenreTypical ExpectationSubversion Opportunity
RomanceCouple together (HEA/HFN)How they get there; what's sacrificed
MysteryCulprit revealedImplications of revelation; detective changed
ThrillerThreat neutralizedCost of victory; what's lost
LiteraryThematic resolutionAmbiguity; open questions
HorrorMonster defeated or prevailsPyrrhic victory; corruption persists
FantasyQuest completeChanged hero returns to changed world

Principle: Meet genre expectations at macro level; surprise at micro level.


Show full SKILL.md (858 more words)Show less

The Final Image

What the reader is left with matters disproportionately.

Strong final images:

  • Resonate with opening (showing change)
  • Embody theme visually
  • Leave emotional aftertaste
  • Compress meaning into moment

Weak final images:

  • Summary or explanation
  • Logistics of next steps
  • Excessive epilogue
  • Happy group scenes (unless earned)

Special Considerations

Series Endings

Book-in-Series:

  • Resolve this installment's conflict
  • Maintain larger series questions
  • Provide satisfaction AND anticipation
  • Avoid pure cliffhanger (some resolution)

Series Finale:

  • Resolve all major threads
  • Longer denouement acceptable
  • Pay off long-term setups
  • End character arcs definitively
The Eucatastrophe

Tolkien's term for the sudden, unexpected turn to good—disaster seems certain, then salvation arrives.

Requirements:

  • Must be set up (Chekhov's gun applies)
  • Must be earned (character's growth matters)
  • Must feel like grace, not luck
  • Must cost something

Diagnostic Process

When a writer presents ending problems:

1. Identify the Problem Type
  • Does it feel random? → E1 (Arbitrary)
  • Does it feel obvious? → E2 (Predictable)
  • Does it feel lucky? → E3 (Unearned)
  • Does it feel confusing? → E4 (Expanding)
  • Does it feel preachy? → E5 (Overexplained)
  • Does it feel rushed/draggy? → E6 (Pacing)
2. Apply the Inevitable/Surprising Test
  • Is it inevitable? (Can you trace back the seeds?)
  • Is it surprising? (Did something subvert expectation?)
  • Both needed for satisfaction
3. Check Character Arc Completion

Does the protagonist demonstrate transformation through action at the climax?

4. Check Setup/Payoff Balance

Use setup-payoff tool to verify:

  • Everything used at climax was established
  • Major setups received payoffs
  • No deus ex machina
5. Recommend Interventions

Based on identified state, provide specific fixes.


Available Tools

ending-check.ts

Analyzes ending structure and type.

bash
deno run --allow-read scripts/ending-check.ts final-chapter.txt
deno run --allow-read scripts/ending-check.ts --text "The resolution..."

Checks:

  • Ending type detection (closed, open, twist, etc.)
  • Pacing indicators
  • Resolution vs. expansion patterns
  • Theme-stating language
setup-payoff.ts

Tracks setups and payoffs across a story.

bash
deno run --allow-read scripts/setup-payoff.ts --setup "The rusty key" --file story.txt
deno run --allow-read scripts/setup-payoff.ts --analyze story.txt

Reports:

  • Unresolved setups (Chekhov's guns unfired)
  • Payoffs without setup (deus ex machina risk)
  • Setup-to-payoff distance

Integration with story-sense

story-sense StateMaps to Endings State
State 5.75: Ending Doesn't LandE1-E6 (diagnose which specifically)
When to Hand Off
  • To character-arc: When ending problems stem from incomplete transformation
  • To scene-sequencing: When pacing issues extend beyond ending
  • To genre-conventions: When genre expectations are unclear

Example Interactions

Example 1: Arbitrary Ending

Writer: "Beta readers say my ending came out of nowhere."

Your approach:

  1. Identify state: E1 (Arbitrary Ending)
  2. Ask: "What does the protagonist do at the climax? What enabled them to do it?"
  3. Check: Was that ability/knowledge established earlier?
  4. If not: identify what needs to be planted
  5. Run setup-payoff tool to find gaps
Example 2: Unearned Victory

Writer: "The cavalry arrives just in time but it feels cheap."

Your approach:

  1. Identify state: E3 (Unearned Ending)
  2. Ask: "Did the protagonist's choices enable the cavalry to arrive?"
  3. If no: protagonist must earn the help or solve it themselves
  4. Consider: what did the character learn that could be the key instead?
  5. Recommend: remove external solution or tie it to protagonist's earlier action
Example 3: Endless Denouement

Writer: "I can't figure out how to end after the climax. I keep adding scenes."

Your approach:

  1. Identify state: E6 (Pacing Mismatch - endless)
  2. Ask: "What does the reader need to see to feel satisfied?"
  3. List essentials: character's new state, central question answered, resonant image
  4. Cut everything that isn't on the list
  5. End on image, not explanation

Output Persistence

This skill writes primary output to files so work persists across sessions.

Output Discovery

Before doing any other work:

  1. Check for context/output-config.md in the project
  2. If found, look for this skill's entry
  3. If not found or no entry for this skill, ask the user first:
    • "Where should I save output from this endings session?"
    • Suggest: explorations/endings/ or a sensible location for this project
  4. Store the user's preference:
    • In context/output-config.md if context network exists
    • In .endings-output.md at project root otherwise
Primary Output

For this skill, persist:

  • Ending state diagnosis - which ending problem applies
  • Promise inventory - implicit promises the story has made
  • Resolution analysis - what must be resolved vs. left open
  • Intervention recommendations - specific techniques for the ending
Conversation vs. File
Goes to FileStays in Conversation
Ending state diagnosisClarifying questions
Promise inventoryDiscussion of options
Resolution requirementsWriter's ending choices
Backwards-trace analysisReal-time feedback
File Naming

Pattern: {story}-ending-{date}.md Example: novel-ending-2025-01-15.md

What You Do NOT Do

  • You do not write endings for writers
  • You do not choose between their ending options (guide analysis instead)
  • You do not diagnose middle-of-story issues (hand off to scene-sequencing or story-sense)
  • You do not rewrite their final chapters

Your role is diagnostic: identify the problem, explain why it's a problem, and guide toward the fix. The writer does the writing.


Key Insight

Endings are promises kept. Every story makes implicit promises about what kind of ending it will deliver—through genre, through character setup, through thematic direction. A good ending keeps those promises in an unexpected way.

The most common ending failure is the arbitrary ending: resolution that doesn't emerge from what was built. The fix is always the same: trace backward. What ending does this story actually point toward? Then either write that ending, or revise the story to point toward the ending you want.

An ending can't be fixed in isolation. It's the culmination of everything that came before.

© jwynia, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 2 other files (scripts) in skills/creative/fiction/structure/endings of jwynia/agent-skills.

  • SKILL.md
  • scripts/ending-check.ts
  • scripts/setup-payoff.ts

Open the folder on GitHubat commit e02ec7e

Compare with similar skills

Endings next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Endings compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Endings this skilljwynia/agent-skills170—~4.4kAutomated safety check: PassMIT
Implementing End To End Encryption For Messagingmukul975/Anthropic-Cybersecurity-Skills34k—~843Automated safety check: PassApache-2.0
Diagnose Gatewayopenclaw/openclaw392k—~670Automated safety check: PassMIT
Diagnosegithub/awesome-copilot40k1 repos~1kAutomated safety check: PassMIT
Dead End Pagesthedaviddias/Front-End-Checklist74k—~683Automated safety check: PassMIT
Diagnose Why Work Stoppedpaperclipai/paperclip99k—~2.8kAutomated safety check: PassMIT

Similar skills

  • Implementing End To End Encryption For Messaging

    mukul975/Anthropic-Cybersecurity-Skills

    Implements a simplified Signal Protocol-style end-to-end encryption scheme for messaging, covering key exchange, forward secrecy, and the core cryptographic components so no server or intermediary…

    34k GitHub stars~843 tokensUpdated 1 mo ago
    SecurityAuto-check passed
  • Diagnose Gateway

    openclaw/openclaw

    Diagnose Gateway, config, secrets, channels, and port failures with read-only one-liners.

    392k GitHub stars~670 tokensUpdated today
    Auto-check passed
  • Diagnose

    github/awesome-copilot

    Official

    Perform a systematic diagnostic scan of an AI workflow across 5 quality dimensions — prompt quality, context efficiency, tool health, architecture fitness, and safety — producing a scored report…

    40k GitHub starsUsed in 1 repo~1k tokens
    Agent WorkflowsAuto-check passed
  • Dead End Pages

    thedaviddias/Front-End-Checklist

    A skill your agent uses when auditing a site's internal link graph for dead-end pages, suggesting related-content links to add to thin or standalone pages, or reviewing CMS templates that produce…

    74k GitHub stars~683 tokensUpdated 4 days ago
    Data & AnalyticsAuto-check passed
  • Diagnose Why Work Stopped

    paperclipai/paperclip

    Diagnose stalled, looping, or over-recovered Paperclip issue trees and propose a no-code product-rule plan.

    99k GitHub stars~2.8k tokensUpdated today
    Auto-check passed
  • Perform a task end-to-end when intent is set to 'perform-task-end-to-end' by checking existence of GITHUBRZPSWEAGENTAPPAPPID environment variable in the session.

    656 GitHub stars~667 tokensUpdated yesterday
    Testing & QAAuto-check passed

More from jwynia/agent-skills

All 111 skills in this repo
  • Devcontainer

    jwynia/agent-skills

    Diagnose devcontainer configuration problems and guide development environment setup.

    170 GitHub stars~1.2k tokensUpdated 7 mo ago
    Auto-check: notes
  • Frontend Design

    jwynia/agent-skills

    Create distinctive, production-grade frontend interfaces with high design quality.

    170 GitHub stars~3.2k tokensUpdated 7 mo ago
    Auto-check passed
  • Gitea Workflow

    jwynia/agent-skills

    Orchestrate agile development workflows for Gitea repositories using the tea CLI.

    170 GitHub stars~3.8k tokensUpdated 7 mo ago
    Auto-check passed
  • Godot Asset Generator

    jwynia/agent-skills

    Generate game assets using AI image generation APIs (DALL-E, Replicate, fal.ai) and prepare them for Godot.

    170 GitHub stars~3.8k tokensUpdated 7 mo ago
    Auto-check passed
  • Mastra Hono

    jwynia/agent-skills

    Develop AI agents, tools, and workflows with Mastra v1 Beta and Hono servers.

    170 GitHub stars~2.9k tokensUpdated 7 mo ago
    Auto-check passed
  • PPTX Generator

    jwynia/agent-skills

    Create and manipulate PowerPoint PPTX files programmatically.

    170 GitHub stars~3.1k tokensUpdated 7 mo ago
    Auto-check passed

Questions about Endings

What does Endings do?

Diagnose weak endings, rushed resolutions, and arbitrary conclusions. Endings is an agent skill from jwynia/agent-skills. Diagnose weak endings, rushed resolutions, and arbitrary conclusions.

When should I use Endings?

Endings fits situations like: stories build well but end disappointingly; climax feels unearned; resolution doesnt complete character arcs.

How do I install Endings in Claude Code?

Run `npx skills add jwynia/agent-skills --skill endings -a claude-code`. Or copy the skill folder (skills/creative/fiction/structure/endings in jwynia/agent-skills) into .claude/skills/endings in your project. Claude Code loads it when a task matches its description.

How do I install Endings in Codex?

Run `npx skills add jwynia/agent-skills --skill endings -a codex`. Or copy the skill folder (skills/creative/fiction/structure/endings in jwynia/agent-skills) into .agents/skills/endings in your project. Codex loads it when a task matches its description.

Can I use Endings in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add jwynia/agent-skills --skill endings -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/endings, .gemini/skills/endings, .github/skills/endings and .opencode/skills/endings in your project.

What does Endings need to run?

Going by SKILL.md and its folder, Endings needs TypeScript for the scripts in its folder and the command-line tools its instructions call (deno). Our summary lists: Node.js.

Does Endings access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Endings safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Endings use?

Endings is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Endings use?

About 4.4k tokens (SKILL.md is roughly 18k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Endings?

Skills that share tags, products or a category with Endings: Implementing End To End Encryption For Messaging (mukul975/Anthropic-Cybersecurity-Skills, 34k stars), Diagnose Gateway (openclaw/openclaw, 392k stars), Diagnose (github/awesome-copilot, 40k stars) and Dead End Pages (thedaviddias/Front-End-Checklist, 74k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Endings?

jwynia (a GitHub user) maintains it in jwynia/agent-skills, which has 170 GitHub stars. The repository holds 111 skills in this directory. The repository was last updated on February 24, 2026.

Source: jwynia/agent-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.