Generate concise, idiomatic code with minimal token overhead

Super Code Skill is a standing house style applied automatically to every coding task, aimed at producing code that is short, correct, idiomatic, and maintainable, in that priority order: correctness, then clarity, then necessary robustness, then conciseness, then micro-performance - conciseness never wins over correctness or readability. It targets two distinct inefficiencies that have to be fixed independently: code-token inefficiency (a bloated artifact - unnecessary lines, boilerplate, over-abstraction) and generation-token inefficiency (how the agent behaves during a session - full-file rewrites, unrequested files, prose padding before or after changes). The workflow runs in five steps on every task: commit to the smallest correct shape before writing anything; write using the target language's idiomatic patterns from a per-language reference file (Bash, C, C++, C#, Dart/Flutter, Elixir/Erlang, Go, Java, Kotlin/Compose, PHP, Python, Ruby, Rust, Scala, Swift, or TypeScript/JavaScript); run a compression pass on the draft against a fixed anti-pattern table (comments that just restate the code, single-use helpers, reinventing a stdlib primitive, defensive handling for an impossible case, a verbose loop replaceable by an idiomatic expression, unrequested logging, unused imports); run a silent guardrail check asking whether the compression dropped handling for a case that can actually happen, made the code harder to read in six months, or traded away correctness or security to save lines - if so, undo that specific compression and keep the rest; and finally present the output under a separate set of generation-token rules. A worked example of the idiomatic-pattern step, taken directly from the skill:

// Anti-pattern
List<String> names = new ArrayList<>();
for (User u : users) {
    if (u.isActive()) {
        names.add(u.getName());
    }
}
// Super-code idiomatic (Java)
List<String> names = users.stream().filter(User::isActive).map(User::getName).toList();

Apply it automatically on every coding task in the IDE - any time the user asks to write, edit, refactor, generate, or review code in any language; it's a standing house style, not an on-demand pass. It is not a license to compress code past readability: if a comment could be mechanically generated from reading the code it adds no value and should be deleted, but a comment explaining why (for example, "process refunds before charges") should be kept; an abstraction earns its place only when used twice or more, or when its name genuinely clarifies domain logic, not for logic used exactly once. Do not add placeholder TODOs, empty "just in case" catch blocks, or parameters current callers don't use unless the user explicitly asked for scaffolding.

Input is whatever code the user asks to write, edit, refactor, or review, in a coding-agent session. Output is governed by a separate set of generation-token rules covering how the agent presents changes, not just what it produces: edit via targeted patches or diffs rather than full-file rewrites, except for new files, files under roughly 30 lines, or changes touching more than 70% of the file; never repeat unchanged portions of a file "to show context"; never generate unrequested test files, README updates, type definitions, config files, or CI scripts (offer one in a single sentence afterward instead); and never add "here's what I'm going to do" preambles or "I've made the following changes" postambles, since the diff is self-evident. A single clarifying question is acceptable only when a requirement is genuinely ambiguous - otherwise make a reasonable choice and note the assumption in an in-code comment if it matters.

Reads a per-language reference file (bash/SKILL.md, python/SKILL.md, typescript/SKILL.md, and 13 others covering C, C++, C#, Dart/Flutter, Elixir/Erlang, Go, Java, Kotlin/Compose, PHP, Ruby, Rust, Scala, and Swift) at the idiomatic-pattern step; if the language in use isn't listed, it falls back to the universal anti-pattern checklist and the language's own native idioms for loops, error handling, and data transformation. It names one related, separate skill, @karpathy-guidelines, for behavioral guidance on surgical changes and simplicity.

Anyone using an agentic coding IDE who wants every generated or edited piece of code to default to short, idiomatic, and maintainable, without having to ask for it on each task - and who wants the agent itself to stop padding sessions with unrequested files and narrated preambles around every diff.