Przejdź do treści
Biblioteka skilli
Marketing i treści · Pisanie

write-blog-post

/write-blog-post

Pisze, sprawdza i publikuje wpis na blogu LoreKit: od badania tematu, przez rysunki SVG, po weryfikację kompilacji.

Repozytorium
lorekit ↗
Licencja
MIT
Ostatnia zmiana repozytorium
10.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
3
Skrypty
1
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 10.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co sprawdzić przed instalacją
  • 1 skrypt w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: scripts/render-svg.cjs

Co robi i kiedy

Pisze, sprawdza i publikuje wpis na blogu LoreKit: od badania tematu, przez rysunki SVG, po weryfikację kompilacji.

Wyzwalacze z opisu

write a blog postnew blog postdraft a post aboutreview this blog postadd graphics to the post

Argumenty

/write-blog-post <topic or slug> [--review-only] [--figures-only]
Oryginalny opis (EN)

Writes, critically reviews, illustrates, and ships a post for the LoreKit blog (packages/web/src/content/blog) end to end: researches the topic, checks every LoreKit claim against the code and every outside claim against sources, drafts in the house voice, runs a skeptic's review and rewrites for plain, strong language, draws SVG figures in the blog's figure style, registers the post, and verifies it compiles. Triggers on "write a blog post", "new blog post", "draft a post about", "review this blog post", "add graphics to the post", "/write-blog-post".

Jak działa

  1. Files you will touch
  2. Phase 1 — Orient
  3. Phase 2 — Research
  4. Phase 3 — Draft
  5. Phase 4 — Critical review and rewrite
  6. Phase 5 — Figures
  7. Phase 6 — Verify
  8. Phase 7 — Ship
  9. Voice
Sekcje z nagłówków SKILL.md, w oryginale · 175 linii, 1 222 słów
Podgląd SKILL.md
---
name: write-blog-post
description: >
  Writes, critically reviews, illustrates, and ships a post for the LoreKit
  blog (packages/web/src/content/blog) end to end: researches the topic,
  checks every LoreKit claim against the code and every outside claim against
  sources, drafts in the house voice, runs a skeptic's review and rewrites for
  plain, strong language, draws SVG figures in the blog's figure style,
  registers the post, and verifies it compiles. Triggers on "write a blog
  post", "new blog post", "draft a post about", "review this blog post",
  "add graphics to the post", "/write-blog-post".
argument-hint: '<topic or slug> [--review-only] [--figures-only]'
license: MIT
metadata:
  author: mthines
  version: '1.0.0'
  workflow_type: applied
  tags:
    - blog
    - content
    - mdx
    - svg
    - lorekit
---

# Write a blog post

A LoreKit blog post is a public claim about how the product works and how it
compares to other tools. Readers include people who build those tools. One
wrong claim about the code, or about a competitor, costs more credibility than
the post earns. So this skill is mostly about **checking**, and only partly
about writing.

Run the phases in order. `--review-only` starts at Phase 4 on an existing post.
`--figures-only` runs Phase 5 alone.

## Files you will touch

| Path | What it is |
| --- | --- |
| `packages/web/src/content/blog/<slug>.mdx` | The post. The slug is the URL and the filename |
| `packages/web/src/lib/blog/sections.ts` | The registry. One entry per post: `id` = slug, `label` = title, `summary` = description, character for character |
| `packages/web/public/blog/<name>.svg` | Figures, referenced as `/blog/<name>.svg` |

`sections.spec.ts` fails when the registry and the frontmatter disagree, and
when the `order` values don't match the registry order.

## Phase 1 — Orient

