kaizen

Guide incremental code improvements using Kaizen, Poka-Yoke, and JIT principles.

Updated Jan 8, 2026
One-click install
npx skills add https://github.com/AndyAnh174/BanThuoc-SEO --skill kaizen-andyanh174
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: kaizen
Source: https://github.com/AndyAnh174/BanThuoc-SEO/tree/main/.agent/skills/kaizen
Command: npx skills add https://github.com/AndyAnh174/BanThuoc-SEO --skill kaizen-andyanh174

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides a framework for systematically improving code quality, refactoring processes, and enhancing workflows through small, continuous changes and error prevention.

Core Features & Use Cases

  • Incremental Improvement: Guides users on making small, frequent enhancements to code and processes.
  • Error Proofing (Poka-Yoke): Emphasizes designing systems to prevent errors at the source.
  • Standardized Work: Promotes consistency by following established patterns and documenting best practices.
  • Just-In-Time (JIT): Advocates for building only what is needed, avoiding premature optimization and over-engineering.
  • Use Case: When refactoring a complex function, use this Skill to guide the process, ensuring each small change improves clarity or efficiency without introducing new bugs, and adhering to established project patterns.

Quick Start

Apply the principles of continuous improvement to refactor the provided code snippet for better readability and efficiency.

Frequently Asked Questions about kaizen

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

FAQPage Schema
What is continuous improvement in software engineering and how does it apply to code refactoring?

Continuous improvement in software engineering involves making small, incremental changes to systematically enhance code quality and refactoring processes. It focuses on frequent enhancements that improve clarity and efficiency without introducing new bugs.

How do I prevent errors at the source when designing software systems?

To prevent errors at the source, apply Poka-Yoke principles to design systems that make mistakes impossible. This error proofing approach emphasizes design-time prevention to ensure consistency and avoid defects before they occur.

How do I implement Just-In-Time principles to avoid over-engineering and premature optimization?

Implement Just-In-Time (JIT) principles by building only what is immediately needed and avoiding premature abstraction or optimization. This approach prevents over-engineering by focusing development strictly on current requirements.

What is the best way to standardize workflows and maintain consistency in software development?

The best way to standardize workflows is by following established patterns and documenting best practices. Standardized work promotes consistency across process management, ensuring that incremental improvements adhere to project patterns.

Can I use continuous improvement techniques for analyzing root causes of complex code issues?

Yes, continuous improvement integrates with problem-solving commands like /why and /analyse to investigate root causes. These techniques guide the process of incrementally refactoring complex functions while maintaining established project patterns.

When should I not use incremental changes for refactoring a complex function?

You should avoid incremental changes when a complete architectural rewrite is required, as continuous improvement focuses on small enhancements rather than large-scale overhauls. Avoid premature optimization if the system lacks established patterns to standardize.