rcode-lazy

Select the smallest working solution for software tasks before writing code.

2|1|Updated Apr 10, 2026

Search Tags:#refactoring #yagni #minimal code #stdlib #surgical changes #lazy mode

Ready to run

npx skills add https://github.com/hanzlahabib/rcode --skill rcode-lazy

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: rcode-lazy
Source: https://github.com/hanzlahabib/rcode/tree/main/rcode/skills/core/rcode-lazy
Command: npx skills add https://github.com/hanzlahabib/rcode --skill rcode-lazy

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

rcode-lazy prevents over-engineering by pushing the simplest working approach first, so you spend less time on unnecessary abstractions, dependencies, and boilerplate.

Core Features & Use Cases

Minimal-Solution Bias: Encourages the shortest correct path, from stdlib and native features to the smallest viable implementation.
Anti-Bloat Guardrails: Blocks premature abstractions, speculative scaffolding, and unnecessary additions while preserving required validation and safety.
Practical Decision Lens: Helps with feature design, refactoring choices, dependency decisions, and quick implementation tradeoffs in active software work.

Quick Start

Activate rcode-lazy and ask for the simplest working solution for your task.

Frequently Asked Questions about rcode-lazy

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

FAQPage Schema

How do I prevent over-engineering when refactoring code?▼

To prevent over-engineering during refactoring, apply a minimal-solution bias by selecting the smallest working implementation, prioritizing standard libraries, and avoiding premature abstractions to block speculative scaffolding while preserving required validation.

What is the YAGNI principle in software development?▼

YAGNI in software development dictates selecting the smallest viable implementation and blocking premature abstractions, enforcing minimal diffs and native-feature-first choices to prevent unnecessary boilerplate and dependencies.

How do I choose the simplest working solution for a new feature?▼

To choose the simplest working solution for a new feature, prioritize standard library and native features first, make surgical changes with minimal diffs, and document deliberate shortcuts while running one runnable check for non-trivial logic.

When should I avoid adding new dependencies to my project?▼

Avoid adding new dependencies when a standard library or native feature achieves the same result. Enforcing a stdlib-first approach prevents unnecessary additions, speculative scaffolding, and bloat while maintaining required safety.

How do I make surgical changes with minimal diffs during implementation?▼

To make surgical changes with minimal diffs during implementation, focus on the shortest correct path, avoid premature abstractions, take deliberate shortcut notes, and ensure one runnable check is applied for any non-trivial logic.

Does a minimal code approach work for complex implementation tradeoffs?▼

A minimal code approach works for complex tradeoffs by acting as a practical decision lens for feature design and refactoring choices, selecting the smallest viable implementation while deliberately documenting shortcuts and preserving required validation.