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.