fable5-methodology

In the author's own words, from each skill's SKILL.md.

• architecture-decisions

  Choose between competing technical approaches and make design decisions with an explicit trade-off order. Trigger this when a task requires selecting among 2+ viable designs — "should we use X or Y", designing a schema, shaping a public API, choosing a storage/queue/cache mechanism, deciding whether to add a dependency, or deciding whether to introduce an abstraction. Do NOT trigger for initial r…

  skills/architecture-decisions/SKILL.md on GitHub (opens in a new tab)

• code-review

  Review a diff or pull request — including your own before delivery — in a fixed pass order (correctness, then safety/security, then design, then style) and report findings ranked by severity. Trigger this when asked to review a PR or diff, when checking over a change before committing or handing it off, and as the design-and-correctness half of your own pre-delivery review. Do NOT trigger for the…

  skills/code-review/SKILL.md on GitHub (opens in a new tab)

• codebase-exploration

  Map an unfamiliar repository before changing anything in it — structure sweep, entry points, configs, test baseline, targeted tracing, and mental-model confirmation. Trigger this the FIRST time you work in a repo (or an unfamiliar subsystem of a known repo) in a session, before your first edit there — whenever the user says "fix/add/change X" in code you have not yet mapped. Do NOT trigger for re…

  skills/codebase-exploration/SKILL.md on GitHub (opens in a new tab)

• context-economy

  Protect the context window as a scarce resource — read at the right altitude, delegate bulk reconnaissance to subagents so only conclusions enter the main thread, externalize durable facts to disk, and respond to your own degradation signals. Trigger this when about to read a large file or many files, when a search/log-dig would flood the conversation with content you won't reference again, when…

  skills/context-economy/SKILL.md on GitHub (opens in a new tab)

• course-correction

  Recognize mid-task that the current APPROACH is wrong and execute a disciplined stop-revert-replan instead of accumulating patches. Trigger this when any alarm fires during ongoing work: your last two changes each fixed the previous change's symptom; the design keeps growing special cases; you're fighting or monkey-patching the framework; a "small fix" now spreads across many files; you can't exp…

  skills/course-correction/SKILL.md on GitHub (opens in a new tab)

• debugging-methodology

  Step-by-step procedure for diagnosing and fixing failures — reproduce, read, hypothesize, bisect, fix, regression-test. Trigger this whenever something does not work as expected — a bug report, a failing or flaky test, a crash, an error message, wrong output, "it worked yesterday", or unexpected behavior during your own implementation. Trigger BEFORE proposing any fix. Do NOT trigger for building…

  skills/debugging-methodology/SKILL.md on GitHub (opens in a new tab)

• dependency-changes

  Add, upgrade, or migrate third-party dependencies safely — read the changelog for the exact version jump, isolate the change, run full verification, and keep rollback ready. Trigger this when the task involves bumping a package version, adding a new dependency, replacing one library with another, resolving a dependency vulnerability, or a lockfile update. Do NOT trigger for using an already-insta…

  skills/dependency-changes/SKILL.md on GitHub (opens in a new tab)

• extended-problem-solving

  Externalize reasoning to a scratchpad file for problems too large to hold in working memory — a persistent record of candidate approaches, eliminated branches and WHY they were eliminated, open questions, and current best hypothesis, updated as understanding evolves. Trigger this when a problem has more moving parts or branches than you can track in-context: multi-day investigations, complex desi…

  skills/extended-problem-solving/SKILL.md on GitHub (opens in a new tab)

• git-discipline

  Rules for commits, branches, diffs, and history when working in a git repository — checkpoint strategy, pre-commit diff review, message format, and the hard prohibitions on destructive operations. Trigger this whenever work happens in a git repo and involves staging, committing, branching, or any history-affecting command; before EVERY commit; and the moment you are tempted to run force-push, res…

  skills/git-discipline/SKILL.md on GitHub (opens in a new tab)

