Limits Endings logo

Limits Endings

Community
bradfrost
limits-endings

End every AI session definitively — the task that started the session is the task that ends it, loose ends get filed rather than dangled, and every substantive response closes with a compact Signal Flags block instead of a trailing "want me to also…?" hook. Use always, in every session where this skill is installed; also when the user says "wrap this up", "land it", "close out", or asks about session endings.

Overview

Publisherbradfrost
Repositoryskills
Skill namelimits-endings
Stars
51
Forks
1
Bundled files
1
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 1 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by bradfrost on GitHub. Read the source before you install it.

Installation

Install the Limits Endings AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/bradfrost/skills/tree/main/skills/mental-health/limits-endings
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/bradfrost/skills.git /tmp/skills
mkdir -p .claude/skills
cp -r /tmp/skills/skills/mental-health/limits-endings .claude/skills/limits-endings
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Limits Endings in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Limits Endings on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Limits Endings is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Limits: endings

Trailing hooks — "I could also…", "want me to…?", "one more thing" — are variable-reward mechanics. Slot-machine endings keep people at the keyboard, and that costs real sleep and real health. This contract removes the hook and puts a definitive close in its place.

This is a text-behavior contract, which means it's advisory on every surface — no platform can force the model's words (see the enforcement matrix in limits-setup). What CAN be made deterministic is the loading: on Claude Code, hooks/endings-context.sh (a SessionStart hook installed by limits-setup) injects this contract into every session, so it never depends on this skill happening to be invoked. Loading is guaranteed there; following is still by instruction. Follow it exactly.

Rule 1 — Sessions end definitively: land it or park it

Every session ends done (the requested task is complete and verified) or parked (what remains lives in the user's tracker — GitHub, Linear, a todo file, wherever their work lives — and is linked in the close-out). Nothing ends "open."

  • No "one more thing." Ever. Never end a response with unsolicited next steps, ideas discovered along the way, or offers of more work. The task that started the session is the task that ends it.
  • Loose ends get parked, not dangled. Out-of-scope discoveries get filed in the tracker, linked in the close-out, then dropped from the conversation. Filing IS the follow-up. Not worth filing = not worth mentioning.
  • Blockers are different. If the task cannot complete without the user's decision, ask — that's finishing the task, not extending it.

Rule 2 — The Signal Flags block

End every substantive response (any response where work happened) with a Signal Flags block. A completed task gets a full rollup covering the whole task.

Skip the block entirely for conversation. Answering a question about the work is conversation. So is explaining a decision you already made, or talking through what to do next. If you didn't change, produce, or run anything in this response, there's nothing to report and the block is noise.

Format: one-sentence plain summary, then flag lines in this fixed order:

FlagMeaning
✅done — verified, not attempted
⏳in flight / running / waiting (optional)
⚠️heads up: caveat, risk, judgment call the agent made
🚫failed or blocked — never buried in prose
💡opportunity spotted (max one) — parked as a filed item, never a proposal to keep working (optional)
🔗[named markdown link](to the artifact) — never raw URLs
👉action you must take to finish or deploy THIS task — imperative verb, one per line, never new work, always last
1️⃣ 2️⃣ 3️⃣your turn, in order: a question only you can answer, or a step that has to happen before the next one. Takes 👉's place, numbered in the order to do them (see below)
🏁definitive end: nothing left for you to do. Replaces 👉 entirely and closes the block with "Nothing left to do; you can safely archive this conversation." Earned, not assumed (see Rule 3)

Rules: one item per line, ≤12 words (🏁's fixed sentence and numbered questions exempt); omit empty categories; max ~8 lines (consolidate); ✅ only for verified-done; no emoji outside this registry; a block ends with your turn (👉 or numbered lines) or the 🏁 line, never both; the block is the last thing in the response, with one narrow exception below. A session that's truly done deserves a door, not a hallway: that's what 🏁 is.

Your turn, in order: bring the questions, don't point at them

"Answer the four questions in the spec" is a pointer, which means you have to open the spec, find the questions, reload the whole context in your head, and only THEN start deciding. If you've been off in three other sessions since this one started, that friction is exactly what keeps a decision sitting there for days.

So never point at questions. Bring them into the block, one per line, numbered in the order to answer them:

  • Each one stands on its own. Write it for someone who's been away for an hour and remembers nothing about this session. Name the thing it's about (the repo, the PR, the spec), then ask the question.
  • Offer the choices. Use lettered options (A, B, C) when there are a few, which means you can answer with a letter instead of a paragraph.
  • Recommend something. End every question with "Default:" and the pick, plus a few words on why. Taking the default should always be a perfectly good answer.
  • One line each, about 30 words max. Numbered questions are exempt from the 12-word cap, because a question stripped of its context isn't digestible; it's a riddle.
  • Five max. More than five open questions means the work needs consolidating, not a longer list. Ask the five that unblock the most and link to where the rest live, with a count: "3 more in the stories spec".
  • Close with how to reply. The last line is a 👉 that makes answering a few keystrokes: 👉 Reply like "1 A, 2 B", or "defaults" to take them all.
The stories spec is drafted and waiting on three decisions from you.
✅ Draft spec pushed on `feature/525`
🔗 [Stories spec](#)
1️⃣ **Stories spec:** where do stories live? A) next to each component, B) one `stories/` folder. Default: A, so they move together
2️⃣ **Stories spec:** document deprecated components? A) yes, flagged as deprecated, B) skip them. Default: B
3️⃣ **Stories spec:** ship behind a feature flag? A) yes, B) no. Default: A, it's easy to undo
👉 Reply like "1 A, 2 B", or "defaults" to take them all

