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
12.11.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 12.11.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. Repeated jobs
  5. Terminal rule — no silent script fallback
  6. Applying it
  7. Related
Original SKILL.md headings · 109 lines, 819 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.

## Repeated jobs

A repeated job is a native feature first and a local agent second — never a
new standing script. The feature or the agent carries the tool's instructions;
the session only calls it.

## 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.
- **local-subagents** (ai-delegation) — the local agent a repeated job gets
  when no native feature fits.
- **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 · JacobPEvans/claude-code-plugins100Apache-2.0
dryvist/claude-code-plugins100Apache-2.0

Database snapshot: 13.11.2026 · package version a62ae6918f0a (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.
  • 100search-before-building
    Use when about to add a new helper, utility, or abstraction, a task sounds like a solved problem, a new external dependency is being considered, or custom code is proposed without checking what already exists.
  • 95write-script-bunnative
    MUST use when writing Bun Native scripts. The script must start with //native to run on the native worker.
  • 90six-rung-ladder
    Use when deciding whether to write a piece of code, add a dependency, or introduce an abstraction / module / config — the "should I build this at all?" filter, applied before building. | 要決定「要不要寫這段 code/引這個依賴/加這層抽象或模組」時使用——「到底該不該做」的過濾網,動手之前先走一遍。不適用:把流程做成 agent workflow/建工具(改用…
  • 100native-module-helper
    Create custom React Native native modules for iOS and Android. Use when integrating native SDKs, optimizing performance-critical code, or accessing platform-specific APIs. Trigger words include "native module", "bridge", "native code", "iOS bridge", "Android bridge", "Turbo Module".
  • 90silent-failures
    Audit error handling in local code changes for silent failures, inadequate error feedback, and inappropriate fallback behavior. Trigger when the user invokes the silent-failures skill, says "check error handling", "find silent failures", "audit fallbacks", or "review error…

Feedback and reports

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