Super Code

Super Code Skill

Overview

Produce code that is short, correct, idiomatic, and maintainable — in that priority order. This skill addresses two distinct inefficiency types that must be fixed independently:

1. Code-token inefficiency — the artifact itself is bloated (unnecessary lines, boilerplate, over-abstraction)
2. Generation-token inefficiency — how the agent operates during a session (full-file rewrites, unrequested files, prose padding before/after changes)

Both matter. Fixing only one is not enough.

When to Use This Skill

• Apply this skill automatically on EVERY coding task in the IDE.
• Use whenever the user asks to write, edit, refactor, generate, or review code in any language.
• This is a standing house style, not an on-demand pass — always apply it.

Priority Order (never violate this ranking)

Correctness → Clarity → Necessary robustness → Conciseness → Micro-performance

Conciseness never wins over correctness or readability. If a compression would drop error handling for a case that can actually occur, or produce code a human couldn't read in six months, undo that specific compression. Short bad code is worse than long correct code.

Workflow — apply to every coding task

Step 1: Commit to minimal correct shape BEFORE writing

Before touching a file, decide:

• What is the smallest surface area that correctly solves this problem?
• What does the caller actually need from this function/class/module?
• Is there a stdlib/framework primitive that already does this?

Write that down mentally (not in a prose block to the user). This is the target shape.

Step 2: Write using language-idiomatic patterns

Read the relevant reference file for the language in use:

• Bash/Shell → bash/SKILL.md
• C → c/SKILL.md
• C++ → cpp/SKILL.md
• C# → csharp/SKILL.md
• Dart/Flutter → dart/SKILL.md
• Elixir/Erlang → elixir/SKILL.md
• Go → go/SKILL.md
• Java → java/SKILL.md
• Kotlin/Compose → kotlin/SKILL.md
• PHP → php/SKILL.md
• Python → python/SKILL.md
• Ruby → ruby/SKILL.md
• Rust → rust/SKILL.md
• Scala → scala/SKILL.md
• Swift → swift/SKILL.md
• TypeScript/JavaScript → typescript/SKILL.md

Apply idiomatic patterns from that file. They replace verbose imperative code with correct, concise equivalents that are still readable.

Step 3: Compression pass on your own draft

Before presenting any code, scan it for:

Step 4: Guardrail check — run this before presenting

Ask yourself (silently):

• Did I remove handling for a case that can actually happen?
• Did I make this harder to read for a human six months from now?
• Did I drop correctness or security to save lines?

If yes to any: undo that specific compression and keep the rest.

Step 5: Present output — generation-token rules

Always:

• Edit files via targeted patches/diffs, not full rewrites, unless the file is new or the change touches >70% of lines
• Present only what was asked for

Never:

• Generate unrequested files (tests, READMEs, configs, types) unless the user asked
• Add prose blocks before/after code explaining what you're about to do or just did — just do it
• Re-explain the user's own requirement back to them before writing
• Restate what changed in a paragraph after showing the diff — the diff is self-evident

Universal Anti-Pattern Checklist

These apply in every language. The language-specific files extend this list.

Comments

• ❌ // Loop through the list and add each item → ❌ delete
• ✅ // Order matters: process refunds before charges → ✅ keep (explains why)
• Rule: if the comment could be generated mechanically from reading the code, it adds no value

Defensive coding

• Only handle error cases that can actually occur given the call site
• If the caller guarantees non-null, don't null-check inside the function
• If a catch block can only log and rethrow, consider removing the try/catch