DEV Community: TK Lin

Give your book a machine-verifiable identity: JSON-LD, llms.txt, SHA-256 ledgers and Ed25519 signatures

TK Lin — Wed, 28 Oct 2026 04:26:52 +0000

I published a book for free in four languages (Traditional Chinese, Simplified Chinese, English, Japanese) and four formats each: a web edition, a standard PDF, an A5 PDF and an EPUB. That is 12 downloadable files plus four web editions.

Right after release I noticed a gap. There was no single place where a person or a machine could answer three questions:

Which book is this? Are the Japanese EPUB and the English PDF the same work, or two different books?
Which revision do I have? The book gets revised, and page numbers differ between formats and between revisions.
Is this file the one the author released? Byte for byte.

So next to the pages people read, I built one page whose only job is to let you check. We call it the book's IDA (identity data). This post walks through the implementation so you can reproduce it for your own book, documentation set or dataset.

The live pieces:

https://km.idaeo.ai/idaeo/book — the identity page (?lang=en | ja | zh-Hans)
https://km.idaeo.ai/idaeo/book/llms.txt and brief.txt — plain-text indexes for LLMs
https://km.idaeo.ai/idaeo/book/releases/2026-10-25-r11.json — the ledger for this revision, plus a .sig
https://km.idaeo.ai/idaeo/book/releases.json — the index of all revisions

Why AI needs a verifiable bibliography

When an AI system summarizes or cites a book, it is working from whatever it crawled. A human can look at the colophon and decide. A machine needs explicit handles:

a stable ID for the work that does not change between revisions,
a list of editions and formats that point back to that work,
a list of revisions with dates and persistent identifiers,
hashes and a signature so a given file can be tied to a given revision.

We split this into layers, from shortest to most detailed:

Layer	What it holds
L0 `brief.txt`	About a dozen lines: titles in four languages, author, revision, license, citation, data limits
L1 `llms.txt`	Every entry point with correct file names, ledger URLs, how to verify
L2 identity page	Embedded JSON-LD: one work, four language editions × four formats
L4 ledger	One never-overwritten JSON per revision: size and SHA-256 of all 12 files, Ed25519-signed

(L3 reuses the book's existing machine-readable data such as facts.json.)

Step 1: JSON-LD with one `#work` and four editions

The core design rule: one work, one edition per language. We use schema.org Book at two levels and link them both ways with workExample and exampleOfWork.

Work node: @id = https://km.idaeo.ai/idaeo/book#work
Edition nodes: @id = https://km.idaeo.ai/idaeo/book#ed-{zh-Hant|zh-Hans|en|ja}
Each edition's encoding lists four MediaObjects: HTML, PDF, A5 PDF, EPUB

Here is the JSON-LD the page emits, trimmed to the English edition:

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "WebPage",
      "@id": "https://km.idaeo.ai/idaeo/book#page",
      "url": "https://km.idaeo.ai/idaeo/book",
      "mainEntity": { "@id": "https://km.idaeo.ai/idaeo/book#work" }
    },
    {
      "@type": "Book",
      "@id": "https://km.idaeo.ai/idaeo/book#work",
      "name": "IDAEO：AI 時代的行銷戰略",
      "alternateName": ["IDAEO: Market Strategy for the AI Era", "IDAEO：AI時代の市場戦略", "IDAEO：AI 时代的营销战略"],
      "author": { "@id": "https://tklin.washinmura.jp#person" },
      "publisher": { "@id": "https://idaeo.ai/#org" },
      "copyrightHolder": { "@id": "https://tklin.washinmura.jp#person" },
      "datePublished": "2026-10-11",
      "dateModified": "2026-10-25",
      "version": "第1版第11次改訂",
      "license": "https://creativecommons.org/licenses/by/4.0/",
      "isAccessibleForFree": true,
      "identifier": [
        {
          "@type": "PropertyValue",
          "propertyID": "DOI",
          "value": "10.5281/zenodo.23691711",
          "url": "https://doi.org/10.5281/zenodo.23691711"
        }
      ],
      "sameAs": ["https://doi.org/10.5281/zenodo.23691711"],
      "subjectOf": { "@id": "https://km.idaeo.ai/idaeo/book/releases/2026-10-25-r11.json" },
      "workExample": [
        { "@id": "https://km.idaeo.ai/idaeo/book#ed-zh-Hant" },
        { "@id": "https://km.idaeo.ai/idaeo/book#ed-zh-Hans" },
        { "@id": "https://km.idaeo.ai/idaeo/book#ed-en" },
        { "@id": "https://km.idaeo.ai/idaeo/book#ed-ja" }
      ]
    },
    {
      "@type": "Book",
      "@id": "https://km.idaeo.ai/idaeo/book#ed-en",
      "name": "IDAEO: Market Strategy for the AI Era",
      "inLanguage": "en",
      "bookEdition": "1st edition, 11th revision",
      "exampleOfWork": { "@id": "https://km.idaeo.ai/idaeo/book#work" },
      "url": "https://km.idaeo.ai/idaeo/textbook?lang=en",
      "encoding": [
        { "@type": "MediaObject", "encodingFormat": "text/html", "contentUrl": "https://km.idaeo.ai/idaeo/textbook?lang=en" },
        { "@type": "MediaObject", "encodingFormat": "application/pdf", "contentUrl": "https://km.idaeo.ai/idaeo/book/IDAEO-en.pdf" },
        { "@type": "MediaObject", "name": "A5 PDF", "encodingFormat": "application/pdf", "contentUrl": "https://km.idaeo.ai/idaeo/book/IDAEO-en-A5.pdf" },
        { "@type": "MediaObject", "encodingFormat": "application/epub+zip", "contentUrl": "https://km.idaeo.ai/idaeo/book/IDAEO-en.epub" }
      ]
    }
  ]
}

Design notes:

author and publisher are @id references only. The author's details live in the author's own identity record at https://tklin.washinmura.jp#person. The book does not duplicate names and bios that could drift apart.
identifier carries only the concept DOI. The book has no ISBN, so there is no ISBN field. "No invented identifiers" is an explicit acceptance criterion.
subjectOf points at the ledger, so a crawler can walk from the work to the record that describes this revision's files.
Two PDFs, one MIME type. The standard PDF and the A5 PDF are both application/pdf; MediaObject.name: "A5 PDF" tells them apart.

In Next.js (App Router) the edition nodes are generated from the language list:

const editions = CONTENT_LANGS.map((l) => ({
  "@type": "Book",
  "@id": `${SITE}${BOOK_PATH}#ed-${FILE_LANG[l]}`,
  name: TITLE[l],
  inLanguage: IN_LANGUAGE[l],
  bookEdition: EDITION_LABEL[l],
  exampleOfWork: { "@id": BOOK_WORK_ID },
  // encoding: HTML / PDF / A5 PDF / EPUB
}));

A gotcha worth copying: the site's internal code for Traditional Chinese is zh, but the files are named IDAEO-zh-Hant.*. One mapping table, FILE_LANG, feeds file names, edition @ids and cover images, so they cannot disagree.

Revisions touch one place. A CURRENT constant holds the release key, date, version DOI and ledger path. Updating that constant plus adding a new ledger file is enough for the page and the JSON-LD to follow.

Step 2: llms.txt and brief.txt

JSON-LD is precise but verbose for a model reading plain text. So there are two text files.

/idaeo/book/brief.txt (L0) fits in about ten lines: the work @id, concept DOI, author, first-edition date, current revision with its version DOI, license, the book's core claim, its framework, the headline number with its limits, where to read, where to verify, and how to cite.

/idaeo/book/llms.txt (L1) is a Markdown-sectioned index:

# IDAEO: Market Strategy for the AI Era — Book IDA index (L1)
> The identity record of this book: which book it is, which revision you have, and how to verify it.

Work @id: https://km.idaeo.ai/idaeo/book#work
...
## Revisions
## Read and download (four languages × four formats)
## What the book says (chapters)
## Records
## Verify a file
## Cite

The ## Records section is split into three buckets: first-party (our own pages), third-party confirmed (the DOIs and the GitHub release), and pending. The pending item is a receipt number from a national-library deposit request, and the file says outright that it is "not a bibliographic ID". Telling a model what something is not matters as much as telling it what it is.

Step 3: a ledger of sizes and SHA-256 hashes

Each revision gets one file, releases/<release_key>.json, and it is never overwritten. A short Python script generates it from the actual files: size, SHA-256, MD5, PDF page count, and the EPUB identifier and modified date.

for code in ["zh-Hant", "zh-Hans", "en", "ja"]:
    for fmt, name in [("pdf", f"IDAEO-{code}.pdf"),
                      ("pdf-a5", f"IDAEO-{code}-A5.pdf"),
                      ("epub", f"IDAEO-{code}.epub")]:
        b = (R / name).read_bytes()
        rec = {"lang": code, "format": fmt,
               "path": f"/idaeo/book/{name}",
               "url": f"https://km.idaeo.ai/idaeo/book/{name}",
               "bytes": len(b),
               "sha256": hashlib.sha256(b).hexdigest(),
               "md5": hashlib.md5(b).hexdigest()}
        # PDF: page count and Author presence via pdfinfo
        # EPUB: dc:identifier and dcterms:modified from the OPF

One entry from the generated ledger:

{
  "lang": "en",
  "format": "pdf",
  "path": "/idaeo/book/IDAEO-en.pdf",
  "url": "https://km.idaeo.ai/idaeo/book/IDAEO-en.pdf",
  "bytes": 18735077,
  "sha256": "a25fa8adebb242592d647a5e9328da205d633cb513c94932096d9e010af776e1",
  "md5": "f1259262e8d658debaa6bf25b41a74c6",
  "pages": 173,
  "pdf_author_present": false
}

Beyond the file list, the top level holds:

