coding-principles

A set of general rules for writing readable, maintainable code. It emphasizes small changes, clear names, focused functions, useful comments, and established coding standards.

In plain words
What is it for?
Use it while creating, changing, or reviewing code in any language. It guides how to break down work, document public code, and organize responsibilities.
Why use it?
It reduces confusion and errors caused by overly complex code, unclear names, and inconsistent practices. It also makes code easier for other developers to understand and maintain.

Cursor rule for Cursor

Install

Getting it into your agent

One page per mod, every tool's command on it. A separate URL per tool would split the same page into five that compete with each other.

agentmods
npx agentmods add rules/mitas/cursor-rules/coding-principles
Clone the repo
git clone --depth 1 https://github.com/mitas/cursor-rules

Made for: Cursor.

Per session 767 This file is loaded in full into every session.
When invoked 767 The same file — it is already loaded in full.
Security scan A 0 findings. Scan, not verified.
Origin original No closer match found in the catalogue.
Token cost

What it costs to keep this loaded

Counted locally with the o200k_base tokenizer, which is exact for GPT models; Claude uses its own tokenizer and its counts differ. Treat this as one consistent yardstick across the catalogue rather than a bill. Prices are per million input tokens.

ModelPer sessionOnce invoked
Fable 5 $0.00767 $0.00767
Opus 5 $0.00383 $0.00383
Sonnet 5 $0.00153 $0.00153
Haiku 4.5 $0.00077 $0.00077

Measured yesterday against content hash 782e6354f7d4, method: parsed. Prices are Anthropic first-party input rates as of 2026-08-30, from the pricing page.

Security

Grade A, and why

coding-principles scanned grade A with 0 findings against 26 rules in 11 categories — prompt injection, anti-refusal, data exfiltration, privilege escalation, supply chain, agent snooping, system-prompt leakage, SSRF and excessive agency — measured yesterday.

A static scan of the body, not an audit. Every finding is printed with the line that produced it so you can judge whether it matters here. A mod is markdown that instructs an agent; that is exactly why what it instructs is worth reading.

Nothing flagged

None of the 26 patterns this scan looks for appear in this file: no shell pipes, no recursive deletes, no credential paths, no hidden text, no instruction-override or anti-refusal phrasing, no agent-config snooping. That is not a guarantee, it is the absence of the things that are checkable.

.cursor/rules/coding-principles.mdc · 105 lines

How it starts

The opening of the file, as written. The whole thing — 105 lines — stays where its author put it; the contents beside it link to each section on GitHub.

Code Quality Principles

Context

  • Writing maintainable, readable code is a priority over clever optimizations
  • Step-by-step implementation reduces errors and improves code quality
  • Proper documentation and comments enhance long-term maintainability
  • Following established coding standards improves collaboration
  • The Unix philosophy of "do one thing well" leads to more robust solutions

Critical rules

  • Proceed with small, focused steps instead of large, complex changes
  • Always prioritize code readability and clarity over premature optimization
  • Add explanatory comments to any complex or non-obvious logic
  • Document all exported methods, functions, classes, and constants with purpose and usage notes
  • Follow the established coding standards and conventions specific to the language in use
  • Prefer simple, straightforward solutions over complex implementations
  • Design components to do one thing well rather than multiple responsibilities
  • Use descriptive variable and function names that reveal intent
  • Break complex operations into smaller, focused functions
  • Keep functions short and focused on a single responsibility
  • Avoid deep nesting of control structures when possible
  • Use consistent formatting throughout the codebase
  • Apply the appropriate error handling approach for the language
  • Include tests for new functionality when applicable
  • Refactor duplicated code into reusable functions

Examples

/**

  • Authenticates a user with provided credentials
  • @param {string} username - The user's username
  • @param {string} password - The user's password
  • @returns {Promise} - The authenticated user or throws an error */ export async function authenticateUser(username, password) { // Validate inputs if (!username || !password) { throw new Error('Username and password required'); }

Read the full file on GitHub · 105 lines

Changes

What this file has done since we first saw it

Hashed on every crawl. A supply-chain change to an agent config is a question of when, not whether, so the history is kept rather than the latest state alone.

  1. yesterday First seen · 105 lines · 767 tokens per session scan A 782e6354f7d4

Subscribe to this mod's changes

coding-principles is a cursor rule published in the GitHub repository mitas/cursor-rules (2 stars, last pushed 1y ago), licensed MIT. It adds 767 tokens to every session, about $0.0038 per session on Opus 5. A static security scan graded it A with 0 findings. No closer match exists in the catalogue, so it is treated as the original; first seen 2026-08-31.