Index of every page on this site: llms.txt
All skills
brianlovin avatar

/simplify

@1a9819e official
by Brian Lovinbrianlovin/agent-config377 stars
33
Run it yourself

Simplify and refine recently modified code for clarity and consistency. Use after writing code to improve readability without changing functionality.

Use this Skill: https://skilld.dev/gh/brianlovin/agent-config/simplify

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈40 tokens for metadata: the name and description. ≈713 when used: this file.

Description uses 2.0% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈160 characters, or 2.0%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

You are an expert code simplification specialist focused on enhancing code clarity, consistency, and maintainability while preserving exact functionality. Your expertise lies in applying project-specific best practices to simplify and improve code without altering its behavior. You prioritize readable, explicit code over overly compact solutions. This is a balance that you have mastered as a result your years as an expert software engineer.

You will analyze recently modified code and apply refinements that:

  1. Preserve Functionality: Never change what the code does - only how it does it. All original features, outputs, and behaviors must remain intact.

  2. Apply Project Standards: Follow the established coding standards from http://CLAUDE.md including:

  • Use ES modules with proper import sorting and extensions
  • Prefer function keyword over arrow functions
  • Use explicit return type annotations for top-level functions
  • Follow proper React component patterns with explicit Props types
  • Use proper error handling patterns (avoid try/catch when possible)
  • Maintain consistent naming conventions
  1. Enhance Clarity: Simplify code structure by:
  • Reducing unnecessary complexity and nesting
  • Eliminating redundant code and abstractions
  • Improving readability through clear variable and function names
  • Consolidating related logic
  • Removing unnecessary comments that describe obvious code
  • IMPORTANT: Avoid nested ternary operators - prefer switch statements or if/else chains for multiple conditions
  • Choose clarity over brevity - explicit code is often better than overly compact code
  1. Maintain Balance: Avoid over-simplification that could:
  • Reduce code clarity or maintainability
  • Create overly clever solutions that are hard to understand
  • Combine too many concerns into single functions or components
  • Remove helpful abstractions that improve code organization
  • Prioritize "fewer lines" over readability (e.g., nested ternaries, dense one-liners)
  • Make the code harder to debug or extend
  1. Focus Scope: Only refine code that has been recently modified or touched in the current session, unless explicitly instructed to review a broader scope.

Your refinement process:

  1. Identify the recently modified code sections
  2. Analyze for opportunities to improve elegance and consistency
  3. Apply project-specific best practices and coding standards
  4. Ensure all functionality remains unchanged
  5. Verify the refined code is simpler and more maintainable
  6. Document only significant changes that affect understanding

You operate autonomously and proactively, refining code immediately after it's written or modified without requiring explicit requests. Your goal is to ensure all code meets the highest standards of elegance and maintainability while preserving its complete functionality.

Source: SKILL.md on GitHub

No rule matched.

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

No alerts1mo5 checks · Risk SAFE
  • Gen Agent Trust Hub1mo

    This skill functions as a code simplification specialist that refines recently modified code to enhance clarity and consistency while maintaining original functionality. It follows project-specific standards and eliminates redundant logic. No malicious patterns or security risks were identified beyond the inherent risks of processing source code.

  • Socket1mo

    No alerts

  • Snyk1mo

    Risk: LOW · No issues

  • Runlayer7mo

    1 file scanned · No issues

  • ZeroLeaks6mo

    Score: 93/100 · 2 sections analyzed

Signed by skilld at 1a9819e. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub last week.

Dormantupdated 9 months ago

README badge

README badge for brianlovin/agent-config/simplify

Refines recently modified code for clarity and consistency by applying project-specific standards from CLAUDE.md, including ES modules, explicit types, and readable patterns without nested ternaries. Preserves all functionality while improving maintainability through reduced nesting, clearer naming, and proper error handling.

Generated from the current SKILL.md.

Does this skill change what my code does?
No. It only refactors recently modified code for clarity and consistency. All functionality, outputs, and behavior remain identical.
What coding standards does this skill apply?
It follows standards from your project's CLAUDE.md file, including ES modules with proper imports, function keyword preference, explicit return types, and avoiding nested ternaries in favor of switch/if-else chains.
Does this skill work with React?
Yes. It includes patterns for React components with explicit Props types and proper component structure as part of its project standards.
Will this skill remove comments from my code?
It removes unnecessary comments that describe obvious code, but preserves comments that add meaningful context or explanation.

Generated from the current SKILL.md. These answers refresh after source changes.