Skip to content
Skills Library
Programming · Planning

native-first

/native-first

Stack-agnostic playbook for the native, non-custom way to do something before writing a script or wrapper. Use when tempted to add a dependency or build a helper, or content-guards blocks a write. Climbs a fixed ladder; ends against silent fallback.

Licence
Apache-2.0
Last repository change
25.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 25.10.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Stack-agnostic playbook for the native, non-custom way to do something before writing a script or wrapper. Use when tempted to add a dependency or build a helper, or content-guards blocks a write. Climbs a fixed ladder; ends against silent fallback.

Original author description

Stack-agnostic playbook for the native, non-custom way to do something before writing a script or wrapper. Use when tempted to add a dependency or build a helper, or content-guards blocks a write. Climbs a fixed ladder; ends against silent fallback.

How it works

  1. When to use
  2. The ladder — stop at the first rung that holds
  3. Ordering rule: supported before bespoke
  4. Terminal rule — no silent script fallback
  5. Applying it
  6. Related
Original SKILL.md headings · 101 lines, 767 words
SKILL.md preview
---
name: native-first
description: "Stack-agnostic playbook for the native, non-custom way to do something before writing a script or wrapper. Use when tempted to add a dependency or build a helper, or content-guards blocks a write. Climbs a fixed ladder; ends against silent fallback."
---

# Native-First

Find the way something is *meant* to be done before building a custom way. Most
"I need a script" moments have a native answer that is smaller, already tested,
and maintained by someone else. This skill is the search for that answer.

It pairs with the script-guard hooks in this plugin. The hooks **block** an unnecessary
script; this skill **supplies the native path** that makes the block irrelevant.
`ponytail` decides *what rung* to reach for; native-first does the *research* that
rung needs when the answer is not already in front of you.

## When to use

- You are about to write a shell/python/glue script or a custom helper function.
- You are about to add a dependency for something small.
- A script-guard hook just blocked a script write. Do not route around it —
  run this ladder instead.
- You catch yourself thinking "there's probably a flag for this, but it's faster
  to just script it." That thought is the trigger.

## The ladder — stop at the first rung that holds

Climb in order. Each rung is cheaper to maintain than the one below it.

1. **The tool's own config, flag, or built-in module.**
   The single most-skipped rung. Check `--help`, `man <tool>`, `tldr <tool>`, and
   the tool's config-file reference before anything else. A `--format`, a config
   key, a built-in subcommand, or a stdlib module usually exists.
   *Examples:* `jq`/`--json` output instead of parsing text with `awk`;
   `git config` instead of editing `.git/config`; a language's stdlib
   (`pathlib`, `datetime`) instead of shelling out.

2. **A native platform feature.**
   The OS, runtime, or data layer often does it declaratively.
   *Examples:* a `launchd`/`systemd` unit instead of a cron-and-pidfile script;
   a database `CHECK`/`UNIQUE` constraint instead of app-side validation; CSS
   instead of JS; an HTML input type instead of a date-picker library.

3. **Official docs — via Context7 MCP, not memory.**
   Look up the current, versioned docs for the tool or library. Memory is stale;
   APIs move. Use the Context7 MCP (`resolve-library-id` then `query-docs`) or the
   vendor's own docs site. Never assert an API exists from recall — verify it.

4. **A package/module registry.**
   Someone published the thing. Search the ecosystem registry before writing glue:
   Ansible Galaxy (a role/collection/module), Terraform Registry (a provider/
   module), nixpkgs (a package/option), the language package index. A maintained
   module beats a bespoke script.

5. **The issue tracker.**
   Ask the source: search the tool's GitHub issues/discussions for
   "how do I do X natively" or "is X supported". The answer — including "not
   supported, here's the workaround" — is often already written down.

## Ordering rule: supported before bespoke

When more than one native path exists, prefer in this order:

**vendor-supported → community-supported → bespoke.**

A first-party feature outranks a popular plugin, which outranks anything you write.

## Terminal rule — no silent script fallback

If you climb the whole ladder and find no native path, the output is **not** a
script by default. The output is an **evidenced conclusion**:

> "No native path exists. I checked: `<tool> --help` (no relevant flag), the
> `<platform>` feature set (nothing declarative for this), Context7 docs for
> `<library>` vX (no API), the `<registry>` (no module), and issue `#<n>`
> (maintainer confirms unsupported). A small script is the remaining option —
> here it is, scoped to just this gap."

### Sanctioned helper

A helper that survives the terminal rule is **sanctioned, not incidental**: record
it in the project's own docs alongside the evidence that justified it — the rungs
checked and what each returned — and re-check that evidence when the underlying
tool ships its next major version. A native path that did not exist at v2 often
exists at v3, and the helper should retire the moment it does.

Only after that evidence is a custom script the right call. A script written
*without* that evidence is the thing this skill and the script-guard hooks
exist to stop. "I couldn't find one" is not evidence; "I checked these five
places and here is what each returned" is.

## Applying it

Report which rung the answer came from, so the next reader learns the native path
too: *"Used the tool's own `--output json` flag (rung 1)."* When you reach the
terminal rule, list the rungs checked and what each returned — that list is the
justification the script needs to exist.

## Related

- **script-guard hooks** (this plugin) — block unnecessary script writes; this
  skill supplies the native alternative they assume exists.
- **native-first is stack-agnostic** — it is not Nix-specific. On a Nix machine,
  a repo's `nix-tool-policy` rule adds the Nix-specific rungs on top of this ladder.

Versions

RepositoryScoreLicence
This page · dryvist/claude-code-plugins100Apache-2.0
JacobPEvans/claude-code-plugins100Apache-2.0

Identical content appears in 1 other GitHub folders. We show one copy with the highest score.

Database snapshot: 13.11.2026 · package version ac334c01f06c (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

  • 90minimalism-driven
    Use when writing or restructuring code, before adding a helper, wrapper, config key, or dependency, or when the user asks for minimal or DRY code. Not for performance tuning: use optimize.
  • 95write-script-bunnative
    MUST use when writing Bun Native scripts. The script must start with //native to run on the native worker.
  • 90stack-guard
    Enforces the fixed technology stack of this project. Use before writing any code, adding a dependency, or scaffolding a module — and always when tempted to choose a library, framework, or tool. Check this skill whenever a change might introduce a new dependency or drift from the approved stack.

Feedback and reports

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