release_key, edition_label (four languages), release_date, first_edition_date
doi.concept and doi.version, plus archives (Zenodo record and GitHub release)
previous_ledger_sha256 — the hash of the previous revision's ledger, so ledgers form a chain. It is null here because this is the first ledger.
history_note — ledgers start at r11; earlier revisions were not recorded at release time.
known_issues — e.g. the PDFs in this revision have no Author metadata.
deployed_at_note — the server's Last-Modified header is recorded, with the caveat that it is "not proof of first publication".
verify — the commands, the public key URL and the key's fingerprint (public_key_fingerprint_sha256_der).

known_issues and deployed_at_note look minor, but they set the tone: the ledger separates what we can claim from what we cannot.

The index releases.json lists current and, per revision, key, ledger, signature, doi and release_date, plus the concept_doi.

Step 4: sign the ledger, not the binaries

Only the ledger JSON is signed, with Ed25519. The 12 binaries are not signed individually. The ledger already contains their SHA-256 hashes, so one valid signature over the ledger covers every hash in it. This also meant we did not have to touch the already-published r11 files.

We did not generate a new key. The ledger is signed with the same Ed25519 key as the author's identity record:

Public key: https://tklin.washinmura.jp/tklin-ida-key.pem

The signatures are raw 64-byte Ed25519 signatures: releases/2026-10-25-r11.json.sig and releases.json.sig.

Step 5: how a reader verifies

Check a file

shasum -a 256 IDAEO-en.pdf
# compare with files[].sha256 in the ledger

To check all 12 at once, turn the ledger into shasum -c input:

jq -r '.files[] | "\(.sha256)  \(.path | split("/") | last)"' \
  2026-10-25-r11.json > SHA256SUMS
shasum -a 256 -c SHA256SUMS
# IDAEO-zh-Hant.pdf: OK
# ...

A mismatch does not necessarily mean tampering. A store repackaging the file or a reader app re-saving it also changes the bytes, and the identity page says so.

Check the ledger signature

openssl pkeyutl -verify -pubin -inkey tklin-ida-key.pem -rawin \
  -in 2026-10-25-r11.json -sigfile 2026-10-25-r11.json.sig
# Signature Verified Successfully

You need OpenSSL 3. The /usr/bin/openssl that ships with macOS is LibreSSL and does not support this. Use Homebrew's openssl@3 or similar. When I tried LibreSSL, it failed while loading the public key with unable to load Public Key.

Change one byte of the ledger and the same command should print Signature Verification Failure. "Altering one byte must fail" is part of the acceptance criteria, for the file hashes and for the signature.

Step 6: two kinds of DOI

The DOIs come from Zenodo, which issues two kinds:

Kind	Value	Meaning
Concept DOI	`10.5281/zenodo.23691711`	All versions; resolves to the latest
Version DOI	`10.5281/zenodo.23691712`	1st edition, 11th revision (r11) only

The work node's identifier and sameAs use the concept DOI. The citation line and the ledger's doi.version use the version DOI. The work stays the same across revisions; a citation pins one revision.

Recap

One @id for the work, one Book node per language edition, formats as MediaObjects in encoding
brief.txt (L0) and llms.txt (L1) for models that read plain text
A never-overwritten ledger per revision, with sizes and SHA-256 computed from the real files
Ed25519 over the ledger only; readers verify with shasum and OpenSSL 3
Concept DOI for the work, version DOI for citations
Do not write identifiers you do not have; put what you cannot claim in known_issues

The book used throughout this post is IDAEO: Market Strategy for the AI Era by TK Lin (林毅祥), who runs Washinmura, a lodge for rescued cats in Chiba, Japan. It is free to read in four languages under CC BY 4.0, DOI 10.5281/zenodo.23691711. Read it online at https://km.idaeo.ai/idaeo/textbook?lang=en, and find the identity page at https://km.idaeo.ai/idaeo/book?lang=en.

112 Battle-Tested Claude Code Skills — Every Bug Fix That Cost Me Hours So It Won't Cost You

TK Lin — Wed, 25 Feb 2026 00:33:09 +0000

AI coding assistants are powerful. They're also amnesiac.

Claude Code will help you fix a Docker SQLite WAL corruption bug at 2am. You'll figure out the root cause (you can't docker cp a SQLite DB from a running container — you need to stop writes first or copy the WAL file too). You'll fix it. Ship it. Move on.

Three days later, same project, new session. Claude Code has no memory of that fix. The same bug pattern appears. You debug it again.

After the third time this happened to me, I stopped fixing bugs and started building a system to make them unfixable.

The Solution: Skills as Muscle Memory

Claude Code supports "skills" — markdown files that load into context when relevant patterns are detected. Think of them as institutional memory for your AI assistant.

Each skill captures:

The problem: What goes wrong, and how it looks when it happens
The root cause: Why it happens (not just what to do)
The fix: Exact steps, code patches, configuration changes
The trigger: When Claude Code should automatically apply this knowledge

Over 7 months of building a production API platform (39 services, 30+ APIs, running from an animal sanctuary in rural Japan — long story), I hit 200+ production bugs. I extracted the non-obvious ones into 112 reusable skills.

The Categories

Docker and Deployment (12 skills)

Skill	What it fixes
`docker-sqlite-wal-copy-trap`	Data corruption when copying SQLite from running container
`docker-ghost-container-recovery`	Container name occupied but container doesn't exist
`docker-small-vps-deploy-optimization`	OOM kills on 2GB VPS during docker build
`docker-static-asset-copy-gotcha`	Static assets 404 in container but work locally
`docker-compose-force-recreate-caddy-loop`	Infinite restart loop with force-recreate watchdog

Database and SQLite (10 skills)

Skill	What it fixes
`bun-sqlite-transaction-await-crash`	Production crash from `await` inside `db.transaction()`
`sqlite-check-constraint-migration`	CHECK constraint failed when expanding allowed values
`bun-sqlite-like-parameter-binding`	Parameter binding silently fails on LIKE queries
`json-to-sqlite-hybrid-migration`	Safe migration from JSON file persistence to SQLite

API and Backend (15 skills)

Skill	What it fixes
`hono-subrouter-auth-isolation`	Auth bypass when multiple Hono sub-routers share paths
`multi-provider-fallback-gateway`	Single provider failures taking down the whole service
`api-security-audit-methodology`	Systematic security review with 30+ vulnerability patterns
`hono-global-middleware-ordering`	Global middleware silently not executing for sub-routes
`multi-layer-proxy-timeout-chain-debugging`	502/504 errors in CDN -> reverse proxy -> app chains

AI and LLM (8 skills)

Skill	What it fixes
`llm-api-cost-optimization`	Claude API costs spiraling out of control
`ai-prompt-mastery`	AI giving generic answers instead of expert-level responses
`api-tool-use-upgrade-pattern`	Upgrading from manual JSON parsing to proper Tool Use
`llm-model-version-migration-2026`	404 errors from deprecated model version strings

Frontend and UI (6 skills)

Skill	What it fixes
`nextjs-common-patterns`	"params is a Promise" and other Next.js 13+ gotchas
`elderly-friendly-ssr-ui-optimization`	Making SSR pages usable for elderly/low-vision users
`template-literal-inline-js-escaping`	Silent page failures from JS syntax errors in SSR scripts

Debugging and Workflow (10 skills)

Skill	What it fixes
`systematic-debug`	Ad-hoc debugging that wastes hours on wrong leads
`code-verification-loop`	Shipping code without automated verification
`multi-agent-workflow-design`	Identifying when to use multi-agent vs single-agent
`audit-inflation-bias-prevention`	AI sub-agents inflating bug reports with false positives

Installation

One command:

curl -fsSL https://raw.githubusercontent.com/sstklen/washin-claude-skills/main/install.sh | bash

What happens:

Clones the skill library to ~/.claude/skills/
Skills are automatically available in all Claude Code sessions
No configuration needed

Verify it worked:

ls ~/.claude/skills/
# Should show 112 skill directories

Before vs After: A Real Example

Scenario: You're deploying a Bun + SQLite app in Docker. You need to backup the database.

Without the skill:

You run docker cp container:/app/data.db ./backup.db. It works. But the backup is silently corrupted — SQLite was mid-write, and the WAL file wasn't copied. You don't discover this until you try to restore from backup in an emergency. 2-4 hours of debugging. Panic.

With docker-sqlite-wal-copy-trap skill:

Claude Code recognizes the pattern the moment you mention copying a SQLite DB from a container. It immediately warns you about the WAL trap and provides the correct approach:

# Stop writes first, or copy all three files:
docker cp container:/app/data.db ./backup.db
docker cp container:/app/data.db-wal ./backup.db-wal
docker cp container:/app/data.db-shm ./backup.db-shm

Problem solved in seconds. Not hours. And it never happens again, across any project.

Skill Format

Every skill follows this structure:

skill-name/
  SKILL.md       # The skill content

Here's what a real skill looks like (abbreviated):

---
name: docker-sqlite-wal-copy-trap
category: Docker & Deployment
trigger: "copying SQLite from Docker container"
---

# Fix: Docker SQLite WAL Copy Trap

## The Problem
`docker cp container:/app/data.db ./backup.db` produces a
silently corrupted copy. No error, no warning — just missing
recent data.

## Root Cause
SQLite uses WAL (Write-Ahead Log). The .db file alone is
incomplete. You must also copy .db-wal and .db-shm, or
checkpoint the WAL first.

## The Fix
Option A — Copy all three files:
  docker cp container:/app/data.db ./backup.db
  docker cp container:/app/data.db-wal ./backup.db-wal
  docker cp container:/app/data.db-shm ./backup.db-shm

Option B — Checkpoint first:
  sqlite3 /app/data.db "PRAGMA wal_checkpoint(TRUNCATE);"
  Then copy the single .db file.

Each skill is under 500 lines. Claude Code loads relevant skills into context automatically when it detects matching patterns.

A Note on Stack Compatibility

Most of these skills come from a specific stack: Bun + Hono + SQLite + Docker on a Linux VPS. If that's your stack, almost everything applies directly.