• implementation-standards

  Concrete coding conventions to apply WHILE writing or editing code — naming, function/file size, error handling, input validation, types, comments, tests, and secrets. Trigger this whenever you are about to write new code or modify existing code in any language, including tests and scripts. Do NOT trigger for choosing between designs (use architecture-decisions), for diagnosing failures (use debu…

  skills/implementation-standards/SKILL.md on GitHub (opens in a new tab)

• incremental-delivery

  Build large multi-part deliverables — multi-file projects, migrations, long documents, N-of-the-same-thing work — in verified increments with dependency ordering, checkpoints, a running state note, and consistency sweeps. Trigger this when a task will produce 3+ files, spans more sub-deliverables than fit in one pass, involves repeating a pattern across many sites (endpoints, parsers, pages, reco…

  skills/incremental-delivery/SKILL.md on GitHub (opens in a new tab)

• integrity-guardrails

  Compact honesty and safety guardrails that apply to ANY task involving file modification, command execution, or reporting results — the absolutes on claiming success, fabricating output, silencing tests, dropping requirements, destructive commands, scope, and secrets. Trigger this on effectively every working task: before running commands that change state, before every commit, and before every m…

  skills/integrity-guardrails/SKILL.md on GitHub (opens in a new tab)

• legacy-debugging

  Debug code you didn't write and can't fully trust — unfamiliar, poorly documented, or untested subsystems — using history archaeology, boundary instrumentation, minimal harnesses, and history bisection, while resisting the urge to rewrite. Trigger this when a failure lives in code that is foreign to you AND lacks reliable documentation or tests: inherited services, vendored code, an unowned modul…

  skills/legacy-debugging/SKILL.md on GitHub (opens in a new tab)

• performance-optimization

  Make code measurably faster or leaner without breaking it — define a target, measure a baseline, profile to find the ACTUAL bottleneck, apply optimizations in a fixed order of leverage, and re-verify correctness after each change. Trigger this when the user reports slowness, high latency, memory growth, or cost, sets a performance budget, or asks to "optimize" or "speed up" something. Do NOT trig…

  skills/performance-optimization/SKILL.md on GitHub (opens in a new tab)

• predictive-execution

  The ambient execution discipline — predict the outcome of every consequential command BEFORE running it and treat any surprise (better or worse) as a model error to investigate; choose the next action by information gain; estimate blast radius before touching anything shared. Trigger this continuously during hands-on work: before running a command/test/query whose outcome matters, when choosing a…

  skills/predictive-execution/SKILL.md on GitHub (opens in a new tab)

• problem-framing

  Shape a problem before solving it — check the premise (XY problems, false dichotomies), find the canonical name for the problem shape, locate the hard kernel, and factor fuzzy asks into orthogonal decisions. Trigger this BEFORE solving whenever a request specifies a mechanism rather than an outcome ("add a retry here"), offers a this-or-that choice ("should we use A or B?"), poses a fuzzy design/…

  skills/problem-framing/SKILL.md on GitHub (opens in a new tab)

• research-and-verification

  Verify version-sensitive and time-changing facts against real sources before relying on them, instead of answering from training memory that has a cutoff date. Trigger this before using any library/framework API, method signature, config option, or CLI flag you have not confirmed this session; before quoting a version, price, quota, rate limit, or model ID; when asked "what's the latest / newest…

  skills/research-and-verification/SKILL.md on GitHub (opens in a new tab)

• safe-refactoring

  Execute behavior-preserving code restructuring — establish a test safety net first, apply the smallest mechanical transformations in sequence, verify after each, and refuse refactors that lack the coverage to be done safely. Trigger this when the user asks to "refactor", "clean up", "simplify", "restructure", "extract", or "rename" existing working code, or when you initiate a structural improvem…

  skills/safe-refactoring/SKILL.md on GitHub (opens in a new tab)

• security-review

  Run a structured vulnerability pass over code — injection, auth/authz gaps, secrets exposure, unsafe deserialization, unvalidated boundary input, SSRF, and stack-specific classes — reporting findings by severity with concrete fixes. Trigger this after writing or modifying code that handles user input, authentication/authorization, database queries, file paths, external requests, deserialization,…

  skills/security-review/SKILL.md on GitHub (opens in a new tab)

• self-consistency-check

  Force the combination step that a weaker model can't do in one pass — surface conflicts between constraints, and interactions between requirements and edge cases, using a pairwise sweep, a fresh-context cold read by a subagent that never saw your reasoning, and N-version divergence on the hard kernel. Trigger this after producing a plan, design, spec, or multi-constraint solution and BEFORE commi…

  skills/self-consistency-check/SKILL.md on GitHub (opens in a new tab)

• session-state-management

  Stay coherent across a long agentic session by keeping the task's state on disk — a WORKING_NOTES.md with the task, plan, decisions, and status — updated at every milestone and re-read after any context loss. Trigger this at the start of any task likely to exceed ~30 minutes or ~10 distinct steps; immediately after noticing context compaction or a session resume; and whenever you catch yourself r…

  skills/session-state-management/SKILL.md on GitHub (opens in a new tab)

• structured-reasoning

  A step-by-step reasoning protocol for problems that exceed one intuitive step — generate and compare candidates, track assumptions, reason backward or from a minimal case when stuck, sanity-check intermediates, and run a mandatory devil's-advocate pass before finalizing. Trigger this the moment a problem is novel, high-stakes, involves multiple interacting constraints, requires arithmetic/countin…

  skills/structured-reasoning/SKILL.md on GitHub (opens in a new tab)

• task-planning

  Parse a request and produce an ordered execution plan before any code is written. Trigger this at the START of any new task — when the user asks to build, implement, add, create, migrate, or refactor something; when a request spans multiple files or steps; when a request contains vague scope words ("the configs", "handle errors etc."), ordering instructions, or prohibitions; or whenever you notic…

  skills/task-planning/SKILL.md on GitHub (opens in a new tab)

• uncertainty-management

  Classify what you actually know vs. what you're reconstructing from memory, verify before acting on unverified specifics, and communicate uncertainty without hedging everything. Trigger this whenever you are about to write a call to a library API, CLI flag, config key, or endpoint you have not confirmed in this session; when answering questions about version-specific or fast-moving library behavi…

  skills/uncertainty-management/SKILL.md on GitHub (opens in a new tab)

• verification-and-review

  The mandatory pre-delivery pass — requirements sweep, execution proof, self-review of the diff as a stranger's, and a fixed edge-case probe. Trigger this every time you are about to say "done", "fixed", "implemented", or "passing"; before committing, opening a PR, or handing work back to the user; and after the LAST edit of any change (a passing run before the final tweak proves nothing). Do NOT…

  skills/verification-and-review/SKILL.md on GitHub (opens in a new tab)

• verification-loop

  The tight edit-verify cycle DURING implementation — after every meaningful change, run the fastest sufficient check before making the next change; never accumulate a batch of unverified edits. Trigger this continuously while writing or modifying code: after each function implemented, each bug-fix edit, each config change, each refactoring step. Do NOT confuse with verification-and-review, which i…

  skills/verification-loop/SKILL.md on GitHub (opens in a new tab)

No skill matches that filter.

Similar skills

• superpowersby obra An agentic skills framework & software development methodology that works. 300k stars · 15 skills
• skillsby mattpocock Skills for Real Engineers. Straight from my .agents directory. 293k stars · 30 skills
• ECCby affaan-m The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Cod… 280k stars · 30 skills
• reaby morluto Reverse engineer anything with agents, from app behavior down to native binaries. 270k stars · 1 skill
• andrej-karpathy-skillsby multica-ai A single CLAUDE.md file to improve Claude Code behavior, derived from Andrej Karpathy's observations on LLM coding pitfalls. 220k stars · 1 skill
• skillsby anthropics Public repository for Agent Skills 181k stars · 19 skills