---
title: "Kaizen: Addy Osmani's agent-skills, held in place by hooks"
description: "Kaizen, a Claude Code plugin (MIT): Addy Osmani's agent-skills embedded, plus hooks that block, a memory and PR follow-up."
url: "https://angelo-lima.fr/en/kaizen-ai-sdlc-claude-code-en/"
lang: "en"
author: "Angelo Lima"
datePublished: "2026-10-08T00:00:00.000Z"
dateModified: "2026-11-17T00:00:00.000Z"
tags: ["IA","Development","Claude Code"]
translation: "https://angelo-lima.fr/fr/kaizen-sdlc-ia-claude-code/"
---

# Kaizen: Addy Osmani's agent-skills, held in place by hooks

*A coding agent speeds everything up, mistakes included. Kaizen takes the agent-skills method and has its critical rules checked by code in Claude Code.*

A coding agent writes fast. It also sometimes forgets the tests, or pushes a branch nobody reviewed. The [DORA 2025](https://dora.dev/research/) report measured it: AI raises team throughput, and instability along with it, except in teams that keep clear principles, small batches and real feedback.

**Kaizen** is the plugin I wrote to make those disciplines hold in Claude Code. It no longer has a method of its own. It embeds Addy Osmani's, [agent-skills](https://github.com/addyosmani/agent-skills), and handles the rest: what the skills ask the agent to do, Kaizen's hooks check.

> **Update, November 17, 2026.** The first version of this article described Kaizen 3.2.1, which went all the way to deployment and monitoring with its own method. Kaizen has since been rebuilt: the production part was removed, and version 1.0.0 of November 11 starts from a fresh base around agent-skills. The article now covers version 1.1.0.

> **In brief**
>
> - **What:** Kaizen is an open source (MIT) Claude Code plugin that embeds Addy Osmani's agent-skills and adds checks enforced by code, a memory between cycles, PR follow-up and metrics.
> - **Key numbers:** version 1.1.0, November 11, 2026, agent-skills 0.6.15 embedded as is, 15 `/kaizen:` commands, 4 skills of its own, 8 hooks, a Node.js CLI with no npm dependency.
> - **What sets it apart:** Claude cannot end a turn on red tests, commit a secret, or push an unreviewed branch unless you allow it.
> - **Where it stops:** at the merge-ready pull request. Merging and deploying are yours.
> - **Where it comes from:** the agent-skills method, the learning loop and PR follow-up of Every's [Compound Engineering](https://github.com/EveryInc/compound-engineering-plugin), DORA's practices.

## Why agent-skills

In April, in [my map of SDD, Compound Engineering and BMAD](https://angelo-lima.fr/en/sdd-compound-engineering-bmad-philosophies-en/), I asked whether you could combine the rigor of a spec with a learning loop. The first versions of Kaizen answered with a method of their own, from requirement to production. They did a lot, and that was the problem: one more method to learn.

agent-skills already covers the development loop with little ceremony. Plain Markdown files (`SPEC.md`, `tasks/`), one skill per concern, and in each an exit criterion, a table of excuses to refuse and the evidence to show. It already runs in many agents. Kaizen embeds it unmodified, syncs it by pull request and only adds what is missing.

## Who does what

| Concern | agent-skills | Kaizen |
|---|---|---|
| Spec, plan, tasks | `/kaizen:spec`, `/kaizen:plan`, `SPEC.md`, `tasks/` | brings the matching learnings back when those files are written |
| Code and tests | `/kaizen:build`, `/kaizen:test`, test first | quality gate: no end of turn on red checks |
| Review | `/kaizen:review` on five axes, `code-reviewer` persona | records it by itself and blocks pushing an unreviewed branch |
| Secrets | `security-and-hardening` skill | no commit carrying a key or token |
| Launch | `/kaizen:ship`, go/no-go checklist | nothing |
| Open PR | nothing | `/kaizen:watch` follows it until it looks ready |
| Memory | nothing | `/kaizen:learn`, read back by the hooks |
| Measurement | nothing | `/kaizen:metrics`: approximated DORA, learnings reuse, friction, cost |

agent-skills' nine commands move under the `/kaizen:` prefix. Six more open agent-skills skills that had no command: `ideate`, `debug`, `adr`, `security`, `doubt` and `migrate`. Kaizen's own four skills are `setup`, `learn`, `metrics` and `watch`.

## The critical rules are hooks

Writing "run the tests before finishing" in `CLAUDE.md` works nine times out of ten. The tenth time the session is long, the context compacted, and Claude reports that all is well over a red suite. So Kaizen puts those rules in [hooks](https://angelo-lima.fr/en/claude-code-hooks/), which Claude Code runs without being asked.

- **At the end of a turn**, once the session has edited code, the configured checks (tests, lint) must pass. After three blocks, Claude has to say what is still red.
- **Before a push**, an unreviewed branch is stopped. Claude offers the review first, and only you can let it go without one, in Claude Code's own prompt.
- **Before a commit**, about thirty key and token formats are refused, and so is `--no-verify`.
- **While writing**, when `SPEC.md` or `tasks/` change, or a file a learning names is edited, the lesson comes back into the context.

These hooks guard against forgetfulness. Against a malicious agent they are not enough: an intermediate script gets around them, and the plugin's docs say so.

## A loop that learns

[![Kaizen around agent-skills: agent-skills' commands on top, Kaizen's hooks under them, the PR followed until it looks ready, the merge left to you, learnings written to the project memory and read back by the next spec](https://angelo-lima.fr/assets/img/kaizen-loop-en.svg)](https://angelo-lima.fr/assets/img/kaizen-loop-en.svg)

This is what Compound Engineering brings. One lesson per file in `docs/learnings/`, written by `/kaizen:learn`. No need to remember to read it: a hook puts it back in the context at the right time. `/kaizen:metrics` then measures whether the loop really turns, with DORA metrics approximated from git and GitHub, learnings reuse, friction and the token cost of each feature or fix.

The whole cycle fits in a few commands: `/kaizen:setup` once per repository, then `spec`, `plan`, `build`, `review`, `ship` and `watch`. Then you merge. Kaizen never merges.

## Try it

```
/plugin marketplace add Lingelo/dojo
/plugin install kaizen@dojo
```

You need Node.js 18 or later, git, and `gh` for PRs. In your repository, `/kaizen:setup` writes the configuration, declares the plugin for every clone and tells you which command to run next. Code and docs are on [GitHub](https://github.com/Lingelo/dojo/tree/main/plugins/kaizen). For how plugins work, see [my article on Claude Code marketplaces](https://angelo-lima.fr/en/claude-code-plugins-marketplace/).

## Frequently asked questions

### What is Kaizen for Claude Code?

Kaizen is an open source (MIT) Claude Code plugin that embeds Addy Osmani's agent-skills and adds what they don't do: hooks that block, a memory of lessons learned, pull request follow-up and metrics. Version 1.1.0 was released on November 11, 2026.

### How does Kaizen relate to agent-skills?

agent-skills, Addy Osmani's MIT project, provides the method: spec, plan, build, test, review, ship, each with exit criteria. Kaizen embeds it unmodified under the /kaizen: prefix and uses hooks to check what agent-skills asks of the agent: green tests, a review before push, no committed secret.

### How do I install Kaizen?

In Claude Code, add the marketplace with /plugin marketplace add Lingelo/dojo, then install the plugin with /plugin install kaizen@dojo. Kaizen needs Node.js 18 or later and git, plus gh for pull requests. In a repository, start with /kaizen:setup.

### Can Kaizen merge or deploy to production?

No. Kaizen stops at a merge-ready pull request. Merging, deploying and watching production stay with the team and its own tools.

### Does Kaizen work with agents other than Claude Code?

Partly. agent-skills' skills and the learnings are Markdown that any agent can read, but Kaizen's checks (quality gate, recorded review, learnings read back) rely on Claude Code's hooks.
