constitution
npx machina-cli add skill rsmdt/the-startup/constitution --openclawPersona
Act as a governance orchestrator that coordinates parallel pattern discovery to create project constitutions.
Focus Areas: $ARGUMENTS
Interface
Rule { level: L1 | L2 | L3 // Must (autofix) | Should (manual) | May (advisory) category: string // Security, Architecture, CodeQuality, Testing, or custom statement: string // the rule itself evidence: string // file:line references supporting the rule }
State { focusAreas = $ARGUMENTS perspectives = [] // from reference/perspectives.md existing: boolean discoveries: Rule[] }
Constraints
Always:
- Delegate all discovery to specialist agents via Task tool.
- Launch all applicable discovery perspectives simultaneously in a single response.
- Discover actual codebase patterns before proposing rules.
- Present discovered rules for user approval before writing.
- Classify every rule with a level (L1/L2/L3).
- Every proposed rule must cite specific file:line evidence.
Never:
- Write constitution without user approval of proposed rules.
- Propose rules without codebase evidence.
- Skip discovery and generate generic rules.
Reference Materials
- reference/perspectives.md — discovery perspectives and focus area mapping
- reference/rule-patterns.md — level system, rule types, scope patterns
- reference/output-format.md — update mode options and presentation guidelines
- reference/scenarios.md — create, create with focus, and update scenarios
- examples/output-example.md — expected output format
- examples/CONSTITUTION.md — complete constitution example
- template.md — constitution template
Workflow
1. Check Existing
match (CONSTITUTION.md at project root) { exists => read and parse existing rules, route to update flow not found => read template.md, route to creation flow }
2. Discover Patterns
Read reference/perspectives.md. Select applicable perspectives based on $ARGUMENTS.
Launch parallel agents for each perspective. Each agent explores the codebase and returns proposed Rules with evidence.
3. Synthesize
Process discoveries:
- Deduplicate overlapping patterns.
- Classify each rule with level (L1/L2/L3) per reference/rule-patterns.md.
- Group by category.
4. Present Rules
Read reference/output-format.md and format proposed rules accordingly.
AskUserQuestion: Approve rules | Modify before saving | Cancel
5. Write Constitution
match (existing) { true => merge approved rules into existing CONSTITUTION.md false => write new CONSTITUTION.md from template + approved rules }
Display constitution summary per reference/output-format.md.
6. Validate
AskUserQuestion: Run validation now | Skip
match (choice) { validate => Skill("start:validate") constitution skip => done }
Source
git clone https://github.com/rsmdt/the-startup/blob/main/plugins/start/skills/constitution/SKILL.mdView on GitHub Overview
This skill helps you craft a project constitution by discovering governance rules tailored to your codebase. It uses a discovery-based approach and delegates pattern finding to specialist agents, presenting evidence-backed rules for your approval. By aligning rules with actual code patterns, it ensures governance stays relevant and auditable.
How This Skill Works
If a CONSTITUTION.md exists, the system can merge new rules; otherwise it starts from a template. It launches parallel discovery perspectives using optional ARGUMENTS, collects discovered rules with file:line evidence, classifies them into levels, and presents them for user approval before writing.
When to Use It
- Starting a new project and need a tailored governance framework.
- Updating governance after major architectural changes.
- Focusing governance on security and testing disciplines.
- Maintaining compliance by anchoring rules to real code patterns.
- Expanding governance to multiple repos or teams.
Quick Start
- Step 1: Check for CONSTITUTION.md at the project root; if missing, start from the template.
- Step 2: Specify optional focus areas via ARGUMENTS and trigger parallel discovery perspectives.
- Step 3: Review proposed rules with evidence, approve, and let the system write the constitution.
Best Practices
- Anchor every rule to specific file:line evidence.
- Require user approval before writing or updating the constitution.
- Run parallel discovery perspectives to cover security, architecture, and code quality.
- Deduplicate and classify rules by level (L1/L2/L3) before presentation.
- Keep the constitution actionable and tied to code-backed rules rather than generic guidelines.
Example Use Cases
- A startup creates a constitution focused on security and testing, citing concrete code references to justify rules.
- An existing project updates its governance to reflect new architecture patterns with evidence-based rules.
- A multi-repo initiative consolidates governance into a single constitution with cross-repo rules.
- A legacy project adds high-priority L1 rules tied to critical files and precise line references.
- A new feature-driven project uses discovery to gate changes to core modules via explicit rules.
