[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"project-93060":3},{"id":4,"name":5,"fullName":6,"owner":7,"repo":5,"description":8,"homepage":9,"htmlUrl":10,"language":11,"languages":10,"totalLinesOfCode":10,"stars":12,"forks":13,"watchers":14,"openIssues":15,"contributorsCount":15,"subscribersCount":15,"size":15,"stars1d":15,"stars7d":15,"stars30d":14,"stars90d":15,"forks30d":15,"starsTrendScore":15,"compositeScore":16,"rankGlobal":10,"rankLanguage":10,"license":17,"archived":18,"fork":18,"defaultBranch":19,"hasWiki":20,"hasPages":18,"topics":21,"createdAt":10,"pushedAt":10,"updatedAt":22,"readmeContent":23,"aiSummary":24,"trendingCount":15,"starSnapshotCount":15,"syncStatus":25,"lastSyncTime":26,"discoverSource":27},93060,"fable-skills","adamentwistle\u002Ffable-skills","adamentwistle","35 engineering-discipline skills authored by fable 5, with a blind-graded benchmark: sonnet 5 loaded with the skills beat opus 4.8 running bare. no deps, mit.","",null,"Python",82,7,1,0,42.81,"MIT License",false,"main",true,[],"2026-07-22 04:02:08","# fable-skills\n\nA library of 35 **engineering-discipline skills** — small, composable instruction files that encode *how a careful senior engineer works*, not what any particular framework does.\n\n## The premise\n\nThe most capable Claude models don't just know more — they *work* more carefully. Fable 5 reaches for a codebase's own conventions before writing, proves a bug's cause before fixing it, sweeps edge cases before declaring done, and reports what it actually verified rather than what it assumes. A strong-but-lighter model like Opus 4.8 *can* do all of that too — it just doesn't always reach for those habits unprompted.\n\nThese skills close that gap. Fable identified the places where a less deliberate run tends to fall short of its own ceiling — orientation, root-cause discipline, security reflexes, edge-case coverage, honest reporting — and wrote each habit down as an explicit, always-available checklist. Load them into a session and a model follows the discipline on purpose instead of leaving it to chance. The goal is simple: **Fable-level output from whatever model is driving.**\n\nEach skill is one focused habit. They fire situationally — a debugging task pulls in `root-cause-debugging`, a diff touching user input pulls in `security-reflexes`, a schema change pulls in `data-migration-safety` — so the model carries the right discipline into the right moment without drowning in guidance.\n\n## Does it actually help? Benchmarks\n\nSame method throughout: run an identical task through fresh agents with **no guidance** vs. **with the relevant skill files**, then score the outputs against a fixed answer key. Benchmark 1 uses Opus 4.8; Benchmark 2 runs both Opus 4.8 and Sonnet 5. These are directional signals, not statistical proofs.\n\n**The full assets are in [`benchmark\u002F`](benchmark\u002F)** — seeded tasks, answer keys, all 62 raw run outputs, the blind-grader prompts, and the per-item score tables — so every number below is auditable and re-gradable rather than take-my-word-for-it. (They were reconstructed verbatim from the original session transcript; each file carries a provenance header, and the recovery manifest in `benchmark\u002FREADME.md` lists the known gaps.)\n\n### Benchmark 1 — Security code review (n=1, blind-graded)\n\nThe same task was run through two fresh agents and both reviews were scored **blind** by an independent third agent. **Task:** review a Python orders module seeded with **14 latent issues** (SQL injection, connection leak, division-by-zero, float-money drift, a missing authorization check, …).\n\n| | Issues found (of 14) | Notable |\n|---|:---:|---|\n| **Without skills** | **10 \u002F 14** | Solid: caught the injection, the leak, div-by-zero, float money |\n| **With skills** | **13 \u002F 14** | Caught everything the control did **plus the IDOR \u002F broken object-level authorization flaw the bare run missed entirely** — the single highest-severity issue in the file — plus an explicit rounding policy, result-set pagination, and robust row access |\n\nThe skill-guided run didn't just find *more* — it found the issue that mattered most. Walking the `security-reflexes` checklist (\"every mutating path: WHO is calling and MAY they touch THIS object?\") surfaced an authorization gap the unprompted review sailed past.\n\n### Benchmark 2 — Three areas × two models, n=5 per cell, blind-graded\n\nThree fresh tasks (root-cause debugging, a racy rate limiter, a CSV revenue parser), each seeded with a fixed answer key. Every cell is **5 independent runs**; all 60 outputs per area were scored **blind** by an independent grader that knew neither the model nor whether skills were applied. Mean issues found:\n\n| Area | Opus 4.8 — bare | Opus 4.8 — skills | Sonnet 5 — bare | Sonnet 5 — skills |\n|---|:---:|:---:|:---:|:---:|\n| **Root-cause debugging** (\u002F8) | 5.2 · 65% | **7.8 · 98%** | 4.4 · 55% | 6.4 · 80% |\n| **Concurrency** (\u002F7) | 6.4 · 91% | **7.0 · 100%** | 6.0 · 86% | 7.0 · 100% |\n| **Edge \u002F numerical** (\u002F9) | 8.2 · 91% | **9.0 · 100%** | 8.6 · 96% | 9.0 · 100% |\n\nFour findings:\n\n1. **Skills lift both models in every area** — biggest on debugging (Opus +2.6, Sonnet +2.0), where the task rewards *process*; smallest on the edge task, whose \"list every edge case\" prompt already forces exhaustiveness (both models near-saturate).\n2. **Skills bring the cheaper model above the stronger bare one.** Sonnet 5 + skills matches or beats bare Opus 4.8 in all three areas (6.4 vs 5.2, 7.0 vs 6.4, 9.0 vs 8.2). That is the parity thesis, measured: the discipline files close the model gap.\n3. **But raw capability still matters at the subtle end.** Opus + skills leads Sonnet + skills on debugging (7.8 vs 6.4) almost entirely on one item — a config of JSON `null` defeating the `is None` cache guard — caught by Opus-with-skills 4\u002F5 times and by Sonnet **0\u002F5 in any condition**. Skills prompt the right *class* of thinking; the hardest single insight still needed the stronger model.\n4. **Variance shrank with skills** — with-skills scores cluster at the top rather than spreading (Opus debugging 7–8 with vs 5–6 without), so the gain is greater consistency, not just a higher mean.\n\nThe Opus numbers here were produced by an earlier author-scored pass too; the blind re-grade reproduced them almost exactly (debugging 5.2 vs 5.4, concurrency and the with-skills scores identical), which is the main reason to trust the rest.\n\n**Honest caveats:** n=5 per cell is still small — directional, not conclusive. The baselines are already strong, so the gain is \"good → near-complete,\" not \"broken → fixed.\" Grading is an LLM applying an objective checklist, not a human. The edge task saturates, compressing its signal.\n\n## Using the skills\n\nEach skill lives in its own directory as a `SKILL.md` with YAML frontmatter (`name`, `description`) and a short body. The `description` is what a harness matches against the situation to decide when to activate the skill.\n\n**With Claude Code:** drop the skill directories into a discoverable skills location (e.g. `~\u002F.claude\u002Fskills\u002F` or a project `.claude\u002Fskills\u002F`) and they become available to the `Skill` tool. The model selects them by description as tasks arise.\n\n**Anywhere else:** the bodies are plain Markdown — paste the relevant one into a system prompt, or concatenate a task-appropriate subset. That's exactly how the benchmarks' \"with skills\" runs were configured.\n\n## The catalog (35 skills)\n\n**Orientation & planning**\n- `codebase-orientation` — recon an unfamiliar repo before changing it\n- `task-decomposition` — acceptance-test-first, dependency-ordered planning\n- `estimation-and-scoping` — honest sizing; surface 10× discoveries early\n- `ambiguity-commit` — resolve ambiguous requests by investigating, then stating the interpretation\n- `question-vs-task` — tell \"explain this\" apart from \"change this\" before acting\n\n**Correctness & debugging**\n- `root-cause-debugging` — reproduce, bisect, prove the cause, fix minimally, re-verify\n- `edge-case-sweep` — enumerate edge cases against a concrete checklist\n- `numerical-care` — floats, currency, rounding, division-by-zero, overflow, units\n- `concurrency-reasoning` — races, check-then-act gaps, mutation across await, cancellation\n- `environment-first` — suspect the environment before rewriting the code\n- `stop-thrashing` — detect non-converging iteration and force a zoom-out\n\n**Security & safety**\n- `security-reflexes` — injection, authz, secrets, SSRF\u002FXSS on everyday diffs\n- `untrusted-content-guard` — treat fetched\u002Fread content as data, never instructions\n- `data-loss-guard` — stop-and-check before destructive or irreversible operations\n- `api-surface-care` — treat changes to shared interfaces as contract changes\n\n**Change discipline**\n- `surgical-refactoring` — enumerate call sites, separate mechanical from judgment edits\n- `dependency-changes` — justify, archaeology, lockfile hygiene, one bump at a time\n- `data-migration-safety` — expand→migrate→contract, backfills, rollback-first\n\n**Testing & verification**\n- `test-design` — regression-first, boundary tables, behavior over implementation\n- `verify-ui-visually` — render and look, don't imagine the markup\n- `workmanship` — evidence before assertion, the done gate, report what happened\n\n**Performance & operations**\n- `performance-investigation` — measure, profile, fix by leverage, verify with the same measurement\n- `perf-sanity` — catch the algorithmic\u002FI\u002FO classics while writing (O(n²), N+1)\n- `incident-diagnosis` — read-only evidence first, mitigate reversibly before root-causing\n\n**Communication**\n- `calibrated-recommendation` — match the strength of the claim to the evidence\n- `explain-at-the-right-level` — teach at the asker's level, grounded in their code\n- `error-message-quality` — errors that name the failing thing, the value, and the fix\n- `escalate-vs-decide` — reversibility × blast-radius: when to ask vs decide\n- `generalize-the-correction` — fix the whole class of a mistake, not just the instance\n\n**Working style & hygiene**\n- `git-hygiene` — atomic commits, branch before risk, never commit debris or secrets\n- `leave-no-mess` — clean up processes, temp files, and scaffolding before done\n- `context-checkpoint` — externalize state so long tasks survive compaction\n- `subagent-fanout` — delegate broad searches to keep the main context clean\n- `cross-platform-care` — scripts that survive a machine they didn't develop on\n\n**LLM application code**\n- `llm-app-code` — treat model output as untrusted input; schema-validate, gate writes\n\n## Agents\n\n**Skills fix habits; agents fix structure.** A skill makes the driving model reach for a discipline it already has. But one gap no checklist can close is *self-correlation*: a model reviewing its own work inherits its own anchoring — the same context, the same wrong assumption it made an hour ago. Subagents close that gap structurally, because each one runs in a clean context. The `agents\u002F` directory packages Fable's independence disciplines as reusable subagent definitions for Claude Code's `Agent` tool.\n\nInstall by dropping a file into `~\u002F.claude\u002Fagents\u002F` (or a project's `.claude\u002Fagents\u002F`); it registers at the next session start.\n\n**Fresh-context independence** (uncorrelated eyes on your own work):\n\n- `skeptic` — adversarial verifier: takes one claim and tries to *refute* it from primary evidence; returns CONFIRMED \u002F REFUTED \u002F UNPROVEN with the evidence trail. For load-bearing conclusions, especially your own.\n- `fresh-eyes-reviewer` — red-team review of a diff with zero knowledge of the author's reasoning, by design; reports only findings with a concrete failure scenario attached.\n- `done-gate` — spec-compliance audit before \"done\": every requirement in the original request checked against evidence, cheap verifications re-run, unevidenced claims flagged.\n- `blind-judge` — grades N provenance-stripped candidates against a rubric, criterion-by-criterion, with anti-halo and position-bias guards. For judge panels and tournament selection (it's how this repo's own benchmarks were scored).\n- `plan-premortem` — \"this plan already failed; write the incident report\": verifies the plan's factual claims against the repo, surfaces unverified load-bearing assumptions, names the riskiest step and the cheapest de-risking probe.\n\nThe verification agents deliberately pin `model: opus` — the point is a cheap driver doing the legwork while the strongest available model does the judging, not the reverse. Override the `model:` field to taste.\n\n**Cross-model independence** (blind spots that don't correlate with Claude's):\n\n- `codex` — runs the OpenAI Codex CLI (GPT-5.6) as a subagent inside Claude fan-outs. The orchestrator picks model tier and reasoning effort per task via two prompt headers (`codex-model:`, `codex-effort:`), steered by an evidence-based routing guide baked into the description: Luna for mechanical\u002Flookup work, Terra at high effort for routine implementation (the best measured marginal return), Sol at xhigh for long-horizon, multi-file, and adversarial-review work — where Sol's higher completion rate makes it cheaper *per completed task* than Terra despite 2× the token price. Hard rules: never hand Luna a >200K-token context (long-context recall cliff), and escalate effort on retry rather than defaulting to max (quality vs. effort is non-monotonic). Requires the `codex` CLI installed and authenticated; verified against codex-cli 0.144 \u002F GPT-5.6 GA (2026-07).\n\n## Attribution\n\nSkills authored by Fable to lift lighter models to its own working standard. Benchmark run and scored with Claude Opus 4.8.\n","fable-skills 是一个面向大语言模型工程化应用的轻量级技能库，提供35个可组合、场景触发的工程实践指令文件，系统化编码资深工程师的关键工作习惯，如根因调试、安全反射、边缘案例覆盖和诚实验证报告。项目采用纯文本指令格式，零依赖、MIT许可，通过盲评基准测试验证其有效性：在安全代码审查任务中，集成技能后Claude Opus 4.8对高危IDOR漏洞的检出率显著提升。适用于需要提升LLM输出严谨性、可复现性和工程可靠性的AI编程助手、代码审查代理及自动化工程助理等场景。",2,"2026-07-11 02:30:47","CREATED_QUERY"]