If you use a different stack, here's what still works universally:

Debugging and Workflow skills (10 skills) — stack-agnostic problem-solving patterns
AI and LLM skills (8 skills) — applicable to any Claude Code project
Docker skills (12 skills) — useful for any Dockerized app, not just Bun/Hono
API patterns (many of the 15 skills) — timeout chains, auth isolation, security audits work regardless of framework

Stack-specific skills (Bun SQLite quirks, Hono sub-router bugs) are clearly named — if you don't use Bun or Hono, you'll know which ones to skip.

Want to contribute your own? Fork the repo, add your skill following the format, and open a PR. Every production bug you've solved is a skill waiting to be shared.

The Philosophy

Skills aren't just bug fixes. They encode a principle:

If the same problem happens three times, stop fixing it. Change the system so it can't happen again.

These 112 skills represent 7 months of production pain at an animal sanctuary in Japan, distilled into patterns that any Claude Code user can benefit from. Your worst production bugs become your AI's best skills.

GitHub: github.com/sstklen/washin-claude-skills

Install:

curl -fsSL https://raw.githubusercontent.com/sstklen/washin-claude-skills/main/install.sh | bash

Full backstory: Zero Engineer — Animal Sanctuary to Production Platform

実戦で鍛えた 112 の Claude Code Skills — 何時間もかけたバグ修正を、あなたは繰り返さなくていい

TK Lin — Tue, 24 Feb 2026 03:49:17 +0000

AI コーディングアシスタントは強力です。しかし、記憶がありません。

Claude Code は深夜 2 時に Docker SQLite WAL 破損バグの修正を手伝ってくれます。根本原因も突き止めます（実行中のコンテナから docker cp で SQLite DB をコピーしてはいけない——先に書き込みを停止するか、WAL ファイルも一緒にコピーする必要があります）。修正完了。デプロイ。次へ。

3 日後、同じプロジェクト、新しいセッション。Claude Code はその修正を一切覚えていません。同じバグパターンが再発。また同じデバッグ作業。

3 回目に同じ問題に遭遇したとき、私はバグを直すのをやめました。代わりに、そのバグが二度と起きないシステムを作り始めました。

解決策：Skills = AI の筋肉記憶

Claude Code は「skills」をサポートしています——関連するパターンが検出されたときに自動的にコンテキストに読み込まれる markdown ファイルです。AI アシスタントの「組織的記憶」と考えてください。

各 skill が記録する内容：

問題：何が起こるか、起きたときどう見えるか
根本原因：なぜ起こるか（対処法だけでなく）
修正方法：具体的な手順、コードパッチ、設定変更
トリガー条件：Claude Code がいつこの知識を自動適用すべきか

日本の房総半島にある動物保護施設で、7 ヶ月かけて本番稼働の API プラットフォーム（39 サービス、30 以上の API）を構築しました。その過程で 200 以上の本番バグに遭遇。そのうち非自明なものを 112 個の再利用可能な skill として抽出しました。

カテゴリ一覧

Docker とデプロイ（12 個）

Skill	何を修正するか
`docker-sqlite-wal-copy-trap`	実行中コンテナから SQLite コピー時のデータ破損
`docker-ghost-container-recovery`	コンテナ名が使用中だがコンテナが存在しない
`docker-small-vps-deploy-optimization`	2GB VPS で docker build 時の OOM kill
`docker-static-asset-copy-gotcha`	コンテナ内で静的アセットが 404 だがローカルでは正常
`docker-compose-force-recreate-caddy-loop`	force-recreate ウォッチドッグによる無限再起動ループ

データベースと SQLite（10 個）

Skill	何を修正するか
`bun-sqlite-transaction-await-crash`	`db.transaction()` 内での `await` による本番クラッシュ
`sqlite-check-constraint-migration`	許可値の拡張時に CHECK constraint failed
`bun-sqlite-like-parameter-binding`	LIKE クエリでパラメータバインディングがサイレントに失敗
`json-to-sqlite-hybrid-migration`	JSON ファイルから SQLite への安全な移行

API とバックエンド（15 個）

Skill	何を修正するか
`hono-subrouter-auth-isolation`	複数の Hono サブルーターがパスを共有する際の認証バイパス
`multi-provider-fallback-gateway`	単一プロバイダーの障害がサービス全体をダウンさせる
`api-security-audit-methodology`	30 以上の脆弱性パターンによる体系的セキュリティ審査
`hono-global-middleware-ordering`	グローバルミドルウェアがサブルートに対してサイレントに未実行
`multi-layer-proxy-timeout-chain-debugging`	CDN → リバースプロキシ → アプリチェーンでの 502/504 エラー

AI と LLM（8 個）

Skill	何を修正するか
`llm-api-cost-optimization`	Claude API のコスト爆発
`ai-prompt-mastery`	AI が一般的な回答しかせず専門家レベルにならない
`api-tool-use-upgrade-pattern`	手動 JSON パースから正式な Tool Use への移行
`llm-model-version-migration-2026`	廃止されたモデルバージョン文字列による 404 エラー

フロントエンドと UI（6 個）

Skill	何を修正するか
`nextjs-common-patterns`	「params is a Promise」等 Next.js 13+ のよくある落とし穴
`elderly-friendly-ssr-ui-optimization`	SSR ページの高齢者・弱視者向け最適化
`template-literal-inline-js-escaping`	SSR インラインスクリプトの JS 構文エラーによるサイレント故障

デバッグとワークフロー（10 個）

Skill	何を修正するか
`systematic-debug`	場当たり的なデバッグで何時間も間違った方向へ
`code-verification-loop`	自動検証なしでの出荷
`multi-agent-workflow-design`	マルチエージェント vs シングルエージェントの判断基準
`audit-inflation-bias-prevention`	AI サブエージェントが監査レポートで偽の問題を水増し

インストール

1 コマンドで完了：

curl -fsSL https://raw.githubusercontent.com/sstklen/washin-claude-skills/main/install.sh | bash

実行後：

Skill ライブラリが ~/.claude/skills/ にクローンされます
すべての Claude Code セッションで自動的に利用可能になります
設定は不要です

確認：

ls ~/.claude/skills/
# 112 個の skill ディレクトリが表示されるはずです

Before vs After：実例

シナリオ： Docker で Bun + SQLite アプリをデプロイ中。データベースのバックアップが必要。

skill なし：

docker cp container:/app/data.db ./backup.db を実行。成功したように見える。しかしバックアップはサイレントに破損している——SQLite が書き込み中で、WAL ファイルがコピーされていない。緊急時にバックアップから復元しようとするまで気づかない。2〜4 時間のデバッグ。パニック。

docker-sqlite-wal-copy-trap skill あり：

コンテナから SQLite をコピーすると言及した瞬間、Claude Code がパターンを認識。WAL トラップについて即座に警告し、正しいアプローチを提示：

# 先に書き込みを停止するか、3 ファイルすべてをコピー：
docker cp container:/app/data.db ./backup.db
docker cp container:/app/data.db-wal ./backup.db-wal
docker cp container:/app/data.db-shm ./backup.db-shm

数秒で解決。何時間もかからない。そして、どのプロジェクトでも二度と起きない。

Skill フォーマット

各 skill の構造：

skill-name/
  SKILL.md       # skill の内容

実際の skill はこのような形式です（抜粋）：

---
name: docker-sqlite-wal-copy-trap
category: Docker & Deployment
trigger: "copying SQLite from Docker container"
---

# Fix: Docker SQLite WAL Copy Trap

## 問題
`docker cp container:/app/data.db ./backup.db` はサイレントに
破損したコピーを生成する。エラーも警告もなく、最近のデータだけが
欠落する。

## 根本原因
SQLite は WAL（Write-Ahead Log）を使用している。.db ファイル
だけでは不完全。.db-wal と .db-shm も一緒にコピーするか、
先に checkpoint を実行する必要がある。

## 修正方法
方法 A — 3 ファイルすべてをコピー：
  docker cp container:/app/data.db ./backup.db
  docker cp container:/app/data.db-wal ./backup.db-wal
  docker cp container:/app/data.db-shm ./backup.db-shm

方法 B — 先に checkpoint：
  sqlite3 /app/data.db "PRAGMA wal_checkpoint(TRUNCATE);"
  その後 .db ファイルだけをコピー。

各 skill は 500 行以下。Claude Code はマッチするパターンを検出すると、関連する skill を自動的にコンテキストに読み込みます。

スタック互換性について

これらの skill の多くは特定のスタックから生まれました：Bun + Hono + SQLite + Docker on Linux VPS。同じスタックであれば、ほぼすべてがそのまま適用できます。

異なるスタックでも普遍的に使えるもの：

デバッグとワークフロー skills（10 個）— スタック非依存の問題解決パターン
AI と LLM skills（8 個）— あらゆる Claude Code プロジェクトに適用可能
Docker skills（12 個）— Bun/Hono 以外のコンテナ化アプリにも有用
API パターン（15 個中の多数）— タイムアウトチェーン、認証分離、セキュリティ監査はフレームワーク非依存

スタック固有の skill（Bun SQLite の癖、Hono サブルーターのバグ）は名前から明確にわかります。Bun や Hono を使っていなければ、スキップすべきものは一目瞭然です。

自分の skill を貢献したいですか？リポジトリを fork し、フォーマットに従って追加し、PR を開いてください。あなたが解決した本番バグすべてが、共有を待っている skill です。

哲学

Skills は単なるバグ修正ではありません。一つの原則をエンコードしています：

同じ問題が 3 回起きたら、手動で直すのをやめる。システムを変えて、二度と起きないようにする。

この 112 の skill は、日本の動物保護施設での 7 ヶ月間の本番運用の苦労を、あらゆる Claude Code ユーザーが恩恵を受けられるパターンに凝縮したものです。あなたの最悪の本番バグが、AI の最強の skill になります。

GitHub: github.com/sstklen/washin-claude-skills

インストール：

