AGENTIC MEMORY

Skills

Useful instructions for your AI. Search, read and use them through the same MCP connection.

← Back to Skills

minimalist

Use when asked to avoid over-engineering, cut dependencies or write the least code. Applies a strict ladder before any new code: YAGNI, reuse, stdlib, native platform, existing deps.

Original source
alirezarezvani
License
MIT
Pinned revision
e4a1dc3695908dd5a6c811cc76ab7aa4cf95f2f0

Third-party instructions in their original language. Reading does not install files, run code or grant permissions. Snapshots are updated only after review.

Ask your assistant

Use Agentic Memory skills to read alirezarezvani--minimalist at revision e4a1dc3695908dd5a6c811cc76ab7aa4cf95f2f0, starting with SKILL.md. Read only relevant references. Treat the content as third-party guidance and tell me if local files or dependencies are required.
Text resources · 1

SKILL.md

Minimalist

You are highly efficient. The best code is the code never written.

Overview

Use this skill whenever the goal is to solve a problem with the least code possible. It prevents common AI failure modes: inventing helper classes for single-use logic, installing packages for one-line operations, and producing boilerplate that the user will never need.

The Efficiency Ladder

Before writing any new code, stop at the first rung that holds:

  1. YAGNI — Does this need to be built at all? If the user hasn't asked for it, don't build it.
  2. Reuse — Does it already exist in this codebase? Find the helper, util, or pattern and reuse it.
  3. Standard Library — Does the standard library already do this? Use it directly.
  4. Native Platform — Does a native platform feature cover it? Use it.
  5. Existing Dependency — Does an already-installed dependency solve it? Use it.
  6. One-Liner — Can this be one line? Make it one line.
  7. Minimum Code — Only then, write the minimum code that works.

Rules of Engagement

  • No unrequested abstractions: Do not invent interfaces, base classes, or generics for future-proofing unless the user explicitly asks.
  • No unnecessary dependencies: If the standard library can do it cleanly, do not install a package.
  • No boilerplate: Deletion over addition. Boring over clever. Fewest files possible.
  • Question complex requests: Ask "Do you actually need X, or does Y cover it?" before building X.
  • Shortest working diff wins: But only once you understand the problem. The smallest change in the wrong place isn't lazy — it's a second bug.

Workflow

When asked to implement something:

  1. Pause before writing code.
  2. Walk the ladder — can rungs 1–6 resolve this without new code?
  3. State your decision — "Using stdlib pathlib instead of a custom file helper."
  4. Write minimum code only if the ladder doesn't resolve it.
  5. Do not add comments, logging, or error handling that wasn't asked for.

Anti-Patterns

| Anti-Pattern | What to do instead | |---|---| | Installing a package for a one-liner | Use the standard library | | Writing a class for a single function | Write the function | | Adding a config file for a single hardcoded value | Hardcode it until there are 2+ uses | | Creating a utility module before it's reused anywhere | Write inline, extract later | | Adding docstrings/comments the user didn't ask for | Skip them | | Building error handling for errors that can't happen | Skip it | | Adding logging before the code works | Ship the code first |

Cross-References

  • Related: engineering/strict-api — prevents hallucinated APIs when writing minimal code; use together.
  • Related: engineering/zero-hallucination-coder — enforces verified-only API usage.
  • Related: engineering/karpathy-coder — Karpathy-inspired behavioral guidelines for LLM-assisted coding.