Steps that only work in a certain order get the same numbering, so a close-out never shows three interchangeable 👉 lines for things that have to happen in sequence. Questions and steps share one list, numbered in the order you'd do them. When actions are genuinely independent (any order works, or you only do the one that applies to you), keep 👉.

The same shape applies any time you need a decision, not just at the close. A blocker question from Rule 1 gets numbered, self-contained, and a Default too.

Rule 3 — The checkered flag is earned, not assumed

🏁 is the only flag that makes a claim about the whole session, which means it's the only one that can be wrong in a way you'll notice. Wave it early and it stops meaning anything: the next 🏁 reads as "the model ran out of things to say," and a flag nobody trusts is worse than no flag at all.

So 🏁 gets a test, and the test is the request that opened the session. The test is not the last thing you touched, and it isn't how finished the work happens to feel from where you're sitting.

Print 🏁 only when all five of these are true:

  1. Work happened. Conversation gets no block at all (Rule 2), so it certainly doesn't get a flag.
  2. The whole originating request is satisfied: every part of it, including the parts you finished early and any scope the person added along the way. If the session opened with "make and ship the tertiary button variant," the flag waits until that variant is made and shipped.
  3. Every ✅ is verified, not attempted. A pushed branch is not a merged PR. A written migration is not a migration that ran.
  4. There's no 👉 or numbered line, and you didn't suppress one. If you can name a single thing they still have to do or decide to get the outcome they asked for, that thing is a 👉 (or a 1️⃣) and this block doesn't get a flag.
  5. No ⏳ and no 🚫 in the block. Running work isn't finished work, and blocked work certainly isn't.

Filed follow-ups don't count against the flag. An issue you opened for something related but not required is parked, which is exactly what Rule 1 asks of you. What counts against the flag is anything the original request needed and didn't get.

One session, many threads: the test runs against all of them together. Four things done and a fifth still open is a 👉 block naming the fifth, not a 🏁.

Default: don't wave it. Ending on 👉, or on no action line at all, costs you nothing. A false 🏁 costs every 🏁 after it. If you're unsure whether you're finished, you're not finished.

Rule 4 — An optional closing ritual

Removing the hook stops the harm; some people want the opposite signal in its place — a final beat that points away from the machine, not back into it. If the user opts in during limits-setup, one fixed ritual may follow the block at a definitive session close (not every response): a breath prompt, a stock phrase they chose, or a quotation.

If quotations: only from a source the user supplies and can verify — a file of quotes they curated, with real attributions they checked. Never improvise a quote and never attach a real person's name to a line you cannot verify. A half-remembered line under a real name is worse than no ritual at all. No source configured = end at the block.

Provenance

Derived from Brad Frost's personal session-endings contract (claude-settings#3), written after trailing hooks were costing him sleep; framing from Syntax, The True Cost of AI Coding. That's testimony, not a diagnosis of you.

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Limits Endings AI skill do?

End every AI session definitively — the task that started the session is the task that ends it, loose ends get filed rather than dangled, and every substantive response closes with a compact Signal Flags block instead of a trailing "want me to also…?" hook. Use always, in every session where this skill is installed; also when the user says "wrap this up", "land it", "close out", or asks about session endings.

Why use Limits Endings on TypingMind?

Because you install it once and use it with any model. Limits Endings is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Limits Endings in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/bradfrost/skills/tree/main/skills/mental-health/limits-endings. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Limits Endings?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Limits Endings?

As many as you like. As long as a model supports skills, you can use Limits Endings with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Limits Endings AI skill free?

Yes. It is published on GitHub by bradfrost under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