1. Read **every** existing post's frontmatter and at least two full posts.
   Learn the voice (see [Voice](#voice)) and, above all, **what has already
   been said**. A new post must not repeat an earlier one. Link to it instead.
2. Read `sections.ts` to find the next `order` (the highest existing value + 1).
3. Settle the angle in one sentence before writing anything. If it overlaps
   an existing post, find the part that's new.

## Phase 2 — Research

**LoreKit claims: check the code, not the docs or your memory.** For every
behaviour the post states, open the implementation and note the file. Claims
that drifted in earlier posts, and are worth checking every time:

- **TTL / expiry.** Read the latest `memory_write` in `supabase/migrations/`
  and `packages/cli/src/store/local.mjs`. Memories are permanent by default.
  Only a write that carries a TTL (or a config default) resets the countdown.
  A read never extends anything.
- **Scope grammar.** `packages/mcp-core/src/scope/scope.ts` defines exactly
  what is accepted. For example, `repo::` takes `owner/repo` only.
- **On-disk format.** `packages/cli/src/store/format.mjs`: which fields
  exist, and what survives a rewrite. Unknown fields are dropped.
- **What the session-start digest includes.** `packages/cli/src/core/lessons.mjs`
  (`isGeneralLesson`).
- **Limits.** `MAX_VALUE_BYTES` in `packages/schemas/src/domain/memory.ts`,
  the memory cap and the rate limit in `docs/limits.md`.
- **Inferred fields.** `kind`/`host` are inferred only from `loop::` tags.
  Show realistic values in examples, not what you assume a field holds.

**Outside claims: search, cite, and look for competitors.** Use WebSearch or
WebFetch for every statement about another tool. Keep the source URLs; the
summary you give the user must list them. Always search explicitly for
**existing proposals or standards** in the post's area. Leaving out a
competing effort is the first thing a critic will point to.

**Never invent first-person experience** for the author ("on my laptop…",
"I tried X last week"). Write it as a general or hypothetical case unless the
user has told you it's true.

## Phase 3 — Draft

Frontmatter (every field required, and the same order as other posts):

```yaml
---
title: "…"                 # must equal sections.ts `label`
description: "…"           # must equal sections.ts `summary`
date: "YYYY-MM-DD"         # a future date keeps it a draft: hidden in prod, visible on previews
author: "Mads Thines"
readingMinutes: 10         # about 220 words a minute, rounded
tags: ["…"]
order: 5                   # next integer, matching the registry position
keywords: ["…"]
---
```

Then add the registry entry at the end of `BLOG_SECTIONS`. Python's `repr()`
picks quote styles that break TypeScript; edit the entry by hand, or check for
the trailing comma afterwards.

Structure that works for this blog:

- Open with something concrete the reader recognises, not a thesis.
- Use `##` sections with plain, specific headings (they become the table of contents).
- Every fenced code block gets a language tag (`bash`, `json`, `ts`, `text`,
  `markdown`, `yaml`). Shiki highlights only tagged blocks.
- Use internal links (`/blog/<slug>`, `/docs/<page>`) rather than repeating material.
- Always write the concrete MCP endpoint, never a `<ref>` placeholder.
- End with something the reader can do, usually `npx @lorekit/cli install`.

## Phase 4 — Critical review and rewrite

Do this as a separate pass, as if someone else wrote the draft. Produce a
findings list for the user, then fix the post.

1. **Compare to the code.** Re-check each LoreKit claim against Phase 2. Look
   for overstatement ("by default", "always", "never", "lossless"): those are
   the words that turn out to be false.
2. **Compare to the industry.** Is every tool described fairly and currently?
   Is any competing proposal missing? Does the post claim something is
   original when someone else already did it?
3. **Write the skeptic's objections.** List the five or six things a sharp
   critic would say: conflict of interest, "X already solves this", security,
   scale, "yet another standard". Answer the strong ones in the post, in a
   section or inline. Concede where the critic is right. A post that admits
   its weak points is more convincing than one that hides them.
4. **Rewrite for plain, strong language.**
   - One idea per sentence. Short sentences. Active voice.
   - Concrete nouns and real examples instead of abstractions.
   - Cut hedges ("quite", "arguably", "it seems") and empty intensifiers.
   - Turn run-on lists in prose into bullets.
   - Bold at most one phrase per section: the thing to remember.
   - Say "I'm not sure" plainly where it's true. Don't invent certainty.
5. Update `description` and the registry `summary` together if the angle moved.

## Phase 5 — Figures

Each post usually has 2–4 figures, one per idea that is easier to see than to
read: a comparison, a timeline, a hierarchy, a data shape. Don't draw a figure
that only repeats a table.

Follow [references/figure-style.md](./references/figure-style.md) exactly:
the palette, fonts, background, `role="img"` with a full `aria-label`, and the
`<figure>` markup with `alt`, `width`, `height` and a `<figcaption>` that
states the takeaway, not just the subject.

Then **look at every figure** before you embed it:

```bash
node .claude/skills/write-blog-post/scripts/render-svg.cjs "$SCRATCH" packages/web/public/blog/<name>.svg
```

Read the PNG and check for text overflowing a box, labels colliding with
marks, and glyphs rendering in the wrong colour. Fix, re-render, and look
again. Validate the XML with `xmllint --noout`.

## Phase 6 — Verify

```bash
cd packages/web
npx vitest run src/lib/blog                      # registry drift, order, dates, render
```

The render spec compiles only one fixed post. Compile the new one through the
real pipeline too, with a throwaway copy that you delete afterwards:

```bash
sed 's|self-healing-agents.mdx|<slug>.mdx|' src/lib/blog/mdx-render.spec.ts > src/lib/blog/tmp-post.spec.ts
npx vitest run src/lib/blog/tmp-post.spec.ts; rm src/lib/blog/tmp-post.spec.ts
```

Install dependencies first in a fresh sandbox (`pnpm install --frozen-lockfile`).

## Phase 7 — Ship

- Commit the post, the registry entry and the figures together. The blog is
  not part of `llms.txt`, so the PR description should say in one line that
  no other docs needed changes.
- Follow the repo's PR workflow (root `CLAUDE.md`) only if the user asks for a PR.
- Report to the user: the post's URL path, its date (and whether that makes it
  a draft), the review findings you fixed, anything you couldn't verify, and
  the source links.

## Voice

- First person singular, as the author: curious and direct, and open about
  what's uncertain.
- Name the problem in the reader's terms before naming LoreKit.
- Invite argument at the end. The blog's posts treat design as an open question.
- No marketing superlatives. Let a concrete example make the point.
Pliki w paczce (3)
  • SKILL.md 9 KB
  • references/figure-style.md 3 KB
  • scripts/render-svg.cjs 1 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · mthines/lorekit100MIT
techwolf-ai/ai-first-toolkit100MIT

Migawka bazy z 13.11.2026 · wersja paczki ae98c0735f8f (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100blog-writer
    Planuje, pisze i recenzuje wpisy na blogu VS Code: najpierw proponuje konspekt i zadaje pytania, a plików nie zmienia przed zatwierdzeniem planu.
  • 100write-blog
    Generuje pełny wpis blogowy zoptymalizowany pod SEO na podstawie słowa kluczowego lub tematu podanego przez użytkownika.
  • 100blog-post
    Pisze wpis blogowy w markdown na dowolny temat i zapisuje go w katalogu ~/claude.nosync/posts/.
  • 100blog-post
    Pisze i publikuje nowy wpis na blogu witryny skillfold: znajduje temat, weryfikuje go w źródłach pierwotnych, pisze post w Markdown, regeneruje witrynę i wysyła pull request.
  • 95memstack-content-blog-post
    Pisze długie artykuły blogowe dopasowane do tematu, odbiorcy i kanału publikacji.
  • 90write-post
    Prowadzi przez siedem etapów pisania wpisu na blogu, od zera albo z gotowego konspektu wygenerowanego w potoku.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.