Writing Skills logo

Writing Skills

Community
andreaswasita
writing-skills

Authors new SKILL.md files that conform to the dojo spec.

Overview

Publisherandreaswasita
Repositorycopilot-agents-dojo
Skill namewriting-skills
Stars
54
Forks
15
Bundled files
Instructions only
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.

  • Self-contained

    Everything the model needs lives in the instructions — no extra files to sync.

  • Open source

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

Installation

Install the Writing Skills 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/andreaswasita/copilot-agents-dojo/tree/main/optional-skills/writing-skills
  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/andreaswasita/copilot-agents-dojo.git /tmp/copilot-agents-dojo
mkdir -p .claude/skills
cp -r /tmp/copilot-agents-dojo/optional-skills/writing-skills .claude/skills/writing-skills
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Writing Skills 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 Writing Skills 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 Writing Skills 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.

Writing Skills (meta) Skill

Walks the agent through producing a new SKILL.md that conforms to spec/copilot-skills-spec.md and passes scripts/verify.sh spec. Covers intent capture, folder layout, frontmatter, canonical body sections, and the test loop. Does NOT auto-register the new skill in skills.md — that is the regen script's job.

When to Use

  • The user explicitly asks to create or amend a skill.
  • A tasks/lessons.md pattern has ≥3 occurrences and should graduate to a skill.
  • The dojo curator (see self-improvement) flags a candidate skill to formalize.
  • Team adapts the dojo for a new domain.
  • NOT for one-off rules — those live in tasks/lessons.md until they recur.

Prerequisites

  • spec/copilot-skills-spec.md and template/SKILL.md exist (this skill is parasitic on them).
  • The view, edit, and powershell Copilot tools.
  • scripts/verify.sh available on the path (or git bash on Windows).
  • Decision recorded for which tier the new skill belongs in.

How to Run

text
1. Capture intent — what, when, what good looks like, what mistakes to prevent.
2. Pick the tier (core / practical / optional) and folder destination.
3. Copy `template/SKILL.md` to `<tier-dir>/<skill-name>/SKILL.md`.
4. Fill frontmatter; ≤60-char description with period; no marketing words.
5. Walk the canonical body sections in order.
6. Run `bash scripts/verify.sh spec` until the new skill is clean.
7. Hand off to the regen script (Phase 5.1) to update `skills.md`.

Quick Reference

TierFolderLoaded when
coreskills/Always
practicalskills/On trigger
optionaloptional-skills/Installed explicitly
Frontmatter keyRule
nameLowercase, hyphens, matches folder
description≤60 chars, ends with period, no marketing words
tiercore | practical | optional
categorySee spec §1.2 valid set
created_byhuman or agent
platformsSubset of [windows, macos, linux]
authorName (@handle), human first
Body section (in order)Purpose
When to UseTriggers and contexts
PrerequisitesWhat must be true before running
How to RunOne-screen happy path
Quick ReferenceTables the agent can act from
ProcedureDeep step-by-step
PitfallsDO NOT imperative register
VerificationCheckboxes that prove the skill ran

Procedure

Step 1: Capture Intent

Answer four questions before touching files:

  1. What behavior does this skill teach?
  2. When should it trigger? (keywords, contexts)
  3. What does good output look like?
  4. What mistakes does it prevent?

If lesson-driven, open tasks/lessons.md and read every entry with the same error_type to extract the pattern.

Step 2: Pick Tier and Folder

SignalTier
Always-on discipline applied to every sessioncore
Triggered by a task family (review, debug, plan)practical
Heavy, niche, or requires external installationoptional

Create the folder:

bash
mkdir -p skills/<skill-name>          # core or practical
mkdir -p optional-skills/<skill-name> # optional

Step 3: Copy the Template

Use edit to read template/SKILL.md and edit to write <folder>/<name>/SKILL.md. Replace every placeholder. Do NOT introduce sections outside the canonical seven.

Step 4: Frontmatter

yaml
---
name: my-new-skill
description: <single sentence ≤60 chars ending with a period>.
tier: practical
category: workflow
created_by: human
platforms: [windows, macos, linux]
tags: [keyword1, keyword2]
author: Real Name (@handle)
---

Forbidden description words (marketing — flagged by verify.sh):

powerful  comprehensive  seamless  advanced
robust    cutting-edge   intelligent  revolutionary

Step 5: Body — Canonical Sections

Write each section in order. The Verification section MUST be a checklist whose items are testable — not aspirations.

In prose, reference Copilot tools by name in backticks (view, edit, grep, glob, powershell, web_fetch, task). Do NOT instruct the agent to call bare shell utilities — verify.sh warns on these:

cat  sed  awk  find  head  tail

Step 6: Run the Spec Gate

bash
bash scripts/verify.sh spec

Iterate until the new skill produces no errors and no warnings.

Step 7: Smoke Test

Open a fresh session. Use a trigger phrase the skill claims to handle. Observe whether it activates and whether the output reflects the procedure. Iterate description and triggers as needed.

Pitfalls

  • DO NOT invent new body sections. Seven canonical, in fixed order.
  • DO NOT write a description over 60 chars or without a period — the gate will reject it.
  • DO NOT use marketing adjectives in the description.
  • DO NOT instruct the agent to call bare shell utilities. Use Copilot tool names.
  • DO NOT register the skill manually in skills.md — let the regen script do it.
  • DO NOT ship a skill without verifying it actually triggers on its claimed contexts.

Verification

  • bash scripts/verify.sh spec produces no errors for the new skill.
  • No warnings on the new skill (banned shell utilities, etc.).
  • Frontmatter complete with all required keys.
  • Body sections present in canonical order.
  • Smoke test in a fresh session confirms the skill activates as claimed.
  • If created from a lesson, the originating tasks/lessons.md entry references the new skill.

Frequently asked questions

What does the Writing Skills AI skill do?

Authors new SKILL.md files that conform to the dojo spec.

Why use Writing Skills on TypingMind?

Because you install it once and use it with any model. Writing Skills 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 Writing Skills in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/andreaswasita/copilot-agents-dojo/tree/main/optional-skills/writing-skills. TypingMind reads its SKILL.md and installs it as a skill you can enable per chat.

Which AI models can use Writing Skills?

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 Writing Skills?

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

Is the Writing Skills AI skill free?

Yes. It is published on GitHub by andreaswasita 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 👇