lazy-senior-dev

Remove unnecessary code, abstractions, and dependencies during implementation and code review.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/meisijiya/ohMeisijiyaCode --skill lazy-senior-dev
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: lazy-senior-dev
Source: https://github.com/meisijiya/ohMeisijiyaCode/tree/main/skills/lazy-senior-dev
Command: npx skills add https://github.com/meisijiya/ohMeisijiyaCode --skill lazy-senior-dev

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you avoid overbuilding by forcing a disciplined YAGNI check before you add code, abstractions, dependencies, or extra complexity.

Core Features & Use Cases

  • Three-question preflight: Ask whether the change can be removed, reused, or truly needs something new.
  • Implementation and review guardrail: Use it when writing code, modifying existing behavior, choosing APIs, or reviewing a proposed design.
  • Safe minimalism: It keeps essential protections intact for error handling, data-loss prevention, security, and accessibility.
  • Use Case: Before adding a new helper or dependency, use this Skill to challenge whether the standard library or existing architecture already solves the problem.

Quick Start

Use lazy-senior-dev to review this change and tell me what can be removed, reused, or avoided before adding anything new.

Frequently Asked Questions about lazy-senior-dev

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

FAQPage Schema
How do I apply YAGNI principles during code review to remove unnecessary abstractions?▼

To apply YAGNI during code review, execute a three-question preflight to determine if code can be removed, reused, or avoided before adding new abstractions or dependencies. This enforces safe minimalism while preserving essential error handling, security, and data-loss protection.

What is the best way to prevent code bloat when adding new dependencies and APIs?▼

The best way to prevent code bloat is challenging whether existing architecture or the standard library already solves the problem before selecting new APIs or dependencies. This reuse-first reasoning ensures you only add what is truly necessary.

When do I need to refactoring existing code to eliminate unnecessary complexity?▼

You need to refactor to eliminate complexity when a three-question preflight reveals redundant abstractions or unused dependencies. This minimalism approach strips bloat while strictly preserving data-loss prevention, security, and accessibility guardrails.

Can I safely strip out unused code without breaking security and error handling?▼

Yes, you can safely strip unused code by applying safe minimalism, which actively preserves essential protections. The process removes unnecessary abstractions and dependencies while explicitly maintaining error handling, data-loss prevention, security, and accessibility.

Why does adding speculative abstractions increase software bloat and maintenance burden?▼

Adding speculative abstractions increases software bloat because it introduces unnecessary dependencies and code paths that are not currently needed. Applying YAGNI discipline challenges these additions through a preflight check, ensuring only essential, reused, or removed code ships.