curl -fsSL https://raw.githubusercontent.com/sstklen/washin-claude-skills/main/install.sh | bash

フルストーリー： Zero Engineer — 動物保護施設から本番 API プラットフォームへ

112 個實戰淬煉的 Claude Code Skills — 每個讓我踩坑數小時的 Bug 修復，讓你不必再踩

TK Lin — Tue, 24 Feb 2026 03:49:15 +0000

AI 寫程式的助手很強大。但它們沒有記憶。

Claude Code 會在凌晨兩點幫你修好一個 Docker SQLite WAL 損壞的 bug。你搞清楚了根本原因（不能直接 docker cp 從運行中的容器複製 SQLite 資料庫——你得先停止寫入，或者連 WAL 檔案一起複製）。修好了。部署了。繼續做事。

三天後，同一個專案，新的 session。Claude Code 完全不記得那次修復。同樣的 bug 模式又出現了。你又 debug 一次。

第三次遇到同樣的問題時，我不再修 bug 了——我開始建一個系統，讓這些 bug 不可能再發生。

解法：Skills = AI 的肌肉記憶

Claude Code 支援「skills」——當偵測到相關模式時自動載入的 markdown 檔案。把它想成 AI 助手的「組織記憶」。

每個 skill 記錄：

問題：什麼會出錯，出錯時長什麼樣
根本原因：為什麼會發生（不只是怎麼修）
修復方法：具體步驟、程式碼補丁、設定變更
觸發條件：Claude Code 什麼時候該自動套用這個知識

在日本鄉下的動物庇護所花了 7 個月打造一個生產級 API 平台（39 個服務、30+ 個 API），過程中碰到 200+ 個 production bug。我把其中不明顯的那些萃取成 112 個可重用的 skill。

分類總覽

Docker 與部署（12 個）

Skill	修什麼
`docker-sqlite-wal-copy-trap`	從運行中容器複製 SQLite 造成資料損壞
`docker-ghost-container-recovery`	容器名稱被佔用但容器不存在
`docker-small-vps-deploy-optimization`	2GB VPS 上 docker build 觸發 OOM kill
`docker-static-asset-copy-gotcha`	靜態資源在容器內 404 但本機正常
`docker-compose-force-recreate-caddy-loop`	force-recreate watchdog 導致無限重啟

資料庫與 SQLite（10 個）

Skill	修什麼
`bun-sqlite-transaction-await-crash`	`db.transaction()` 內用 `await` 導致 production crash
`sqlite-check-constraint-migration`	擴展允許值時 CHECK constraint failed
`bun-sqlite-like-parameter-binding`	LIKE 查詢的參數綁定靜默失敗
`json-to-sqlite-hybrid-migration`	從 JSON 檔案儲存安全遷移到 SQLite

API 與後端（15 個）

Skill	修什麼
`hono-subrouter-auth-isolation`	多個 Hono sub-router 共用路徑時的認證繞過
`multi-provider-fallback-gateway`	單一供應商故障拖垮整個服務
`api-security-audit-methodology`	30+ 個漏洞模式的系統化安全審查
`hono-global-middleware-ordering`	全域 middleware 對 sub-route 靜默不執行
`multi-layer-proxy-timeout-chain-debugging`	CDN → 反向代理 → 應用鏈路的 502/504 錯誤

AI 與 LLM（8 個）

Skill	修什麼
`llm-api-cost-optimization`	Claude API 費用失控
`ai-prompt-mastery`	AI 給出籠統回答而非專家級回應
`api-tool-use-upgrade-pattern`	從手動 JSON 解析升級到正式 Tool Use
`llm-model-version-migration-2026`	已棄用的模型版本字串導致 404 錯誤

前端與 UI（6 個）

Skill	修什麼
`nextjs-common-patterns`	「params is a Promise」等 Next.js 13+ 常見坑
`elderly-friendly-ssr-ui-optimization`	SSR 頁面對長輩/視力不佳用戶的友善化
`template-literal-inline-js-escaping`	SSR 內嵌 script 的 JS 語法錯誤導致頁面靜默失敗

除錯與工作流（10 個）

Skill	修什麼
`systematic-debug`	漫無目的的 debug 浪費數小時走錯方向
`code-verification-loop`	沒有自動驗證就出貨
`multi-agent-workflow-design`	判斷何時該用多 Agent vs 單 Agent
`audit-inflation-bias-prevention`	AI sub-agent 在審計報告中灌水假問題

安裝

一行指令：

curl -fsSL https://raw.githubusercontent.com/sstklen/washin-claude-skills/main/install.sh | bash

安裝完成後：

Skill 庫會複製到 ~/.claude/skills/
所有 Claude Code session 自動可用
不需要任何設定

驗證：

ls ~/.claude/skills/
# 應該看到 112 個 skill 資料夾

前後對比：真實案例

場景： 你在 Docker 裡部署 Bun + SQLite 應用，需要備份資料庫。

沒有 skill：

你跑 docker cp container:/app/data.db ./backup.db。成功了。但備份是靜默損壞的——SQLite 正在寫入，WAL 檔案沒有被複製。你不會發現這件事，直到緊急需要從備份還原時。2-4 小時的 debug。恐慌。

有 docker-sqlite-wal-copy-trap skill：

Claude Code 在你提到從容器複製 SQLite 的瞬間就辨識出這個模式。它立即警告你 WAL 陷阱，並提供正確做法：

# 先停止寫入，或複製全部三個檔案：
docker cp container:/app/data.db ./backup.db
docker cp container:/app/data.db-wal ./backup.db-wal
docker cp container:/app/data.db-shm ./backup.db-shm

幾秒鐘解決。不是幾小時。而且在任何專案中都不會再發生。

Skill 格式

每個 skill 的結構：

skill-name/
  SKILL.md       # skill 內容

真實 skill 長這樣（節錄）：

---
name: docker-sqlite-wal-copy-trap
category: Docker & Deployment
trigger: "copying SQLite from Docker container"
---

# Fix: Docker SQLite WAL Copy Trap

## 問題
`docker cp container:/app/data.db ./backup.db` 會產出
靜默損壞的副本。沒有錯誤、沒有警告——就是少了最近的資料。

## 根本原因
SQLite 使用 WAL（Write-Ahead Log）。光有 .db 檔案是不完整的。
你必須同時複製 .db-wal 和 .db-shm，或者先做 checkpoint。

## 修復方法
方案 A — 複製全部三個檔案：
  docker cp container:/app/data.db ./backup.db
  docker cp container:/app/data.db-wal ./backup.db-wal
  docker cp container:/app/data.db-shm ./backup.db-shm

方案 B — 先 checkpoint：
  sqlite3 /app/data.db "PRAGMA wal_checkpoint(TRUNCATE);"
  然後只複製 .db 檔案即可。

每個 skill 不超過 500 行。Claude Code 偵測到匹配模式時自動載入相關 skill。

Stack 適用性說明

這些 skill 大部分來自特定技術棧：Bun + Hono + SQLite + Docker on Linux VPS。如果你的 stack 跟我們一樣，幾乎全部適用。

不同 stack 也通用的部分：

除錯與工作流 skills（10 個）— 不限 stack 的問題解決模式
AI 與 LLM skills（8 個）— 適用於任何 Claude Code 專案
Docker skills（12 個）— 適用於任何容器化應用
API 模式（15 個中大部分）— timeout 鏈、認證隔離、安全審計不限框架

Stack 特定的 skill（Bun SQLite 怪癖、Hono sub-router bug）從名稱就能看出來——如果你不用 Bun 或 Hono，一看就知道哪些可以跳過。

想貢獻你自己的 skill？Fork repo，按格式新增，開 PR。你解決過的每個 production bug 都是一個等待被分享的 skill。

哲學

Skills 不只是 bug 修復。它們編碼了一個原則：

同樣的問題出現第三次，就不要再手動修了。改系統，讓它不可能再發生。

這 112 個 skill 代表了日本一間動物庇護所 7 個月的 production 血淚，濃縮成任何 Claude Code 使用者都能受益的模式。你最慘的 production bug，會成為你的 AI 最強的 skill。

GitHub: github.com/sstklen/washin-claude-skills

安裝：

curl -fsSL https://raw.githubusercontent.com/sstklen/washin-claude-skills/main/install.sh | bash

完整故事： Zero Engineer — 從動物庇護所到生產級 API 平台

🎬 Behavior_Recognition

TK Lin — Wed, 28 Jan 2026 15:00:44 +0000

Behavior Recognition: Teaching Machines to Understand What Cats Are Doing

Washin Village AI Director Tech Notes #5

🎯 From "Who Is This" to "What Are They Doing"

After AI can identify whether it's Jelly or Ariel, what's next?

Behavior Recognition: Teaching AI not just to identify animals, but to understand what they're doing.

📊 Behavior Categories We Defined

Behavior	Description	Examples
resting	Lying down, sleeping	Cat napping
walking	Moving around	Walking through room
eating	Eating, drinking	At food bowl
sitting	Sitting posture	Sitting upright
playing	Chasing, playing with toys	With toys or other cats
standing	Standing and looking	Alert stance

💻 Technical Approaches

Approach 1: Single-Frame Classification

Classify behavior for each image frame.

class BehaviorClassifier:
    def __init__(self, model_path):
        self.model = YOLO(model_path)

    def predict(self, frame):
        result = self.model.predict(frame)
        return result.class_name, result.confidence

Pros: Simple, fast
Cons: Can't judge continuous actions ("walking" vs "stopped")

Approach 2: Sequence Analysis

Analyze multiple consecutive frames to understand dynamic behavior.

class SequenceBehaviorAnalyzer:
    def __init__(self, window_size=10):
        self.window_size = window_size
        self.frame_buffer = []

    def analyze(self, frames):
        predictions = [self.classify_frame(f) for f in frames]

        # Detect behavior transitions
        transitions = self.detect_transitions(predictions)

        # Return primary behavior
        return self.majority_vote(predictions)

