Skip to main content
ClaudeWave
Skill292 repo starsupdated 1mo ago

constitution

The constitution skill creates or updates project governance documents by discovering actual codebase patterns through parallel specialist agents, then presenting evidence-backed rules at three enforcement levels (must, should, may) for user approval before writing. Use it to establish project-specific governance rules grounded in real code analysis rather than generic templates.

Install in Claude Code
Copy
git clone --depth 1 https://github.com/rsmdt/the-startup /tmp/constitution && cp -r /tmp/constitution/plugins/start/skills/constitution ~/.claude/skills/constitution
Then start a new Claude Code session; the skill loads automatically.

SKILL.md

## Persona

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.
- 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:
1. Deduplicate overlapping patterns.
2. Classify each rule with level (L1/L2/L3) per reference/rule-patterns.md.
3. 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
}
analyzeSkill

Deep-dive codebase analysis that explains how things actually work — business rules, architecture patterns, auth flows, data models, integrations, and performance hotspots. Use whenever the user asks "how does X work", "map the Y flow", "what are the business rules for Z", "trace the auth path", "explore the codebase for patterns", "find all [domain concept]", or needs mechanism-level understanding before making a change. Produces What/How/Why findings with file:line evidence, cross-cutting connections, and clean-solution recommendations first.

brainstormSkill

You MUST use this before any creative work — creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements, and design before implementation.

debugSkill

Systematically diagnose and resolve bugs through conversational investigation and root cause analysis

documentSkill

Generate and maintain documentation for code, APIs, and project components

implement-directSkill

Lightweight implementation orchestrator for low-complexity work — fixes, refactors, doc changes, or single-AC features that do not warrant a phase plan or factory decomposition.

implement-factorySkill

Factory loop orchestrator for multi-feature or multi-component implementation manifests. Use for high-complexity work with parallel-eligible workstreams and holdout-scenario evaluation.

implement-incrementalSkill

Linear phase-loop orchestrator for single-feature implementation plans. Use for medium-complexity work where transparent human-in-the-loop phase review is preferred over factory automation.

implementSkill

Implementation entry point. Use to execute a completed specification. Auto-detects the decomposition tier (Direct, Incremental, or Factory) from spec artifacts and dispatches to the matching execution sub-skill.