Waza: An 8-Skill Cap That Teaches AI Coding Assistants Senior-Engineer Judgment
Superpower Isn't the "Smartest" — This Open-Source Project Teaches Models the Muscle Memory of Senior Engineers
Waza is a skill set designed for AI coding assistants, converting the "tacit knowledge" of senior engineers into standardized processes that AI can execute.
The "Last Mile" Problem in AI Coding
Large models like GPT-4 and Claude are already quite capable at writing code. Give them a requirement, and they'll spit out a pile of code in no time.
But here's the problem — the code they write always falls a bit short.
Not in terms of syntax errors, but that feeling of "obviously written by a novice." The code runs, but it's not elegant; the functionality is implemented, but the considerations are incomplete.
Why?
Because programming isn't just about writing code. A senior engineer's value often lies in things that "aren't written in the code":
- Stress-testing during requirements analysis
- Architectural thinking before writing code
- Root cause analysis when bugs appear
- Attention to detail during code review
- Polishing expression when writing documentation
These abilities are what we call "engineering habits" or "muscle memory." They are intuitions accumulated through years of real-world practice, hard to articulate in a few words.
What Waza aims to do is make this "tacit knowledge" explicit, turning it into skills that AI can execute.
GitHub:
Core Design: 8 Skills, 8 Engineering Intuitions
Waza's core consists of 8 skills, each corresponding to a key engineering habit:
| Skill | Trigger Timing | What It Does |
|---|---|---|
/think |
Before starting a new feature | Challenges the problem itself, stress-tests the design plan, generates an executable plan |
/ui |
When building front-end interfaces | Produces UI with design sense, not cookie-cutter default styles |
/check |
After completing a task | Reviews code diffs, extracts project constraints, handles release processes |
/hunt |
When encountering a bug | Systematic debugging, finds the root cause before fixing |
/write |
When writing documentation | Rewrites copy so both Chinese and English read naturally and fluently |
/learn |
When learning a new domain | Six-stage research workflow: Collect → Digest → Outline → Fill → Refine → Publish |
/read |
When reading URLs/PDFs | Platform-specific routing, intelligent summarization or conversion |
/health |
When auditing an Agent | Checks configuration, permissions, output quality, gives a budget-aware summary |
Note: 8 is a hard cap. The author explicitly states: no adding a 9th, no splitting existing ones. This restraint is smart — too many skills dilute the value of each one.
Design Philosophy: Give the Target, Not the Path
Waza's most interesting design philosophy is captured in this original line:
"Give the model the target, not the path."
In other words: tell the model what result you want, but don't prescribe how it gets there.
This runs counter to most AI tooling. Many tools love to write elaborate flowcharts and step-by-step instructions, eager to lock down every move.
But Waza says: no. Because —
Models are evolving. A task that needs 10 steps today might be done in 3 steps tomorrow. Over-specifying limits the model's potential.
Judgment matters more than execution. Writing code is execution, but "should we even build this feature" or "is this design elegant enough" is judgment. Waza leaves the judgment to the model, providing only clear goals and constraints.
Brevity is a hard constraint. Every skill passes a "no-op test": if you delete a sentence, does the model's behavior change? If not, delete it. Because filler that "says something without saying anything" only consumes context, adding zero value.
Skill Chains: The Power of Composition
Individual skills are already useful, but Waza's real power lies in skill chains — chaining multiple skills together.
A few typical workflows:
Planning a new feature:
/think → approval → "implement X" → /check → merge
Fixing a bug:
/hunt → fix → /check → release
Research and writing:
/read (gather materials) → /learn (comprehensive analysis) → /write (polish expression)
Debug and verify:
/hunt (find root cause) → fix → /check (review changes)
The key: every skill switch is manually triggered. A skill completes and stops, waiting for you to decide the next step.
This design is clever. It keeps control in human hands, avoiding the situation where AI excitedly runs through all steps and can't stop when something goes wrong midway.
Technical Implementation: Simple but Not Simplistic
From a technical perspective, Waza's implementation is remarkably restrained:
Tech stack:
- Markdown (skill definitions)
- Shell (helper scripts)
- Python (validation scripts)
No flashy frameworks, no complex dependencies. The entire project is just a bunch of Markdown files + some lightweight scripts.
Directory structure:
skills/ # 8 core skills
rules/ # Shared behavioral rules
scripts/ # Build and validation scripts
tests/ # Smoke tests
plugins/ # Codex plugin mirrors
Installation:
npx skills add tw93/Waza -a claude-code codex cursor -g -y
One command, automatically adapting to multiple AI coding tools (Claude Code, Codex, Cursor, etc.).
Validation mechanism:
make test # run all tests
make regenerate # regenerate metadata
make package # package for release
A complete CI/CD pipeline; every change must pass tests.
Highlight Breakdown: A Few Designs Worth Learning From
1. Project-Aware Code Review
The /check skill has a clever design: it automatically reads the target repository's public context (README, package.json, CI config, etc.), understands the project's specific constraints, and then reviews code based on those constraints.
This means: it doesn't use a one-size-fits-all standard to review every project, but adjusts review focus according to each project's characteristics.
2. Persistent Context Preflight
Multiple skills share a "Durable Context Preflight." Before executing any skill, it first checks whether necessary context exists. This avoids redundant loading and ensures information continuity between skills.
3. Anti-Jitter Design
Each skill has a "Gotchas" table, recording real pitfalls encountered in actual projects. These aren't theoretical deductions but failure experiences distilled from 300+ sessions across 7 real projects.
4. Anti-Pattern Rules
rules/anti-patterns.md defines cross-skill behavioral guardrails:
- Read before doing
- Don't go beyond scope
- Don't proactively summarize
These rules apply to all 8 skills, ensuring the AI doesn't "act on its own."
Project Background: The "Middle Child" of a Trilogy
Waza doesn't exist in isolation; it's one of tw93's "Programming Trilogy":
| Project | Japanese | Meaning | Role |
|---|---|---|---|
| Kaku | 書く | Write | Dad (writing code) |
| Waza | 技 | Technique | Older sister (practicing habits) |
| Kami | 紙 | Paper | Younger sister (publishing docs) |
This personified metaphor is quite interesting. Writing code is the foundation (Dad), practicing habits is the advancement (older sister), publishing docs is the finishing touch (younger sister).
The three projects each have their own role, together forming a complete AI coding workflow.
Horizontal Comparison: Three Major AI Coding Skill Libraries
AI coding skill libraries aren't just Waza. The three hottest projects right now are: Waza, Superpowers, and mattpocock/skills. Each has its own emphasis, suited to different scenarios.
| Dimension | Waza (tw93) | Superpowers (obra) | mattpocock/skills |
|---|---|---|---|
| Stars | 6.9k | 21.8k | 240k |
| Installs | - | 1M+ | - |
| Skill Count | 8 (hard cap) | 20+ | 15+ |
| Core Philosophy | Give target, not path | Enforce TDD discipline | Solve four failure modes |
| Tech Stack | Markdown/Shell/Python | Markdown/TypeScript | Markdown |
| TDD Support | None | Enforced (write tests first) | Yes (/tdd) |
| Debugging | /hunt (root cause analysis) | Yes (systematic debugging) | /diagnosing-bugs |
| Code Review | /check (project-aware) | Yes (sub-agent review) | /code-review |
| Requirement Alignment | /think (stress test) | /brainstorm | /grill-me |
| Domain Modeling | None | None | /domain-modeling + CONTEXT.md |
| Frontend Design | /ui | None | None |
| Learning & Research | /learn + /read | None | /research |
| Writing & Polishing | /write | None | None |
| Health Audit | /health | None | None |
| Installation | npx skills add | Claude Code plugin | Claude Code plugin / npx skills |
| Multi-Tool Support | Claude/Codex/Cursor/Antigravity | Mainly Claude Code | Mainly Claude Code |
| Project Background | Part of trilogy (Kaku/Waza/Kami) | Standalone project | Crystallization of personal experience |
| Target Audience | Full-stack engineers | Teams valuing TDD | Teams valuing architecture design |
Differentiated Positioning
Waza's unique value:
- The only one supporting
/ui(frontend design) and/write(writing polish) - The only one providing
/health(Agent health audit) - Restrained design: 8 skills is a hard cap, rejecting feature bloat
- Best multi-tool support (Claude/Codex/Cursor/Antigravity)
Superpowers' unique value:
- Enforced TDD discipline: if you write code before tests, it will delete your code
- Sub-agent architecture: each task uses an independent AI instance, avoiding context pollution
- Anthropic officially validated, installs exceeding 1 million
mattpocock/skills' unique value:
- Strongest domain modeling capability (/domain-modeling + CONTEXT.md)
- Solves the "codebase turns into a mud ball" problem (/improve-codebase-architecture)
- Largest community (240k Stars), richest documentation
Selection Advice
| Your Situation | Recommendation |
|---|---|
| Want "less is more," don't want too many choices | Waza |
| Team code quality is uneven, need enforced standards | Superpowers |
| Project is complex, needs domain modeling and architecture governance | mattpocock/skills |
| Need frontend design or writing polish | Waza |
| Need multi-tool support (Codex/Cursor) | Waza |
| Value TDD and sub-agent collaboration | Superpowers |
Applicable Scenarios: Who Would Use This?
Best suited for:
Developers who use AI coding tools daily: If you're already using Claude Code, Copilot, etc., Waza can significantly improve output quality.
Tech team leads: Can serve as the team's "AI coding standard," unifying quality standards for AI-assisted programming.
Power users of AI tools: Those who want AI to better understand engineering thinking, not just act as a code generator.
Less suited scenarios:
- People who don't use AI coding at all
- Scenarios requiring only simple code generation
- Projects with low requirements for AI coding output quality
GitHub:
Personal Assessment: Restraint Is the Greatest Virtue
After reading through Waza's code and documentation, my biggest takeaway is: restraint.
8 skills is a hard cap, no adding allowed. Every sentence must pass a no-op test; useless ones get deleted. No complex frameworks — Markdown + Shell + Python is enough. Don't prescribe the model's path, only give goals and constraints.
This restraint, paradoxically, gives Waza stronger vitality.
Because simple things are easier to maintain, easier to spread, and easier for models to understand.
In an era where AI tools are blooming everywhere, Waza chose the "less is more" path. It doesn't try to solve every problem, only focusing on the 8 most critical engineering habits.
This focus is worth learning from.
Follow
If you're interested in AI coding, developer tools, and open-source projects, feel free to follow this public account.