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
Top comments (2)
The "amnesiac AI" framing is spot on. I hit the exact same wall building a finance planning tool (React + IndexedDB, 160+ commits). Every new session, Claude would suggest adding a backend for data persistence — even though the entire architecture decision was "zero server, browser only."
What I found: the skill/memory approach works, but the real multiplier was constraining the architecture surface area first. When there's no server, no database connection, no API layer — there's simply less to get wrong between sessions. The AI can't suggest "just add a Postgres connection" when the project literally has no server dependency.
For the Docker SQLite WAL trap specifically — curious if you considered embedding the "stop writes first" constraint as a pre-commit hook or CI check rather than a skill? Skills rely on Claude remembering to load them, but a CI gate catches it even when the skill doesn't fire.
The rural Japan animal sanctuary detail is great. Running 39 services from there sounds like a story worth its own post.
Question: with 112 skills, do you hit context window limits? I imagine loading even 20% of them into a single session would eat significant tokens.
Some comments may only be visible to logged-in visitors. Sign in to view all comments.