Skip to content
Skills Library
Programming · Building & coding

fable-native-code

/fable-native-code

Use when writing or editing code in an existing codebase — before adding comments, docstrings, try/catch blocks, validation, logging, or TODOs the surrounding file doesn't have, and before explaining your style choices in the reply.

Licence
MIT
Last repository change
06.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 06.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use when writing or editing code in an existing codebase — before adding comments, docstrings, try/catch blocks, validation, logging, or TODOs the surrounding file doesn't have, and before explaining your style choices in the reply.

Original author description

Use when writing or editing code in an existing codebase — before adding comments, docstrings, try/catch blocks, validation, logging, or TODOs the surrounding file doesn't have, and before explaining your style choices in the reply.

How it works

  1. Overview
  2. Rules
  3. Contrast
  4. Rationalizations
  5. Red Flags — delete before committing
Original SKILL.md headings · 100 lines, 669 words
SKILL.md preview
---
name: fable-native-code
description: Use when writing or editing code in an existing codebase — before adding comments, docstrings, try/catch blocks, validation, logging, or TODOs the surrounding file doesn't have, and before explaining your style choices in the reply.
---

# Native Code

## Overview

Your diff should read like the file's longtime owner wrote it. The file has
a style — naming, error handling, comment density, formatting. Write in it.
Your personal preferences are not improvements; they're an accent.

## Rules

1. **Match the file:** naming, error-handling idiom, comment density,
   formatting, import organization. If the file has one comment per 200
   lines, your addition almost certainly has zero.
2. **Comments state only constraints the code cannot show** — invariants,
   gotchas, why-not-the-obvious-way. Never what the next line does, never
   narration of your change ("now correctly handles X"), never justification
   aimed at a reviewer. Test: after the PR merges, is this comment
   information or noise?
3. **No defensive bloat:** no try/catch around code that works, no
   validating invariants the types or callers already guarantee, no
   logging, config, or flags nobody asked for. If the contract is worth
   enforcing, that's a test or a boundary assertion — its own change.
4. **Don't narrate your restraint.** The urge to explain what you
   *didn't* add ("note: I deliberately left out the doc comment because…")
   is the same urge that adds it — displaced into the reply. The
   justification a senior dev never writes in code, they also never write
   in chat. Deliver the code; mention style only if the user asks.
5. **Clean exit:** no debug prints, no commented-out code, no TODO crumbs
   you created.
6. **Names come from the codebase's existing vocabulary.** Don't coin a
   second name for an existing concept.

## Contrast

Task: add `clampWindow` to a terse Go file whose only comment in 200 lines
marks a sorting invariant; callers guarantee `max >= 0`.

**Foreign (your habits, not the file's):**

```go
// clampWindow clamps start and end into the valid range [0, max] and
// normalizes inverted windows. Returns (start, start) when end < start.
func clampWindow(start, end, max int) (int, int) {
    if max < 0 {
        return 0, 0 // defensive: should never happen
    }
    ...
}
```

**Native (what the file's owner would write):**

```go
func clampWindow(start, end, max int) (int, int) {
    if start < 0 {
        start = 0
    }
    if start > max {
        start = max
    }
    if end < 0 {
        end = 0
    }
    if end > max {
        end = max
    }
    if end < start {
        return start, start
    }
    return start, end
}
```

No header comment (the signature says it), no `max < 0` guard (the callers
guarantee it, like `mergeWindows` trusts its sorted-input invariant) — and
no paragraph in the reply explaining either omission.

## Rationalizations

| Thought | Reality |
|---|---|
| "A doc comment helps the next reader" | The next reader has the signature and twelve obvious lines. The file's owner trusted them; trust them too. |
| "Extra validation can't hurt" | A guard for an impossible state is dead code that suggests the state is possible. Swallowed errors are the most expensive bugs to find. |
| "My last reviewer praised my documentation habits" | In a codebase whose style wants documentation. This file's style is the spec now. |
| "I'll explain in chat what I left out of the code" | Observed verbatim in baseline: a multi-paragraph "note on what I deliberately left out" after "output only the code." Restraint that announces itself isn't restraint. |
| "I'll leave a TODO for the edge case" | Handle it, or surface it in your report. TODOs are where edge cases go to be forgotten. |

Provenance: baseline Opus 4.8 wrote the native version above, then narrated
its restraint anyway (rule 4 exists because of it). fable-skills test logs,
2026-06-10.

## Red Flags — delete before committing

- A comment that describes the line below it
- "deliberately", "note that I", "for safety" — in code or in your reply
- try/catch whose catch block only logs or re-raises
- A guard for a state the caller contract excludes
- Your addition is the only part of the file with comments

Versions

The database has no other skills named fable-native-code.

Database snapshot: 13.11.2026 · package version eb89690544ed (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100comments
    Comment rules for every language: which comments survive, format, protected comments, placement, TODOs. Use when writing, editing, moving or deleting comments, docstrings or TODOs. Auto-invoke when editing code files.
  • 90code-comments
    Full comment and docstring policy for this repo — what to delete, what to keep compressed, what to never touch, and the two local traps. Use when writing, reviewing, or pruning comments and docstrings in any language.
  • 95code-comments
    Rules for writing and editing code comments — inline comments, doc comments (TSDoc, GoDoc, docstrings), and TODOs. Use when writing or changing code, adding or editing comments, or reviewing a diff for comment quality.
  • 100codebase-tidiness
    Scan Python codebases for obsolete code, stale comments, and outdated docstrings — the kind of cruft that accumulates during development but doesn't trigger linter errors. Run this before sprint reviews, after large refactors, or whenever the codebase needs a cleanup pass. If…
  • 85fable-review
    Launch an independent Fable code review and return it verbatim. Use only when the user explicitly invokes /fable-review.
  • 100fable-code
    Code like Fable 5 — methodical, verified, and deeply informed by context. Use this skill whenever you need to write, edit, or create code.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.