CtrlK
BlogDocsLog inGet started
Tessl Logo
SkillPublic

kaizen

Use when Code implementation and refactoring, architecturing or designing systems, process and workflow improvements, error handling and validation. Provide tehniquest to avoid over-engineering and apply iterative improvements.

Quality

53%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide
SecuritybySnyk

Passed

No findings from the security scan

Fix and improve this skill with Tessl

tessl review fix ./plugins/kaizen/skills/kaizen/SKILL.md
SKILL.md
Quality
Evals
Security

Quality

Content

46%Weight 40%Scale 1-5

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

The content is highly actionable with numerous concrete, executable TypeScript examples, but it is severely verbose — repeatedly explaining well-known concepts and restating its own principles across prose, bullets, examples, and a recap. Structurally it is a monolithic inline wall of text with no progressive disclosure into reference files.

Suggestions

Cut the prose explanations of concepts Claude already knows (YAGNI, premature optimization, type safety) and keep only the distilled principle plus one Good/Bad example per pillar to roughly halve the length.

Split the four pillars into separate reference files (e.g. references/poka-yoke.md, references/jit.md) and keep SKILL.md as a concise overview with one-level-deep links, enabling progressive disclosure.

Convert the 'In Practice' lists into concrete, checkpointed workflows with explicit validate/verify steps where the guidance involves batch or error-prone operations.

DimensionReasoningScore

Conciseness

At ~730 lines the body extensively explains concepts Claude already knows (YAGNI, poka-yoke, type-system basics, premature optimization) and restates the same principles multiple times across prose, bullets, Good/Bad blocks, and a closing 'Remember' section, making it severely verbose and heavily padded.

1 / 5

Actionability

It provides multiple copy-paste-ready, executable TypeScript examples spanning the common cases — iterative calculateTotal refinement, invalid-state-unrepresentable types, boundary validation, Result<T,E>, and YAGNI vs over-engineered logger — fully covering the common cases with concrete code.

5 / 5

Workflow Clarity

The 'In Practice' sections list sequenced steps (e.g. '1. Start with simplest version... 3. Test and verify'), but these are general guidance rather than a concrete workflow with explicit validation checkpoints or feedback loops, matching the anchor where steps are listed but checkpoints are missing or implicit.

3 / 5

Progressive Disclosure

The entire body is a single monolithic inline document with no references or bundle files; content that clearly belongs in separate files (per-pillar guides, an example catalog, an API pattern reference) is inlined, matching the minimal-structure anchor where inlined content should be split.

2 / 5

Total

11

/

20

Passed

Description

40%Weight 40%Scale 1-5

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

The description attempts to cover a wide range of software-engineering domains but does so with generic, awkwardly phrased language and a typo ('tehniquest'), reducing both specificity and trigger quality. It states an explicit 'when' trigger but the 'what' is only weakly specified, and its breadth creates high overlap risk with general coding skills.

Suggestions

Rewrite in third-person imperative voice with concrete verbs (e.g. 'Suggests small iterative code improvements, error-proofs designs via types and validation, and avoids over-engineering'), fixing the 'tehniquest' typo.

Sharpen the 'what' beyond 'improvements' and 'refactoring' by listing 2-3 concrete actions so the skill's value is distinguishable from generic coding guidance.

Narrow the 'Use when' trigger to natural phrases users actually say (e.g. 'Use when refactoring, designing error-proof APIs, or reviewing code for over-engineering') to reduce conflict with broad coding skills.

DimensionReasoningScore

Specificity

It names several domains ('Code implementation and refactoring', 'architecturing or designing systems', 'error handling and validation') but the actions are minimal and generic ('improvements', 'refactoring') rather than concrete verbs, matching the anchor where the domain is named but actions are minimal.

2 / 5

Completeness

It has an explicit 'Use when' clause covering when to apply it, but the 'what' is weakly conveyed through the same clause and 'Provide tehniquest to avoid over-engineering' (with a typo), so the what is clear only loosely with no separate concrete statement.

3 / 5

Trigger Term Quality

'Use when Code implementation and refactoring, ... error handling and validation' provides some relevant keywords users would say, but the phrasing is awkward and it misses common synonyms and natural phrasings, fitting the anchor with some relevant keywords but missing variations.

3 / 5

Distinctiveness Conflict Risk

'Code implementation and refactoring, architecturing or designing systems, process and workflow improvements, error handling and validation' is very broad with high overlap risk against virtually any general coding or design skill, matching the very-broad anchor.

2 / 5

Total

10

/

20

Passed

Validation

93%

Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.

Validation — 15 / 16 Passed

Validation for skill structure

CriteriaDescriptionResult

skill_md_line_count

SKILL.md is long (734 lines); consider splitting into references/ and linking

Warning

Total

15

/

16

Passed

Repository

NeoLabHQ/context-engineering-kit

Path

plugins/kaizen/skills/kaizen/SKILL.md

Reviewed

Table of Contents

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.