writing-laws

Formalize codebase governance documents with structured laws and compliance checklists.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/front-depiction/claude-setup --skill writing-laws
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-laws
Source: https://github.com/front-depiction/claude-setup/tree/main/skills/writing-laws
Command: npx skills add https://github.com/front-depiction/claude-setup --skill writing-laws

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill helps teams formalize laws and covenants for codebases, turning informal standards into enforceable, auditable requirements that govern behavior.

Core Features & Use Cases

  • Hierarchical law structure: §-numbered sections and bracketed names for precise organization.
  • Self-contained covenants: preambles, definitions, laws, severity classifications, and compliance checklists to ensure clarity and verifiability.
  • Governance and compliance: converts ad-hoc rules into codified policies that can be reviewed, versioned, and audited across projects.

Quick Start

Draft a minimal covenant document that defines a single law using the sectioning format and the statement “IT IS HEREBY DECREED that [subject] SHALL [action].” Then include a short plain-text example that demonstrates a namespace import rule or similar constraint.

Frequently Asked Questions about writing-laws

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

FAQPage Schema
How do I formalize architectural constraints and codebase governance policies into enforceable rules?

You formalize architectural constraints by drafting codified laws with hierarchical §-numbered sections, preambles, severity classifications, and compliance checklists. This converts informal standards into auditable, self-contained covenants that govern behavior across projects.

What is the best way to document domain-specific rules and code governance standards for a development team?

Documenting domain-specific rules is best done by creating self-contained covenant documents using precise formal language. Each document includes a preamble, definitions, laws, and severity classifications to ensure the code governance standards are clear, verifiable, and reviewable.

Can I use this approach to version and audit compliance policies across multiple projects?

Yes, you can use this approach to audit compliance policies. By writing codified laws with clear structures and compliance checklists, ad-hoc rules become versioned, auditable governance documents that can be consistently reviewed across multiple projects.

How do I structure a covenant document for codebase architectural constraints?

Structure a covenant document using hierarchical §-numbered sections and bracketed names for organization. Include a preamble, definitions, the formal laws using decreed statements, severity classifications, and a compliance checklist to ensure the architectural constraints are self-contained.

When do I need to codify inviolable covenants for my codebase?

You need to codify inviolable covenants when architectural constraints and domain-specific rules must be strictly followed across projects. This process transforms informal standards into formal, enforceable policies with severity classifications and compliance checklists for auditing.

Does writing formal laws for code governance require any specific frameworks or dependencies?

Writing formal laws for code governance requires no specific frameworks or dependencies. It relies on precise, self-contained law documents structured with preambles, §-numbered sections, severity classifications, and compliance checklists to define architectural constraints.