describe-laws-and-style

Documents invariants and conventions for Ushabti-based projects across Phases and refactors.

7|1|Updated Jan 27, 2026
One-click install
npx skills add https://github.com/adamrdrew/ushabti --skill describe-laws-and-style
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: describe-laws-and-style
Source: https://github.com/adamrdrew/ushabti/tree/main/skills/describe-laws-and-style
Command: npx skills add https://github.com/adamrdrew/ushabti --skill describe-laws-and-style

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Distinguishing invariants (laws) from conventions (style) to create a clear governance framework for Ushabti-based projects and prevent drift across Phases and implementations.

Core Features & Use Cases

  • Distinguishes laws and style and explains their distinct roles and responsibilities in governance
  • Provides guidance on how to modify laws (Lawgiver) vs modify style (Artisan) without conflict
  • Supports auditing and alignment of project practices across Phases, implementations, and refactors

Quick Start

Review and codify your project's invariant laws and architectural style by updating .ushabti/laws.md and .ushabti/style.md.

Frequently Asked Questions about describe-laws-and-style

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I separate project invariants from conventions in AI-assisted development?

To separate project invariants from conventions, distinguish non-negotiable laws from evolvable style. This establishes a clear governance framework that prevents architectural drift across Phases, implementations, and refactors by enforcing laws while preserving conventions.

What is the difference between laws and style in project governance?

In project governance, laws represent non-negotiable invariants that must be strictly enforced, while style represents evolvable conventions that can be modified. Documenting these distinct roles prevents conflicts and clarifies responsibilities for maintaining architectural standards.

How do I codify laws and style for Ushabti-based projects?

To codify laws and style for Ushabti-based projects, review and update the .ushabti/laws.md file for invariants and the .ushabti/style.md file for conventions. This documents governance rules to align project practices across implementations and refactors.

Who is responsible for modifying laws versus style in a governed project?

The Lawgiver is responsible for modifying laws (invariants), while the Artisan is responsible for modifying style (conventions). This role separation ensures non-negotiable invariants are enforced while allowing conventions to evolve without conflict.

Can I audit project alignment across Phases using laws and style governance?

Yes, you can audit project alignment by applying laws and style governance across Phases, implementations, and refactors. This ensures project practices adhere to codified invariants and conventions, preventing architectural drift in AI-assisted software development.

When should I enforce invariants instead of updating conventions during a refactor?

Enforce invariants during a refactor when non-negotiable laws are at risk of being violated, but update conventions when only evolvable style needs adjustment. This distinction preserves architectural integrity while allowing style to adapt without breaking governance rules.