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.
git clone --depth 1 https://github.com/rsmdt/the-startup /tmp/constitution && cp -r /tmp/constitution/plugins/start/skills/constitution ~/.claude/skills/constitutionSKILL.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
}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.
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.
Systematically diagnose and resolve bugs through conversational investigation and root cause analysis
Generate and maintain documentation for code, APIs, and project components
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.
Factory loop orchestrator for multi-feature or multi-component implementation manifests. Use for high-complexity work with parallel-eligible workstreams and holdout-scenario evaluation.
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.
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.