kaizen%3Akaizen by neolabhq/context-engineering-kit
npx skills add https://github.com/neolabhq/context-engineering-kit --skill kaizen:kaizen应用持续改进的思维方式——建议小的迭代改进、防错设计、遵循既定模式、避免过度工程化;自动应用于指导质量和简洁性
持续进行小的改进。通过设计防错。遵循有效的方法。只构建所需的内容。
核心原则: 许多小的改进胜过一次大的变更。在设计时预防错误,而不是通过修复。
始终应用于:
理念: 通过渐进式进步和预防来实现质量,而非通过巨大努力追求完美。
小而频繁的改进会累积成重大收益。
渐进式优于革命式:
始终保持代码更好:
迭代优化:
// 迭代 1:让它能工作
const calculateTotal = (items: Item[]): number => {
let total = 0;
for (const item of items) {
total += item.price * item.quantity;
}
return total;
};
// 迭代 2:让它清晰(重构)
const calculateTotal = (items: Item[]): number => {
return items.reduce((total, item) => {
return total + (item.price * item.quantity);
}, 0);
};
// 迭代 3:让它健壮(添加验证)
const calculateTotal = (items: Item[]): number => {
if (!items?.length) return 0;
return items.reduce((total, item) => {
if (item.price < 0 || item.quantity < 0) {
throw new Error('Price and quantity must be non-negative');
}
return total + (item.price * item.quantity);
}, 0);
};
广告位招租
在这里展示您的产品或服务
触达数万 AI 开发者,精准高效
每个步骤都是完整、经过测试且可工作的
// 试图一次性完成所有事情
const calculateTotal = (items: Item[]): number => {
// 同时进行验证、优化、添加功能、处理边界情况
if (!items?.length) return 0;
const validItems = items.filter(item => {
if (item.price < 0) throw new Error('Negative price');
if (item.quantity < 0) throw new Error('Negative quantity');
return item.quantity > 0; // 同时过滤数量为零的情况
});
// 加上缓存,加上日志记录,加上货币转换...
return validItems.reduce(...); // 一次处理太多关注点
};
令人不知所措、容易出错、难以验证
实现功能时:
重构时:
审查代码时:
设计能在编译/设计时而非运行时预防错误的系统。
使错误不可能发生:
为安全而设计:
分层防御:
// 良好:仅可能有效状态
type OrderStatus = 'pending' | 'processing' | 'shipped' | 'delivered';
type Order = { status: OrderStatus; total: number; };
// 更好:带有关联数据的状态
type Order =
| { status: 'pending'; createdAt: Date }
| { status: 'processing'; startedAt: Date; estimatedCompletion: Date }
| { status: 'shipped'; trackingNumber: string; shippedAt: Date }
| { status: 'delivered'; deliveredAt: Date; signature: string };
// 现在不可能出现已发货但没有 trackingNumber 的情况
类型系统防止了整类错误
// 使无效状态无法表示
type NonEmptyArray<T> = [T, ...T[]];
const firstItem = <T>(items: NonEmptyArray<T>): T => {
return items[0]; // 总是安全的,永远不会是 undefined!
};
// 调用者必须证明数组非空
const items: number[] = [1, 2, 3];
if (items.length > 0) {
firstItem(items as NonEmptyArray<number>); // 安全
}
函数签名保证安全性
// 良好:立即验证
const processPayment = (amount: number) => {
if (amount <= 0) {
throw new Error('Payment amount must be positive');
}
if (amount > 10000) {
throw new Error('Payment exceeds maximum allowed');
}
const fee = amount * 0.03;
// ... 现在可以安全使用
};
// 更好:在边界处验证并使用标记类型
type PositiveNumber = number & { readonly __brand: 'PositiveNumber' };
const validatePositive = (n: number): PositiveNumber => {
if (n <= 0) throw new Error('Must be positive');
return n as PositiveNumber;
};
const processPayment = (amount: PositiveNumber) => {
// amount 保证为正数,无需检查
const fee = amount * 0.03;
};
// 在系统边界处验证
const handlePaymentRequest = (req: Request) => {
const amount = validatePositive(req.body.amount); // 验证一次
processPayment(amount); // 随处安全使用
};
在边界处验证一次,其他地方都安全
// 提前返回防止深层嵌套代码
const processUser = (user: User | null) => {
if (!user) {
logger.error('User not found');
return;
}
if (!user.email) {
logger.error('User email missing');
return;
}
if (!user.isActive) {
logger.info('User inactive, skipping');
return;
}
// 主逻辑在此,保证用户有效且活跃
sendEmail(user.email, 'Welcome!');
};
守卫使假设明确并强制执行
const client = new APIClient({
timeout: 5000
}); // apiKey 缺失!
// 良好:必需配置,尽早失败
type Config = {
apiKey: string;
timeout: number;
};
const loadConfig = (): Config => {
const apiKey = process.env.API_KEY;
if (!apiKey) {
throw new Error('API_KEY environment variable required');
}
return {
apiKey,
timeout: 5000,
};
};
// 如果配置无效,应用在启动时失败,而非在请求期间
const config = loadConfig();
const client = new APIClient(config);
在启动时失败,而非在生产环境中
设计 API 时:
处理错误时:
配置时:
遵循既定模式。记录有效的方法。使良好实践易于遵循。
一致性优于巧妙性:
文档与代码共存:
自动化标准:
// 现有代码库的 API 客户端模式
class UserAPIClient {
async getUser(id: string): Promise<User> {
return this.fetch(`/users/${id}`);
}
}
// 新代码遵循相同模式
class OrderAPIClient {
async getOrder(id: string): Promise<Order> {
return this.fetch(`/orders/${id}`);
}
}
一致性使代码库可预测
// 新代码未经讨论引入了不同模式
const getOrder = async (id: string): Promise<Order> => {
// 破坏一致性,"因为我更喜欢函数"
};
不一致性造成混淆
// 项目标准:Result 类型用于可恢复错误
type Result<T, E> = { ok: true; value: T } | { ok: false; error: E };
// 所有服务都遵循此模式
const fetchUser = async (id: string): Promise<Result<User, Error>> => {
try {
const user = await db.users.findById(id);
if (!user) {
return { ok: false, error: new Error('User not found') };
}
return { ok: true, value: user };
} catch (err) {
return { ok: false, error: err as Error };
}
};
// 调用者使用一致的模式
const result = await fetchUser('123');
if (!result.ok) {
logger.error('Failed to fetch user', result.error);
return;
}
const user = result.value; // 类型安全!
跨代码库的标准模式
添加新模式前:
编写代码时:
审查时:
构建当前所需。不多不少。避免过早优化和过度工程化。
YAGNI(你不需要它):
最简单的可行方案:
在测量后优化:
class ConsoleTransport implements LogTransport { /*...*/ }
class FileTransport implements LogTransport { /* ... */ }
class RemoteTransport implements LogTransport { /* ...*/ }
class Logger {
private transports: LogTransport[] = [];
private queue: LogEntry[] = [];
private rateLimiter: RateLimiter;
private formatter: LogFormatter;
// 200 行代码用于"也许我们以后会需要"
}
const logError = (error: Error) => {
Logger.getInstance().log('error', error.message);
};
为想象中的未来需求构建
何时添加复杂性:
// 从简单开始
const formatCurrency = (amount: number): string => {
return `$${amount.toFixed(2)}`;
};
// 需求演变:支持多种货币
const formatCurrency = (amount: number, currency: string): string => {
const symbols = { USD: '$', EUR: '€', GBP: '£' };
return `${symbols[currency]}${amount.toFixed(2)}`;
};
// 需求演变:支持本地化
const formatCurrency = (amount: number, locale: string): string => {
return new Intl.NumberFormat(locale, {
style: 'currency',
currency: locale === 'en-US' ? 'USD' : 'EUR',
}).format(amount);
};
仅在需要时添加复杂性
class GenericRepository { /*300 行 */ }
class QueryBuilder { /* 200 行*/ }
// ... 为单个表构建整个 ORM
为不确定的未来构建庞大的抽象
// 针对当前需求的简单函数
const getUsers = async (): Promise<User[]> => {
return db.query('SELECT * FROM users');
};
const getUserById = async (id: string): Promise<User | null> => {
return db.query('SELECT * FROM users WHERE id = $1', [id]);
};
// 当模式在多个实体中出现时,再进行抽象
仅当模式在 3 个以上案例中得到验证时才进行抽象
// 基准测试显示:1000 个用户耗时 50ms(可接受)
// ✓ 发布它,无需优化
// 之后:分析显示这是瓶颈
// 然后使用索引查找或缓存进行优化
基于测量而非假设进行优化
// 过早优化
const filterActiveUsers = (users: User[]): User[] => {
// "这可能很慢,所以让我们缓存和索引"
const cache = new WeakMap();
const indexed = buildBTreeIndex(users, 'isActive');
// 100 行优化代码
// 增加复杂性,更难维护
// 没有证据表明需要它
};
针对未测量问题的复杂解决方案
实现时:
优化时:
抽象时:
Kaizen 技能指导您的工作方式。命令提供结构化分析:
/why : 根本原因分析(5 Whys)/cause-and-effect : 多因素分析(鱼骨图)/plan-do-check-act : 迭代改进周期/analyse-problem : 全面文档记录(A3)/analyse : 智能方法选择(现场观察/价值流图/浪费分析)使用命令进行结构化问题解决。应用技能进行日常开发。
违反持续改进:
违反防错:
违反标准化工作:
违反准时制:
Kaizen 是关于:
不是关于:
心态: 今天足够好,明天会更好。重复。
每周安装数
231
代码仓库
GitHub 星标数
699
首次出现
2026 年 2 月 19 日
安装于
opencode223
codex222
github-copilot221
gemini-cli220
kimi-cli218
amp218
Apply continuous improvement mindset - suggest small iterative improvements, error-proof designs, follow established patterns, avoid over-engineering; automatically applied to guide quality and simplicity
Small improvements, continuously. Error-proof by design. Follow what works. Build only what's needed.
Core principle: Many small improvements beat one big change. Prevent errors at design time, not with fixes.
Always applied for:
Philosophy: Quality through incremental progress and prevention, not perfection through massive effort.
Small, frequent improvements compound into major gains.
Incremental over revolutionary:
Always leave code better:
Iterative refinement:
// Iteration 2: Make it clear (refactor) const calculateTotal = (items: Item[]): number => { return items.reduce((total, item) => { return total + (item.price * item.quantity); }, 0); };
// Iteration 3: Make it robust (add validation) const calculateTotal = (items: Item[]): number => { if (!items?.length) return 0;
return items.reduce((total, item) => { if (item.price < 0 || item.quantity < 0) { throw new Error('Price and quantity must be non-negative'); } return total + (item.price * item.quantity); }, 0); };
Each step is complete, tested, and working
</Good>
<Bad>
```typescript
// Trying to do everything at once
const calculateTotal = (items: Item[]): number => {
// Validate, optimize, add features, handle edge cases all together
if (!items?.length) return 0;
const validItems = items.filter(item => {
if (item.price < 0) throw new Error('Negative price');
if (item.quantity < 0) throw new Error('Negative quantity');
return item.quantity > 0; // Also filtering zero quantities
});
// Plus caching, plus logging, plus currency conversion...
return validItems.reduce(...); // Too many concerns at once
};
Overwhelming, error-prone, hard to verify
When implementing features:
When refactoring:
When reviewing code:
Design systems that prevent errors at compile/design time, not runtime.
Make errors impossible:
Design for safety:
Defense in layers:
// Good: Only valid states possible type OrderStatus = 'pending' | 'processing' | 'shipped' | 'delivered'; type Order = { status: OrderStatus; total: number; };
// Better: States with associated data type Order = | { status: 'pending'; createdAt: Date } | { status: 'processing'; startedAt: Date; estimatedCompletion: Date } | { status: 'shipped'; trackingNumber: string; shippedAt: Date } | { status: 'delivered'; deliveredAt: Date; signature: string };
// Now impossible to have shipped without trackingNumber
Type system prevents entire classes of errors
</Good>
<Good>
```typescript
// Make invalid states unrepresentable
type NonEmptyArray<T> = [T, ...T[]];
const firstItem = <T>(items: NonEmptyArray<T>): T => {
return items[0]; // Always safe, never undefined!
};
// Caller must prove array is non-empty
const items: number[] = [1, 2, 3];
if (items.length > 0) {
firstItem(items as NonEmptyArray<number>); // Safe
}
Function signature guarantees safety
// Good: Validate immediately const processPayment = (amount: number) => { if (amount <= 0) { throw new Error('Payment amount must be positive'); } if (amount > 10000) { throw new Error('Payment exceeds maximum allowed'); }
const fee = amount * 0.03; // ... now safe to use };
// Better: Validation at boundary with branded type type PositiveNumber = number & { readonly __brand: 'PositiveNumber' };
const validatePositive = (n: number): PositiveNumber => { if (n <= 0) throw new Error('Must be positive'); return n as PositiveNumber; };
const processPayment = (amount: PositiveNumber) => { // amount is guaranteed positive, no need to check const fee = amount * 0.03; };
// Validate at system boundary const handlePaymentRequest = (req: Request) => { const amount = validatePositive(req.body.amount); // Validate once processPayment(amount); // Use everywhere safely };
Validate once at boundary, safe everywhere else
</Good>
#### Guards and Preconditions
<Good>
```typescript
// Early returns prevent deeply nested code
const processUser = (user: User | null) => {
if (!user) {
logger.error('User not found');
return;
}
if (!user.email) {
logger.error('User email missing');
return;
}
if (!user.isActive) {
logger.info('User inactive, skipping');
return;
}
// Main logic here, guaranteed user is valid and active
sendEmail(user.email, 'Welcome!');
};
Guards make assumptions explicit and enforced
const client = new APIClient({ timeout: 5000 }); // apiKey missing!
// Good: Required config, fails early type Config = { apiKey: string; timeout: number; };
const loadConfig = (): Config => { const apiKey = process.env.API_KEY; if (!apiKey) { throw new Error('API_KEY environment variable required'); }
return { apiKey, timeout: 5000, }; };
// App fails at startup if config invalid, not during request const config = loadConfig(); const client = new APIClient(config);
Fail at startup, not in production
</Good>
#### In Practice
**When designing APIs:**
- Use types to constrain inputs
- Make invalid states unrepresentable
- Return Result<T, E> instead of throwing
- Document preconditions in types
**When handling errors:**
- Validate at system boundaries
- Use guards for preconditions
- Fail fast with clear messages
- Log context for debugging
**When configuring:**
- Required over optional with defaults
- Validate all config at startup
- Fail deployment if config invalid
- Don't allow partial configurations
### 3. Standardized Work
Follow established patterns. Document what works. Make good practices easy to follow.
#### Principles
**Consistency over cleverness:**
- Follow existing codebase patterns
- Don't reinvent solved problems
- New pattern only if significantly better
- Team agreement on new patterns
**Documentation lives with code:**
- README for setup and architecture
- CLAUDE.md for AI coding conventions
- Comments for "why", not "what"
- Examples for complex patterns
**Automate standards:**
- Linters enforce style
- Type checks enforce contracts
- Tests verify behavior
- CI/CD enforces quality gates
#### Following Patterns
<Good>
```typescript
// Existing codebase pattern for API clients
class UserAPIClient {
async getUser(id: string): Promise<User> {
return this.fetch(`/users/${id}`);
}
}
// New code follows the same pattern
class OrderAPIClient {
async getOrder(id: string): Promise<Order> {
return this.fetch(`/orders/${id}`);
}
}
Consistency makes codebase predictable
// New code introduces different pattern without discussion const getOrder = async (id: string): Promise => { // Breaking consistency "because I prefer functions" };
Inconsistency creates confusion
</Bad>
#### Error Handling Patterns
<Good>
```typescript
// Project standard: Result type for recoverable errors
type Result<T, E> = { ok: true; value: T } | { ok: false; error: E };
// All services follow this pattern
const fetchUser = async (id: string): Promise<Result<User, Error>> => {
try {
const user = await db.users.findById(id);
if (!user) {
return { ok: false, error: new Error('User not found') };
}
return { ok: true, value: user };
} catch (err) {
return { ok: false, error: err as Error };
}
};
// Callers use consistent pattern
const result = await fetchUser('123');
if (!result.ok) {
logger.error('Failed to fetch user', result.error);
return;
}
const user = result.value; // Type-safe!
Standard pattern across codebase
Before adding new patterns:
When writing code:
When reviewing:
Build what's needed now. No more, no less. Avoid premature optimization and over-engineering.
YAGNI (You Aren't Gonna Need It):
Simplest thing that works:
Optimize when measured:
class ConsoleTransport implements LogTransport { /.../ } class FileTransport implements LogTransport { /_ ... / } class RemoteTransport implements LogTransport { / ..._/ }
class Logger { private transports: LogTransport[] = []; private queue: LogEntry[] = []; private rateLimiter: RateLimiter; private formatter: LogFormatter;
// 200 lines of code for "maybe we'll need it" }
const logError = (error: Error) => { Logger.getInstance().log('error', error.message); };
Building for imaginary future requirements
</Bad>
**When to add complexity:**
- Current requirement demands it
- Pain points identified through use
- Measured performance issues
- Multiple use cases emerged
<Good>
```typescript
// Start simple
const formatCurrency = (amount: number): string => {
return `$${amount.toFixed(2)}`;
};
// Requirement evolves: support multiple currencies
const formatCurrency = (amount: number, currency: string): string => {
const symbols = { USD: '$', EUR: '€', GBP: '£' };
return `${symbols[currency]}${amount.toFixed(2)}`;
};
// Requirement evolves: support localization
const formatCurrency = (amount: number, locale: string): string => {
return new Intl.NumberFormat(locale, {
style: 'currency',
currency: locale === 'en-US' ? 'USD' : 'EUR',
}).format(amount);
};
Complexity added only when needed
class GenericRepository { /300 lines / } class QueryBuilder { / 200 lines/ } // ... building entire ORM for single table
Massive abstraction for uncertain future
</Bad>
<Good>
```typescript
// Simple functions for current needs
const getUsers = async (): Promise<User[]> => {
return db.query('SELECT * FROM users');
};
const getUserById = async (id: string): Promise<User | null> => {
return db.query('SELECT * FROM users WHERE id = $1', [id]);
};
// When pattern emerges across multiple entities, then abstract
Abstract only when pattern proven across 3+ cases
// Benchmark shows: 50ms for 1000 users (acceptable) // ✓ Ship it, no optimization needed
// Later: After profiling shows this is bottleneck // Then optimize with indexed lookup or caching
Optimize based on measurement, not assumptions
</Good>
<Bad>
```typescript
// Premature optimization
const filterActiveUsers = (users: User[]): User[] => {
// "This might be slow, so let's cache and index"
const cache = new WeakMap();
const indexed = buildBTreeIndex(users, 'isActive');
// 100 lines of optimization code
// Adds complexity, harder to maintain
// No evidence it was needed
};
Complex solution for unmeasured problem
When implementing:
When optimizing:
When abstracting:
The Kaizen skill guides how you work. The commands provide structured analysis:
/why : Root cause analysis (5 Whys)/cause-and-effect : Multi-factor analysis (Fishbone)/plan-do-check-act : Iterative improvement cycles/analyse-problem : Comprehensive documentation (A3)/analyse : Smart method selection (Gemba/VSM/Muda)Use commands for structured problem-solving. Apply skill for day-to-day development.
Violating Continuous Improvement:
Violating Poka-Yoke:
Violating Standardized Work:
Violating Just-In-Time:
Kaizen is about:
Not about:
Mindset: Good enough today, better tomorrow. Repeat.
Weekly Installs
231
Repository
GitHub Stars
699
First Seen
Feb 19, 2026
Installed on
opencode223
codex222
github-copilot221
gemini-cli220
kimi-cli218
amp218
Perl测试完全指南:Test2::V0、Test::More与TDD实践
791 周安装
AI访谈总结工具 - 自动生成结构化客户访谈摘要,提升产品管理效率
226 周安装
Azure成本优化技能:识别节省机会、清理孤立资源、调整规模 | Microsoft Copilot
103,300 周安装
Azure AI 服务指南:AI Search、Speech、OpenAI 与 MCP 工具使用教程
103,700 周安装
React 组合模式指南:Vercel 组件架构最佳实践,提升代码可维护性
107,800 周安装
Skill Creator 技能创建工具 - Anthropic Claude 技能开发指南
118,800 周安装
agent-browser 浏览器自动化工具 - Vercel Labs 命令行网页操作与测试
144,300 周安装