📈 Data Preparation

Labeling Process

Screenshot from videos: 200+ images per behavior category
Manual labeling: Using Label Studio
Quality review: Ensure labeling consistency

Data Statistics

Behavior	Training	Validation
resting	250	65
walking	180	45
eating	150	38
sitting	200	50
playing	120	30
standing	144	48
Total	1044	276

🔧 Training Configuration

from ultralytics import YOLO

model = YOLO('yolov8s-cls.pt')

model.train(
    data='behavior_dataset',
    epochs=50,
    imgsz=224,
    batch=32,

    # Augmentation settings
    augment=True,
    degrees=10,
    translate=0.1,
    scale=0.2,
    fliplr=0.5,
)

📊 Expected Results

Metric	Target
Top-1 Accuracy	75%+
Inference Speed	<20ms
Use Case	Real-time video analysis

🎬 Real Applications

1. Automatic Video Classification

Input Video → Behavior Recognition → Auto-tagging
                       ↓
              "Jelly sleeping" "Dollar eating"

2. Smart Editing

Automatically cut highlights based on behavior:

"Playing" clips → For funny videos
"Resting" clips → For relaxing videos

3. Health Monitoring

Long-term tracking of animal behavior patterns:

Decreased eating frequency → Possible illness
Reduced activity → Needs attention

💡 Lessons Learned

Clear behavior definitions: Vague definitions lead to inconsistent labeling
Balanced dataset: Keep sample counts similar across categories
Consider continuity: Single-frame has limits; sequence analysis is more accurate
Scene diversity: Include samples from different lighting and angles

🔮 Future Development

Fine-grained behaviors: Distinguish "fast running" from "slow walking"
Interaction detection: Two cats playing together
Abnormal behavior: Detect fighting or illness signs

Washin Village 🏡 by AI Director

💰 Claude API コスト削減術：公式テクニックで最大90%節約！

TK Lin — Tue, 27 Jan 2026 16:09:48 +0000

💰 Claude API コスト削減術：公式テクニックで最大90%節約！

まだ定価でClaude APIを使っていませんか？実は公式が提供する3つの機能を使うだけで、APIコストを最大90%まで削減できるんです。

🎯 はじめに：なぜコスト削減が重要なのか

私たち和心村では、28匹の猫と犬たちの写真・動画を毎日AI分析しています。動物識別、コンテンツ生成、自動投稿...Claude APIの呼び出しは1日数百回にも及びます。

最初の月の請求書を見た時、正直驚きました。「これ、続けられるの...？」

しかし、Anthropic公式ドキュメントを読み込んだ結果、3つの節約テクニックを発見。今では同じ処理量でコストを80%以上削減できています。

今日はその秘密を全て公開します。

📊 三大節約テクニック

1️⃣ Batch API（50%オフ）

即時レスポンスが不要な処理に最適！

Batch APIは、リクエストを24時間以内に処理する代わりに、50%割引を提供します。

適用シーン

大量の画像分析
バッチ翻訳処理
夜間の定期処理
レポート生成

Python コード例

import anthropic
import json

client = anthropic.Anthropic()

# バッチリクエストを作成
def create_batch_request(prompts: list[str]) -> str:
    """複数のプロンプトをバッチ処理する"""

    requests = []
    for i, prompt in enumerate(prompts):
        requests.append({
            "custom_id": f"request-{i}",
            "params": {
                "model": "claude-sonnet-4-20250514",
                "max_tokens": 1024,
                "messages": [
                    {"role": "user", "content": prompt}
                ]
            }
        })

    # バッチを作成
    batch = client.batches.create(requests=requests)

    print(f"✅ バッチ作成完了: {batch.id}")
    print(f"📊 リクエスト数: {len(prompts)}")
    print(f"💰 節約率: 50%!")

    return batch.id

# 使用例
prompts = [
    "この猫の特徴を説明してください",
    "この犬の品種を判定してください",
    "この動物の行動を分析してください"
]

batch_id = create_batch_request(prompts)

💡 ポイント

結果は24時間以内に返却
大量処理ほど効果的
client.batches.retrieve(batch_id) で状態確認

2️⃣ Prompt Caching（最大90%オフ）

繰り返し使うプロンプトをキャッシュ！

同じシステムプロンプトや長いコンテキストを何度も送信していませんか？Prompt Cachingを使えば、キャッシュされた部分は90%オフになります。

適用シーン

長いシステムプロンプト
ドキュメント分析（同じドキュメントに複数質問）
Few-shot例の再利用
RAGのコンテキスト

Python コード例

import anthropic

client = anthropic.Anthropic()

def analyze_with_cache(document: str, questions: list[str]):
    """同じドキュメントに対して複数の質問をキャッシュ活用で処理"""

    results = []

    for i, question in enumerate(questions):
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            system=[
                {
                    "type": "text",
                    "text": "あなたは動物行動分析の専門家です。",
                },
                {
                    "type": "text",
                    "text": document,
                    "cache_control": {"type": "ephemeral"}  # 🔑 キャッシュ指定
                }
            ],
            messages=[
                {"role": "user", "content": question}
            ]
        )

        # キャッシュ状況を確認
        usage = response.usage
        cache_read = getattr(usage, 'cache_read_input_tokens', 0)
        cache_creation = getattr(usage, 'cache_creation_input_tokens', 0)

        if cache_read > 0:
            print(f"✅ 質問{i+1}: キャッシュヒット! {cache_read}トークン (90%オフ)")
        elif cache_creation > 0:
            print(f"📝 質問{i+1}: キャッシュ作成 {cache_creation}トークン")

        results.append(response.content[0].text)

    return results

# 使用例：長いドキュメントに複数の質問
document = """
[和心村の動物プロフィール - 10,000文字のドキュメント...]
"""

questions = [
    "Jellyの性格を教えてください",
    "Goldの好きな食べ物は？",
    "Arielの特徴的な行動パターンは？"
]

results = analyze_with_cache(document, questions)
# → 2回目以降の質問でキャッシュヒット、90%節約！

💡 ポイント

キャッシュは5分間有効
1024トークン以上でキャッシュ可能
cache_control: {"type": "ephemeral"} を付けるだけ

3️⃣ Extended Thinking（思考トークン約80%オフ）

複雑な推論タスクに最適！

Extended Thinkingは、Claudeに「考える時間」を与える機能。思考トークンは通常の約80%オフの特別価格です。

適用シーン

複雑な論理推論
コード生成・デバッグ
数学的問題解決
戦略立案

Python コード例

import anthropic

client = anthropic.Anthropic()

def solve_complex_problem(problem: str):
    """Extended Thinkingで複雑な問題を解決"""

    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=16000,
        thinking={
            "type": "enabled",
            "budget_tokens": 10000  # 思考に使うトークン数
        },
        messages=[
            {"role": "user", "content": problem}
        ]
    )

    # 思考プロセスと回答を分離
    thinking_content = None
    answer_content = None

    for block in response.content:
        if block.type == "thinking":
            thinking_content = block.thinking
        elif block.type == "text":
            answer_content = block.text

    # コスト計算
    usage = response.usage
    input_tokens = usage.input_tokens
    output_tokens = usage.output_tokens

    print(f"📊 入力トークン: {input_tokens}")
    print(f"📊 出力トークン: {output_tokens}")
    print(f"💭 思考トークンは約80%オフ!")

    return {
        "thinking": thinking_content,
        "answer": answer_content
    }

# 使用例
problem = """
和心村の28匹の動物たちの最適な給餌スケジュールを設計してください。
条件：
- 猫23匹、犬5匹
- 朝・夕の2回給餌
- 特別食が必要な動物が3匹
- スタッフは2名
"""

result = solve_complex_problem(problem)
print(f"\n🎯 回答:\n{result['answer']}")

💡 ポイント

思考トークンは出力に含まれない
budget_tokens で思考量を制御
複雑な問題ほど効果的

📈 節約レポート：実際の効果

和心村での1ヶ月間の実績を公開します：

╔══════════════════════════════════════════════════════════════╗
║           💰 Claude API 月間節約レポート                      ║
╠══════════════════════════════════════════════════════════════╣
║                                                              ║
║  📊 処理内訳                                                  ║
║  ├─ 動物識別 (Batch)     : 3,000回/月 → 50%オフ             ║
║  ├─ コンテンツ生成 (Cache): 1,500回/月 → 90%オフ             ║
║  └─ 戦略立案 (Thinking)  :   100回/月 → 80%オフ             ║
║                                                              ║
║  💵 コスト比較                                                ║
║  ┌────────────────────────────────────────────┐              ║
║  │ 定価       : $450.00  ████████████████████ │              ║
║  │ 節約後     : $89.50   ████                 │              ║
║  │ 節約額     : $360.50  (80.1%削減!)         │              ║
║  └────────────────────────────────────────────┘              ║
║                                                              ║
║  🎯 テクニック別効果                                          ║
║  ├─ Batch API      : -$75.00  (50%削減)                     ║
║  ├─ Prompt Caching : -$243.00 (90%削減)                     ║
║  └─ Ext. Thinking  : -$42.50  (80%削減)                     ║
║                                                              ║
║  ✅ 年間換算節約額: $4,326.00                                 ║
║                                                              ║
╚══════════════════════════════════════════════════════════════╝

🛠️ すぐに使える統合クラス

3つのテクニックを統合した便利なクラスを作りました：

import anthropic
from dataclasses import dataclass
from typing import Optional
from enum import Enum

class OptimizationMode(Enum):
    BATCH = "batch"           # 50%オフ、24時間以内
    CACHED = "cached"         # 90%オフ、繰り返し処理
    THINKING = "thinking"     # 80%オフ、複雑な推論

@dataclass
class CostOptimizedRequest:
    """コスト最適化されたAPIリクエスト"""
    mode: OptimizationMode
    prompt: str
    system_prompt: Optional[str] = None
    cache_context: Optional[str] = None
    thinking_budget: int = 10000

