The engineering counterpart of impeccable.
One skill, 13 commands, 3 standards files.
Disciplined code, low-ceremony, opinionated. Setup writes your team's standards once. Every sub-command after that follows them. Push back against AI cargo, premature abstraction, and defensive ceremony.
npx skills add CoRLab-Tech/skills@rigorous/rigorous teachFive categories. One coherent toolkit.
Setup once, then run any command from any project. Each follows your team's posture in PRINCIPLES.md, STACK.md, and TESTING.md.
teachInteractive walkthrough. Writes PRINCIPLES.md, STACK.md, TESTING.md once per project.
documentReverse-engineer the three standards files from existing code.
shapePlan a feature before you write any code. Returns a one-page brief.
craftImplement the approved shape end-to-end. Typecheck and verify each layer.
tddStrict red, green, refactor cycle. One failing test at a time.
critiqueAcid review. What's complicated, what can be cut, what doesn't earn its place.
auditTechnical audit. Performance, security, dependency health, races, observability.
architectSystem design review. Modules, coupling, abstraction lines, failure model.
simplifyStrip ceremony. Dead code, premature abstractions, unnecessary indirection.
hardenBoundary validation, edge cases, idempotency. Only where they earn their place.
refactorRestructure without changing behavior. Small steps, tests after each.
debugSystematic root cause investigation. Reproduce, hypothesize, trace upstream.
optimizeProfile-driven performance work. Measure, target, fix, re-measure.
Set up once. Every command follows them.
`teach` writes these files at the root of your repo through 15 questions. After that, every command reads them before doing work, so the output never drifts from your team's posture.
PRINCIPLES.mdmdSTACK.mdmdTESTING.mdmdThe files are markdown, version-controlled, edited by you whenever the rules drift. They're the durable engineering policy of the project.
From idea to shipped.
One representative path through the toolkit. The five categories cover everything else, but most features go through these in order.
- 01
/teachSetupAnswer 15 questions about how your team writes code. Get three standards files at the repo root.
- 02
/shapePlanDescribe the feature. Get a one-page brief: goal, files, schema, test plan, tradeoffs. Confirm before any code.
- 03
/craftBuildImplement after the plan is approved. Each layer typechecks and verifies before the next starts.
- 04
/critiqueReviewAcid review of the diff. What's complicated, what can be cut, what abstractions don't earn their place.
- 05
/hardenShipAdd boundary validation, idempotency, observability. Only where they earn their place. Then it's ready.
Always apply. Override taste and inertia.
Six rules every command honors, regardless of what's in your standards files. The product of years of code review distilled to what survives when defaults fail.
Match the change to the task.
A bug fix changes the buggy line and nothing else. No surrounding cleanup. Three similar lines beat a premature abstraction.
Trust internal code, validate boundaries.
No defensive null checks for arguments the type system already validated. Validate at HTTP request bodies, env vars, third-party API responses, user uploads.
Default to zero comments.
The code is the documentation. Write a comment only when the WHY is non-obvious: a hidden constraint, a workaround, a subtle invariant. Never WHAT-comments.
No half-finished work.
No feature flags or backwards-compat shims if the change can be made directly. No TODO without an issue link. No function with one branch returning null.
The slop test.
If a senior engineer reading this PR could say "AI wrote that" without doubt, it has failed. Over-commented code, defensive cargo, suffix-disease class names — rework until it reads like a deliberate human authored it.
Reversibility before risk.
Editing files is free. Deleting files, dropping tables, force-pushing, modifying CI — confirm with the user first.
What's different from the alternatives.
The skill ecosystem already has good code-quality tools. rigorous picks a specific bet: one cohesive skill, durable standards, gates instead of suggestions.
| Feature | rigorous | Other code skills |
|---|---|---|
| Single skill, multiple commands | 13 commands, one install | fragmented across N packages |
| Setup that asks the right questions | teach writes 3 durable files | global system prompts only |
| Standards drive every command | PRINCIPLES.md is loaded on every run | agent re-asks each time |
| Plan-before-code as a hard gate | shape required for craft / tdd | optional or absent |
| Engineering laws baked in | six rules apply to every output | depends on which skill you invoke |
Honest take: obra/superpowers and mattpocock/skills have brilliant individual skills. Use them too. rigorous is for teams that want one cohesive frame instead of 14 separate packages.