Global Commenting

Generate self-documenting code with evergreen comments and meaningful naming.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/grimmolf/mga-soap-calculator --skill global-commenting-grimmolf
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: Global Commenting
Source: https://github.com/grimmolf/mga-soap-calculator/tree/main/.claude/skills/global-commenting
Command: npx skills add https://github.com/grimmolf/mga-soap-calculator --skill global-commenting-grimmolf

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill reduces cognitive load and improves long-term maintainability by guiding developers to write self-documenting code and add only minimal, evergreen comments for complex logic, preventing outdated or redundant explanations.

Core Features & Use Cases

  • Self-Documenting Code: Prioritizes clear structure and naming over excessive comments.
  • Evergreen Explanations: Focuses on explaining why code makes decisions, not just what it does.
  • Comment Review & Refinement: Guides on removing outdated or temporal comments.
  • Use Case: When reviewing a complex algorithm, use this skill to ensure comments explain why a decision was made, not just what the code does, making it easier for future developers to understand.

Quick Start

Apply the Global Commenting skill to review the calculateSaponificationValue function and ensure comments are concise and explain complex logic.

Frequently Asked Questions about Global Commenting

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I write code comments that won't become outdated?

Evergreen comments explain *why* decisions were made, not *what* the code does. Focus on non-obvious logic and reasoning rather than restating syntax, so comments remain accurate as code evolves without constant maintenance.

What's the difference between self-documenting code and comments?

Self-documenting code uses clear naming and structure to convey intent directly; comments then explain complex decisions and edge cases. Together they reduce cognitive load—code clarity handles the obvious, comments handle the *why*.

When should I remove comments from my code?

Remove temporal notes (dates, version markers), redundant comments that restate obvious code, and outdated explanations. Keep only comments that clarify non-obvious decisions or complex algorithms that naming alone cannot express.

How do I balance clarity with minimal commenting?

Prioritize meaningful variable and function names, logical structure, and explicit code organization first. Add comments only for non-obvious *why* decisions; this reduces maintenance burden while keeping code readable across projects and languages.

Can I apply commenting standards across different programming languages?

Yes. Self-documenting principles—clear naming, meaningful structure, and evergreen explanations of *why*—apply to all code files and platforms. Adjust comment syntax per language but keep the same philosophy of clarity and maintainability.

How do I review existing comments for quality?

During code review or refactoring, check that comments explain non-obvious decisions rather than restating code, contain no temporal references, and use naming and structure to handle simple clarity. Remove or rewrite comments that fail these criteria.