class ClaudeCostOptimizer:
    """Claude API コスト最適化クラス"""

    def __init__(self):
        self.client = anthropic.Anthropic()
        self.stats = {
            "total_requests": 0,
            "estimated_savings": 0.0
        }

    def process(self, request: CostOptimizedRequest):
        """最適化モードに応じて処理を実行"""

        self.stats["total_requests"] += 1

        if request.mode == OptimizationMode.BATCH:
            return self._process_batch(request)
        elif request.mode == OptimizationMode.CACHED:
            return self._process_cached(request)
        elif request.mode == OptimizationMode.THINKING:
            return self._process_thinking(request)

    def _process_batch(self, request):
        """Batch API処理（50%オフ）"""
        batch = self.client.batches.create(
            requests=[{
                "custom_id": "opt-request",
                "params": {
                    "model": "claude-sonnet-4-20250514",
                    "max_tokens": 1024,
                    "messages": [{"role": "user", "content": request.prompt}]
                }
            }]
        )
        self.stats["estimated_savings"] += 0.50  # 概算
        return {"batch_id": batch.id, "mode": "batch", "savings": "50%"}

    def _process_cached(self, request):
        """Prompt Caching処理（90%オフ）"""
        system = []
        if request.system_prompt:
            system.append({"type": "text", "text": request.system_prompt})
        if request.cache_context:
            system.append({
                "type": "text",
                "text": request.cache_context,
                "cache_control": {"type": "ephemeral"}
            })

        response = self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            system=system if system else None,
            messages=[{"role": "user", "content": request.prompt}]
        )

        cache_read = getattr(response.usage, 'cache_read_input_tokens', 0)
        if cache_read > 0:
            self.stats["estimated_savings"] += 0.90

        return {"response": response.content[0].text, "mode": "cached", "savings": "90%"}

    def _process_thinking(self, request):
        """Extended Thinking処理（80%オフ）"""
        response = self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=16000,
            thinking={"type": "enabled", "budget_tokens": request.thinking_budget},
            messages=[{"role": "user", "content": request.prompt}]
        )

        self.stats["estimated_savings"] += 0.80

        answer = next(
            (b.text for b in response.content if b.type == "text"),
            None
        )
        return {"response": answer, "mode": "thinking", "savings": "80%"}

    def get_stats(self):
        """統計情報を取得"""
        return self.stats

# 使用例
optimizer = ClaudeCostOptimizer()

# Batch処理（即時性不要な大量処理）
result1 = optimizer.process(CostOptimizedRequest(
    mode=OptimizationMode.BATCH,
    prompt="この画像の動物を識別してください"
))

# Cache処理（同じコンテキストで複数質問）
result2 = optimizer.process(CostOptimizedRequest(
    mode=OptimizationMode.CACHED,
    prompt="Jellyの特徴は？",
    cache_context="[和心村の動物データベース...]"
))

# Thinking処理（複雑な推論）
result3 = optimizer.process(CostOptimizedRequest(
    mode=OptimizationMode.THINKING,
    prompt="28匹の動物の最適な健康管理プランを設計してください",
    thinking_budget=15000
))

print(f"📊 統計: {optimizer.get_stats()}")

🎯 どのテクニックを使うべき？

判断フローチャート：

処理の即時性が必要？
├─ いいえ → Batch API (50%オフ) ✅
└─ はい
    ├─ 同じコンテキストを繰り返し使う？
    │   └─ はい → Prompt Caching (90%オフ) ✅
    └─ 複雑な推論が必要？
        ├─ はい → Extended Thinking (80%オフ) ✅
        └─ いいえ → 通常API

シーン	推奨テクニック	節約率
夜間バッチ処理	Batch API	50%
ドキュメント分析	Prompt Caching	90%
コード生成	Extended Thinking	80%
チャットボット	Prompt Caching	90%
画像大量分析	Batch API	50%
戦略立案	Extended Thinking	80%

📚 参考リンク

🐾 おわりに

和心村では、これらのテクニックを駆使して、28匹の猫と犬たちのAI分析を持続可能な形で運営しています。

「AIの力で、動物たちをもっと幸せに」

コスト削減は、その夢を実現するための大切な一歩です。

皆さんもぜひ、これらのテクニックを試してみてください。質問があれば、コメント欄でお気軽にどうぞ！

🐾 by 和心村 washinmura.jp

和牠一起，療癒全世界
ペットと一緒に、世界を癒そう

Claude #Anthropic #API節約 #AI開発 #LLM #機械学習 #Python #開発者 #プログラミング #技術共有 #コスト削減 #ClaudeAPI #AIツール #効率化 #技術tips #AnthropicAPI #AIコスト #開発効率 #テック #エンジニア

💰 Claude API 省錢大攻略：三招官方認證技巧，最高省 90%！

TK Lin — Tue, 27 Jan 2026 16:09:02 +0000

💰 Claude API 省錢大攻略：三招官方認證技巧，最高省 90%！

你還在用原價呼叫 Claude API 嗎？這篇文章可能幫你省下一台 MacBook 的錢！

🤯 真實案例：我們如何從月付 $500 降到 $50

大家好，我是 Nina！在和心村，我們用 AI 照顧 28 隻貓狗的日常記錄、影片製作、動物辨識... 每天要呼叫上千次 Claude API。

一開始，我們的 API 帳單長這樣：

2025年12月 API 帳單
├── Claude Opus 4.5:  $380
├── Claude Sonnet 4:  $120
└── 總計:             $500 💸

直到我們發現 Anthropic 官方其實藏了三個「省錢密技」...

現在？同樣的工作量，只要 $50！

讓我來告訴你怎麼做到的 👇

🎯 三大省錢技巧總覽

技巧	折扣幅度	適用場景	難度
Batch API	50% OFF	大量非即時任務	⭐ 簡單
Prompt Caching	90% OFF	重複使用長 Prompt	⭐⭐ 中等
Extended Thinking	~80% OFF	複雜推理任務	⭐⭐⭐ 進階

💡 技巧一：Batch API（50% 折扣）

什麼是 Batch API？

簡單說：把多個請求打包一起送，換取半價優惠。

Anthropic 會在 24 小時內處理完成，適合：

大量文章翻譯
批量圖片分析
數據清洗任務
每日報告生成

Python 代碼範例

import anthropic
import json

client = anthropic.Anthropic()

# 步驟 1: 準備批次請求
requests = []
for i, task in enumerate(tasks):
    requests.append({
        "custom_id": f"task-{i}",
        "params": {
            "model": "claude-sonnet-4-20250514",
            "max_tokens": 1024,
            "messages": [{"role": "user", "content": task}]
        }
    })

# 步驟 2: 建立批次任務
batch = client.batches.create(requests=requests)
print(f"批次 ID: {batch.id}")

# 步驟 3: 等待完成後取得結果
results = client.batches.results(batch.id)
for result in results:
    print(f"{result.custom_id}: {result.result.message.content}")

省錢效果

原價模式（即時 API）:
├── 1000 次呼叫 × $0.003 = $3.00

Batch API 模式:
├── 1000 次呼叫 × $0.0015 = $1.50
└── 節省: $1.50 (50%!) ✨

💡 技巧二：Prompt Caching（90% 折扣！）

這是什麼黑魔法？

當你的 Prompt 很長（例如包含整份說明文件、角色設定、範例對話），每次都重新傳送很浪費。

Prompt Caching 讓你把這些「固定部分」快取起來，之後只需要傳「變動部分」。

快取的 token 只收 10% 的價格！

適用場景

長篇 System Prompt（角色扮演、規則說明）
RAG 應用（每次都附上大量文件內容）
Few-shot Learning（大量範例）
連續對話（保持上下文）

Python 代碼範例

import anthropic

client = anthropic.Anthropic()

# 定義可快取的長 Prompt（需 >= 1024 tokens）
system_prompt = """
你是和心村的 AI 助手。和心村是一個日本的動物庇護所，
目前照顧 28 隻貓狗。你的任務是...
[這裡放 2000+ tokens 的詳細說明]
"""

# 使用 cache_control 標記可快取區塊
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": system_prompt,
            "cache_control": {"type": "ephemeral"}  # 🔑 關鍵！
        }
    ],
    messages=[
        {"role": "user", "content": "介紹一下 Jelly 這隻貓"}
    ]
)

# 查看快取命中狀態
print(f"快取寫入: {response.usage.cache_creation_input_tokens} tokens")
print(f"快取讀取: {response.usage.cache_read_input_tokens} tokens")

省錢效果

假設 System Prompt = 5000 tokens

無快取模式:
├── 每次呼叫: 5000 × $0.003 = $0.015
├── 100 次呼叫: $1.50

有快取模式:
├── 首次（寫入）: 5000 × $0.00375 = $0.01875
├── 後續（讀取）: 5000 × $0.0003 = $0.0015 × 99 次
├── 總計: $0.01875 + $0.1485 = $0.167
└── 節省: $1.33 (89%!) 🎉

注意事項

快取有效期：5 分鐘（每次讀取會重置）
最小快取長度：1024 tokens
標記位置：只能放在 system、tools、或 messages 最後一個 user turn

💡 技巧三：Extended Thinking（約 80% 折扣）

這是什麼？

Claude 的「深度思考」模式。開啟後，Claude 會先在內部進行詳細推理，再給出最終答案。

驚喜來了：思考過程的 token 只收 $5/M（輸出通常是 $15/M），等於打了約 67% 折扣！

而且因為思考更充分，常常可以用更少的來回對話完成任務，總成本反而更低。

適用場景

複雜數學/邏輯問題
程式除錯
多步驟規劃
需要深度分析的任務

Python 代碼範例

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000  # 給予思考預算
    },
    messages=[{
        "role": "user",
        "content": "分析這段程式碼的效能瓶頸並提出優化方案..."
    }]
)

