GitHub

Waza: An 8-Skill Cap That Teaches AI Coding Assistants Senior-Engineer Judgment

By Hey_AI_Coder · Aug 28, 2026

Read original on juejin.cn ↗ Google Translate ↗ Alt translation

Most AI coding skill libraries chase feature count; Waza imposes a hard cap of eight skills and a no-op deletion rule, producing prompts that waste less context and degrade less as models evolve. For teams juggling Claude Code, Codex, and Cursor, it is the only library that installs across all three with one command and the only one that covers UI design sense and writing polish.

Summary

AI coding models produce working code but lack the judgment and habits that distinguish senior engineers: stress-testing requirements before building, hunting root causes instead of patching symptoms, reviewing diffs against a specific project's constraints, and polishing documentation so it reads naturally. Waza packages these instincts into eight skills — `/think`, `/ui`, `/check`, `/hunt`, `/write`, `/learn`, `/read`, and `/health` — each triggered manually so the developer retains control over the workflow. The project enforces a hard cap of eight skills and subjects every instruction to a no-op test: if removing a sentence doesn't change model behavior, it gets cut.

The design philosophy is "give the target, not the path." Skills describe the desired outcome and constraints but never prescribe step-by-step procedures, because models improve and over-specification locks out better approaches. Skills chain together — `/think` → implement → `/check` → merge, or `/hunt` → fix → `/check` → release — but each transition requires a manual trigger, preventing runaway automation. The implementation is deliberately minimal: Markdown definitions, Shell helpers, and Python validation scripts, installable across Claude Code, Codex, and Cursor with a single `npx` command.

Compared to Superpowers (21.8k stars, enforced TDD that deletes code written before tests) and mattpocock/skills (240k stars, strongest domain modeling), Waza occupies a distinct niche. It is the only library offering frontend design (`/ui`), writing polish (`/write`), and Agent health auditing (`/health`), and it supports the widest range of AI coding tools. The project is part of tw93's "Programming Trilogy" alongside Kaku (code generation) and Kami (document publishing).

Takeaways

— Eight skills, hard cap — no ninth skill, no splitting existing ones, to prevent dilution.

— Every skill instruction passes a no-op test: if deleting a sentence doesn't change model output, it gets removed.

— Skills give the target and constraints but never prescribe step-by-step paths, so models can use better approaches as they improve.

— Skill chains are manually triggered at each transition — a skill completes and stops, waiting for the developer to decide the next step.

— `/check` reads a repo's README, package.json, and CI config to apply project-specific constraints during code review, not generic standards.

— A "Durable Context Preflight" shared across skills avoids redundant context loading and maintains information continuity between steps.

— Each skill includes a Gotchas table distilled from 300+ real sessions across 7 projects, not theoretical edge cases.

— `rules/anti-patterns.md` enforces cross-skill guardrails: read before doing, don't exceed scope, don't proactively summarize.

— Installation is a single `npx skills add tw93/Waza -a claude-code codex cursor -g -y` command, adapting automatically to multiple tools.

— Waza is the only major skill library with `/ui` (frontend design sense), `/write` (bilingual writing polish), and `/health` (Agent budget-aware auditing).

— Superpowers enforces TDD by deleting code written before tests; mattpocock/skills leads in domain modeling with `/domain-modeling` and CONTEXT.md.

— The project is part of a trilogy: Kaku writes code, Waza practices engineering habits, Kami publishes documentation.

Conclusions

The hard cap of eight skills is a structural bet against feature creep — it forces the maintainer to improve depth rather than add surface area, which keeps prompts lean as models get more capable.

The no-op deletion rule treats prompt text as a cost center: every sentence that doesn't change behavior is dead weight consuming context windows, a discipline most prompt libraries ignore.

Manual skill-chain triggers solve a real failure mode in autonomous agents — the model running all steps without stopping when an intermediate step goes wrong — by making every transition a human checkpoint.

Project-aware code review (`/check`) sidesteps the generic-review problem by reading live repo metadata, making the review constraints dynamic per project rather than static across all codebases.

Waza's multi-tool installation (Claude Code, Codex, Cursor, Antigravity) addresses a fragmentation pain point that Superpowers and mattpocock/skills largely ignore by focusing on Claude Code alone.

The trilogy framing (Kaku/Waza/Kami) reflects an opinionated view of the AI coding workflow as three separable concerns — generation, habit, and publication — rather than one monolithic assistant.

Concepts & terms

No-op test

A prompt-engineering discipline: delete a sentence from a skill definition; if the model's behavior does not change, the sentence is dead weight and should be removed permanently.

Skill chain

A manually-triggered sequence of Waza skills (e.g., `/think` → implement → `/check` → merge) where each skill completes and stops, requiring the developer to explicitly invoke the next step.

Durable Context Preflight

A shared pre-execution check across Waza skills that loads necessary project context once and reuses it, avoiding redundant context loading and ensuring information continuity between chained skills.

Project-aware code review

A review approach where the AI reads a repository's README, package.json, CI configuration, and other public metadata to derive project-specific constraints before evaluating a code diff, rather than applying a fixed generic standard.

Tacit knowledge / muscle memory

Engineering judgment accumulated through years of practice — stress-testing requirements, root-cause debugging, architectural thinking — that senior engineers apply instinctively but rarely document explicitly.

Source: juejin.cn ↗ Google Translate ↗ Backup ↗