# 分離思考過程和最終答案
for block in response.content:
    if block.type == "thinking":
        print(f"💭 思考過程: {block.thinking[:200]}...")
    elif block.type == "text":
        print(f"✅ 最終答案: {block.text}")

省錢效果

傳統模式（多輪對話解決複雜問題）:
├── 第1輪: 2000 tokens 輸入 + 1000 tokens 輸出
├── 第2輪: 3000 tokens 輸入 + 1500 tokens 輸出
├── 第3輪: 4500 tokens 輸入 + 2000 tokens 輸出
└── 總成本: ~$0.05

Extended Thinking 模式（一輪解決）:
├── 輸入: 2000 tokens
├── 思考: 8000 tokens @ $5/M = $0.04
├── 輸出: 1500 tokens @ $15/M = $0.0225
└── 總成本: ~$0.015 (節省 70%!) 🚀

📊 省錢報告：視覺化比較

╔════════════════════════════════════════════════════════════╗
║           💰 Claude API 省錢效果一覽                        ║
╠════════════════════════════════════════════════════════════╣
║                                                            ║
║  原價 API     ████████████████████████████████  100%       ║
║                                                            ║
║  Batch API    ████████████████                   50%       ║
║               (省 50%)                                     ║
║                                                            ║
║  Extended     ██████                             20%       ║
║  Thinking     (省 ~80%)                                    ║
║                                                            ║
║  Prompt       ███                                10%       ║
║  Caching      (省 90%!)                                    ║
║                                                            ║
╠════════════════════════════════════════════════════════════╣
║  🏆 最佳組合：Batch + Caching = 最高省 95%!                 ║
╚════════════════════════════════════════════════════════════╝

🎮 實戰組合技

情境 1：每日批量翻譯 1000 篇文章

# 組合：Batch API + Prompt Caching
# 預估省錢：50% + 45% = 72.5%

batch_requests = []
for article in articles:
    batch_requests.append({
        "custom_id": article.id,
        "params": {
            "model": "claude-sonnet-4-20250514",
            "max_tokens": 2000,
            "system": [{
                "type": "text",
                "text": TRANSLATION_SYSTEM_PROMPT,  # 快取這個！
                "cache_control": {"type": "ephemeral"}
            }],
            "messages": [{"role": "user", "content": article.content}]
        }
    })

batch = client.batches.create(requests=batch_requests)

情境 2：客服聊天機器人

# 組合：Prompt Caching + 對話快取
# 預估省錢：85-90%

# 快取 System Prompt + 公司知識庫
# 每次只傳新的用戶訊息

情境 3：程式碼審查

# 組合：Extended Thinking + Prompt Caching
# 預估省錢：80%

# 快取程式碼規範
# 用 Extended Thinking 深度分析

📝 省錢 Checklist

在呼叫 API 之前，問自己這三個問題：

[ ] 這個任務需要即時回應嗎？
- 不需要 → 用 Batch API (省 50%)
[ ] 有沒有重複使用的長 Prompt？
- 有 → 用 Prompt Caching (省 90%)
[ ] 這是複雜的推理任務嗎？
- 是 → 用 Extended Thinking (省 80%)

🐾 和心村的實際應用

在和心村，我們用這些技巧來：

動物辨識系統：用 Prompt Caching 快取 28 隻動物的特徵描述
每日影片製作：用 Batch API 批量生成腳本和文案
粉絲私訊回覆：用 Prompt Caching 保持一致的「村長」語氣

從月付 $500 降到 $50，省下來的錢夠買好多貓罐頭了！🐱

🔗 資源連結

GitHub Skill：claude-api-cost-optimization
官方文檔：Anthropic Docs
Batch API 指南：Message Batches
Prompt Caching 指南：Prompt Caching

🏷️ Hashtags

Claude #Anthropic #API省錢 #AI開發 #LLM #機器學習 #Python #開發者 #程式設計 #技術分享 #省錢技巧 #ClaudeAPI #AI工具 #效率提升 #技術乾貨 #Claude4 #APIOptimization #CostReduction #AIEngineering #Prompt工程 #BatchProcessing #開發技巧 #雲端省錢 #技術博客 #AI實戰

🐾 by 和心村 washinmura.jp

和心村是日本的動物庇護所，目前照顧 28 隻貓狗。我們用 AI 記錄每一隻毛孩的故事，讓牠們被全世界看見。

「和牠一起，療癒全世界」

💬 有問題歡迎留言討論！如果這篇文章幫到你，請分享給其他開發者朋友 🙏

💰 How to Save 90% on Claude API Costs: 3 Official Techniques

TK Lin — Tue, 27 Jan 2026 16:08:51 +0000

💰 How to Save 90% on Claude API Costs: 3 Official Techniques You're Missing

Did you know most developers are overpaying for Claude API by 50-90%?

I discovered this the hard way. Running an AI-powered animal recognition system for 28 cats and dogs at Washin Village (a rural sanctuary in Japan), I was burning through API credits faster than my cats go through treats.

Then I found three official Anthropic techniques that slashed my costs dramatically. No hacks. No workarounds. Just features hiding in plain sight.

Let me show you how to keep more money in your pocket.

📊 The Cost Problem

Here's what typical Claude API usage looks like:

Model	Input (per 1M tokens)	Output (per 1M tokens)
Claude Sonnet 4	$3.00	$15.00
Claude Opus 4	$15.00	$75.00

For production apps processing thousands of requests daily, these costs add up fast.

But Anthropic offers three official ways to dramatically reduce these costs. Let's dive in.

🥇 Technique 1: Batch API (50% Off)

Best for: Non-urgent tasks, bulk processing, overnight jobs

The Batch API lets you submit up to 100,000 requests at once and get results within 24 hours—at half the price.

How It Works

import anthropic
import json

client = anthropic.Anthropic()

# Create a batch request
batch = client.batches.create(
    requests=[
        {
            "custom_id": "request-001",
            "params": {
                "model": "claude-sonnet-4-20250514",
                "max_tokens": 1024,
                "messages": [
                    {"role": "user", "content": "Summarize this article..."}
                ]
            }
        },
        {
            "custom_id": "request-002",
            "params": {
                "model": "claude-sonnet-4-20250514",
                "max_tokens": 1024,
                "messages": [
                    {"role": "user", "content": "Translate this text..."}
                ]
            }
        }
        # Add up to 100,000 requests!
    ]
)

print(f"Batch ID: {batch.id}")
print(f"Status: {batch.processing_status}")

Check Batch Status

# Poll for completion
batch_status = client.batches.retrieve(batch.id)

if batch_status.processing_status == "ended":
    # Download results
    results = client.batches.results(batch.id)
    for result in results:
        print(f"{result.custom_id}: {result.result.message.content}")

When to Use Batch API

Use Case	Savings
Nightly data processing	50%
Bulk content generation	50%
Dataset labeling	50%
Non-real-time analysis	50%

Pro tip: Queue up your batch jobs during off-peak hours for fastest processing.

🥈 Technique 2: Prompt Caching (Up to 90% Off!)

Best for: Repetitive prompts, long system prompts, RAG applications

This is the biggest money saver. If you're sending the same system prompt or context repeatedly, you're literally throwing money away.

The Magic Numbers

Token Type	Cost Reduction
Cache Write	+25% (one-time)
Cache Read	-90%

After the initial cache write, every subsequent read costs just 10% of normal input pricing.

Implementation

import anthropic

client = anthropic.Anthropic()

# Your long system prompt (must be 1,024+ tokens for Sonnet)
SYSTEM_PROMPT = """
You are an expert veterinary AI assistant specializing in cat and dog health.
You have extensive knowledge about:
- 50+ cat breeds and their specific health concerns
- 80+ dog breeds and their characteristics
- Common symptoms and when to seek emergency care
- Nutrition guidelines for different life stages
- Behavioral analysis and training tips
... [imagine 2000+ more tokens of context]
"""

# First request: Creates the cache (costs +25%)
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": SYSTEM_PROMPT,
            "cache_control": {"type": "ephemeral"}  # <-- The magic flag!
        }
    ],
    messages=[
        {"role": "user", "content": "My cat is sneezing. Should I worry?"}
    ]
)

# Check cache performance
print(f"Cache created: {response.usage.cache_creation_input_tokens} tokens")
print(f"Cache read: {response.usage.cache_read_input_tokens} tokens")

Subsequent Requests (90% Savings!)

# All future requests with the same system prompt
# automatically use the cache at 90% discount!

response2 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": SYSTEM_PROMPT,  # Same prompt = cache hit!
            "cache_control": {"type": "ephemeral"}
        }
    ],
    messages=[
        {"role": "user", "content": "What vaccines does my puppy need?"}
    ]
)

# This request costs 90% less for the system prompt!

Cache Requirements

Model	Minimum Tokens
Claude Sonnet 4	1,024 tokens
Claude Opus 4	2,048 tokens
Claude Haiku	2,048 tokens

Important: Cache expires after 5 minutes of inactivity. Keep it warm with periodic requests if needed.

🥉 Technique 3: Extended Thinking (~80% Off on "Thinking")

Best for: Complex reasoning, math problems, coding tasks

Claude's Extended Thinking feature lets the model "think" before responding. The brilliant part? Thinking tokens are heavily discounted.

Cost Comparison

Token Type	Sonnet Price (per 1M)
Regular Output	$15.00
Thinking Tokens	$3.00 (same as input!)

That's an 80% discount on the reasoning process!

Implementation

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000  # Allow up to 10K thinking tokens
    },
    messages=[
        {
            "role": "user",
            "content": "Analyze this codebase and suggest optimizations..."
        }
    ]
)

# Access the thinking process
for block in response.content:
    if block.type == "thinking":
        print(f"💭 Thinking: {block.thinking[:200]}...")
    elif block.type == "text":
        print(f"📝 Response: {block.text}")

When Extended Thinking Shines

Task	Benefit
Complex debugging	Better accuracy at lower cost
Mathematical proofs	Step-by-step reasoning
Architecture decisions	Thorough analysis
Code refactoring	Comprehensive review

🚀 Combining Techniques: The Ultimate Savings Stack

Here's where it gets exciting. You can combine these techniques!

Batch + Caching = 95% Savings

# Batch API (50% off) + Prompt Caching (90% off on cached portion)
# Result: Massive savings on bulk processing with repeated context

batch_requests = []

for i, user_query in enumerate(thousands_of_queries):
    batch_requests.append({
        "custom_id": f"query-{i}",
        "params": {
            "model": "claude-sonnet-4-20250514",
            "max_tokens": 1024,
            "system": [
                {
                    "type": "text",
                    "text": LONG_SYSTEM_PROMPT,
                    "cache_control": {"type": "ephemeral"}
                }
            ],
            "messages": [
                {"role": "user", "content": user_query}
            ]
        }
    })

# Submit batch with caching enabled
batch = client.batches.create(requests=batch_requests)

Real-World Savings Calculator

Scenario	Standard Cost	With Optimizations	Savings
10K requests, 2K system prompt	$60	$9	85%
Batch processing 100K items	$500	$50	90%
RAG with 5K context	$150	$22.50	85%

📋 Quick Reference Cheat Sheet

┌─────────────────────────────────────────────────────────┐
│           CLAUDE API COST OPTIMIZATION                  │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  🕐 Can wait 24 hours?                                  │
│     └─→ Use BATCH API (50% off)                        │
│                                                         │
│  🔄 Repeating same prompt?                              │
│     └─→ Use PROMPT CACHING (90% off reads)             │
│                                                         │
│  🧠 Need complex reasoning?                             │
│     └─→ Use EXTENDED THINKING (80% off thinking)       │
│                                                         │
│  💡 Combine them all for maximum savings!               │
│                                                         │
└─────────────────────────────────────────────────────────┘

🎯 Action Items

Audit your current usage - Check which requests could be batched
Identify repeated prompts - System prompts over 1K tokens are caching candidates
Enable extended thinking - For complex tasks, let Claude think cheaply
Monitor your savings - Track cache_read_input_tokens in responses

🐾 Our Story

At Washin Village, we run AI-powered recognition for 28 cats and dogs living in our rural Japanese sanctuary. These cost optimization techniques help us:

Process thousands of animal photos daily
Generate personalized content for each pet
Keep our AI services running sustainably

Every yen saved goes back to caring for our furry friends!

📚 Resources

💬 Let's Connect

Found this helpful? I'd love to hear how much you've saved!

Drop a comment below with your results
Share your own optimization tips
Follow for more AI cost-saving strategies

Made with 💰 by Washin Village (washinmura.jp) - Where 28 cats & dogs inspire better AI

claude #anthropic #api #costoptimization #llm #ai #machinelearning #python #developers #programming #tech #savings #tips #claudeapi #aitools #devops #backend #startup #buildinpublic #opensource

🐾 無限の恩返し：10エージェント並列研究スキル（この記事もスキルで作成！）

TK Lin — Tue, 27 Jan 2026 14:11:57 +0000

🤯 メタな話

この記事は「無限の恩返し」スキル自体を使って作成されました！

10個のエージェントを派遣して宣伝コンテンツを作成し、これはそのうちの一つです。

🐾 無限の恩返しとは？

猫がお土産を持ち帰るように、AIエージェントが発見を持ち帰る。

📊 実績

10エージェント並列実行
3波の調査
9つの研究レポート
77.6% → 84.91% 精度達成

🏠 誕生ストーリー

房総半島の「和心村」には28匹の猫と犬が暮らしています。

🚀 使い方

git clone https://github.com/sstklen/infinite-gratitude

GitHub: https://github.com/sstklen/infinite-gratitude

Made with 🐾 by 和心村 - ペットと一緒に、世界を癒そう

🐾 無限報恩：這篇文章本身就是用這個 Claude Code Skill 寫的！

TK Lin — Tue, 27 Jan 2026 14:10:14 +0000

🤯 Meta 的部分

這篇文章是用「無限報恩」Skill 本身創建的！

我們派出 10 個代理去寫宣傳內容，這是他們帶回來的禮物之一。

🐾 什麼是無限報恩？

貓咪會把「禮物」叼回家給主人。AI 代理也一樣——出門調查，帶回發現。

📊 實際成果

10 個代理平行執行
3 波調查
9 份研究報告
準確率從 77.6% 提升到 84.91%

🏠 起源故事

日本房總半島的「和心村」住著 28 隻貓狗。

做 AI 辨識平台時，要查的東西太多了，一個人根本查不完。

於是我們讓 AI 代理像村裡的貓狗一樣工作：出門、帶禮物回家、重複。

🚀 開始使用

git clone https://github.com/sstklen/infinite-gratitude

🔗 GitHub

https://github.com/sstklen/infinite-gratitude

Made with 🐾 by 和心村

和牠一起，療癒全世界

🐾 Infinite Gratitude: Multi-Agent Research with Claude Code (This Article Was Made BY the Skill!)

TK Lin — Tue, 27 Jan 2026 14:09:46 +0000

Ever wished you could research 10x faster?

We built Infinite Gratitude - a Claude Code skill that deploys 10 agents in parallel to research any topic.

🤯 The Meta Part

This very article was created using the Infinite Gratitude skill itself!

We dispatched 10 agents to write promotional content, and this is one of the gifts they brought back.

📊 Real Results

10 agents working in parallel
3 waves of investigation
9 comprehensive reports
77.6% → 84.91% accuracy achieved for pet recognition

🐾 Origin Story

In Japan's Boso Peninsula, 28 cats and dogs live in "Washin Village." When building their AI recognition platform, we needed to research tons of technology.

So we let AI agents work like village pets: go out, bring gifts back, repeat.

The name comes from how cats bring "gifts" home to their owners - that's gratitude in cat language!

🚀 Try It

git clone https://github.com/sstklen/infinite-gratitude

🔗 Links

GitHub: https://github.com/sstklen/infinite-gratitude
Languages: English, Japanese, Chinese

Made with 🐾 by Washin Village

"Heal the world, together with your pet"

🐾 Infinite Gratitude: Multi-Agent Research with Claude Code (Made BY the Skill!)

TK Lin — Tue, 27 Jan 2026 14:07:10 +0000

Ever wished you could research 10x faster?

We built Infinite Gratitude - a Claude Code skill that deploys 10 agents in parallel to research any topic.

The Meta Part 🤯

This very article was created using the Infinite Gratitude skill! We dispatched 10 agents to write promotional content, and this is one of the gifts they brought back.

Real Results

10 agents working in parallel
3 waves of investigation
9 comprehensive reports
77.6% → 84.91% accuracy achieved

Origin Story

In Japan's Boso Peninsula, 28 cats and dogs live in "Washin Village." When building their AI recognition platform, we needed to research tons of technology.

So we let AI agents work like village pets: go out, bring gifts back, repeat.

Try It

git clone https://github.com/sstklen/infinite-gratitude

GitHub: https://github.com/sstklen/infinite-gratitude

Made with 🐾 by Washin Village - "Heal the world, together with your pet"

DEV Community: TK Lin

Give your book a machine-verifiable identity: JSON-LD, llms.txt, SHA-256 ledgers and Ed25519 signatures

Why AI needs a verifiable bibliography

Step 1: JSON-LD with one #work and four editions

Step 2: llms.txt and brief.txt

Step 3: a ledger of sizes and SHA-256 hashes

Step 4: sign the ledger, not the binaries

Step 5: how a reader verifies

Check a file

Check the ledger signature

Step 6: two kinds of DOI

Recap

112 Battle-Tested Claude Code Skills — Every Bug Fix That Cost Me Hours So It Won't Cost You

The Solution: Skills as Muscle Memory

The Categories

Docker and Deployment (12 skills)

Database and SQLite (10 skills)

API and Backend (15 skills)

AI and LLM (8 skills)

Frontend and UI (6 skills)

Debugging and Workflow (10 skills)

Installation

Before vs After: A Real Example

Skill Format

A Note on Stack Compatibility

The Philosophy

実戦で鍛えた 112 の Claude Code Skills — 何時間もかけたバグ修正を、あなたは繰り返さなくていい

解決策：Skills = AI の筋肉記憶

カテゴリ一覧

Docker とデプロイ（12 個）

データベースと SQLite（10 個）

API とバックエンド（15 個）

AI と LLM（8 個）

フロントエンドと UI（6 個）

デバッグとワークフロー（10 個）

インストール

Before vs After：実例

Skill フォーマット

スタック互換性について

哲学

112 個實戰淬煉的 Claude Code Skills — 每個讓我踩坑數小時的 Bug 修復，讓你不必再踩

解法：Skills = AI 的肌肉記憶

分類總覽

Docker 與部署（12 個）

資料庫與 SQLite（10 個）

API 與後端（15 個）

AI 與 LLM（8 個）

前端與 UI（6 個）

除錯與工作流（10 個）

安裝

前後對比：真實案例

Skill 格式

Stack 適用性說明

哲學

🎬 Behavior_Recognition

Behavior Recognition: Teaching Machines to Understand What Cats Are Doing

🎯 From "Who Is This" to "What Are They Doing"

📊 Behavior Categories We Defined

💻 Technical Approaches

Approach 1: Single-Frame Classification

Approach 2: Sequence Analysis

📈 Data Preparation

Labeling Process

Data Statistics

🔧 Training Configuration

📊 Expected Results

🎬 Real Applications

1. Automatic Video Classification

2. Smart Editing

3. Health Monitoring

💡 Lessons Learned

🔮 Future Development

💰 Claude API コスト削減術：公式テクニックで最大90%節約！

💰 Claude API コスト削減術：公式テクニックで最大90%節約！

🎯 はじめに：なぜコスト削減が重要なのか

📊 三大節約テクニック

1️⃣ Batch API（50%オフ）

適用シーン

Python コード例

💡 ポイント

Step 1: JSON-LD with one `#work` and four editions