Agent skill

Team Constitution

by tikalk in tikalk/adlc-team-skills

A skill your agent uses when bootstrapping a new team AI directives repo, establishing team-wide principles for the first time, or amending the constitution in team-ai-directives.

MITAuto-check passedDevelopment

Install Team Constitution

skills CLI
$ npx skills add tikalk/adlc-team-skills --skill team-constitution -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install tikalk/adlc-team-skills team-constitution --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/tikalk/adlc-team-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/team/team-constitution .claude/skills/team-constitution && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
team-constitution
GitHub stars
141
Token cost
~3.2k tokens
SKILL.md length
1,216 words
Files
3 (incl. scripts)
Skills in repo
44
Repo updated
First seen
Licence
MIT

At a glance

A skill your agent uses when bootstrapping a new team AI directives repo, establishing team-wide principles for the first time, or amending the constitution in team-ai-directives.

  • Works in 6 steps: Environment Setup → Load Team Context → Elicit Principles → …
  • Bootstrapping a new team AI directives repo
  • SKILL.md covers What this skill does, When to use, Process and Verification, plus 3 more sections
  • Runs Shell and PowerShell scripts from its folder; calls git

What it does

Team Constitution is an agent skill from tikalk/adlc-team-skills. Use when bootstrapping a new team AI directives repo, establishing team-wide principles for the first time, or amending the constitution in team-ai-directives.

Its SKILL.md is about 3.2k tokens, which your agent loads only when the skill is triggered. The skill folder holds 5 other files, including scripts (for example `scripts/bash/setup-team-constitution.sh`).

It sits in Development. The repository describes itself as: Agent skills for the Agentic SDLC: team lifecycle (team-boot, team-learn, team-init, team-repair), software factory, evals, CDR lifecycle with confidence scoring, and… The licence is MIT.

When your agent uses it

  • Bootstrapping a new team AI directives repo
  • Establishing team-wide principles for the first time
  • Amending the constitution in team-ai-directives

Example prompts

  • “/team-constitution”

Requirements

  • A Bash shell
  • PowerShell

Workflow steps

6 steps, taken from the step headings in SKILL.md.

  1. Environment Setup
  2. Load Team Context
  3. Elicit Principles
  4. Governance Section
  5. Write Constitution
  6. Commit & Summary

What it can do on your machine

Read from SKILL.md and the folder at commit 2dbed36. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 2 files in scripts/ (Shell and PowerShell), which the agent can run.

    Shell commands in SKILL.md call:

    • git

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use git, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Team Constitution loads about 3.2k tokens when it runs. Until then it costs about 44 tokens; SKILL.md has 1,216 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~44
When it runs · the whole SKILL.md, loaded when a task matches
~3.2k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from tikalk/adlc-team-skills at commit 2dbed36, republished under its MIT licence (© tikalk). 1,216 words, ~3,155 tokens.

Download SKILL.mdSave it as .claude/skills/team-constitution/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.
name
team-constitution
description
Use when bootstrapping a new team AI directives repo, establishing team-wide principles for the first time, or amending the constitution in team-ai-directives.
disable-model-invocation
true

team-constitution

What this skill does

Interactively create or amend the team constitution at {TEAM_AI_DIRECTIVES}/context_modules/constitution.md.

The scaffold written by team-setup (Mode 3) contains only a placeholder ("No team-wide principles defined yet"). This skill turns that placeholder into a real constitution through guided elicitation:

  • Propose principles informed by team context (existing rules, CDRs, AGENTS.md)
  • Review each principle interactively — confirm, edit, or reject
  • Write the constitution in the established team format (OKF v0.2 frontmatter + numbered principles + Governance section)

What this skill is NOT:

  • Not a port of spec-kit's spec.constitution template machinery — no placeholder tokens, no hooks, no extensions.yml, no template propagation, no Sync Impact Report
  • Not semantic versioning — the team constitution is versioned by git history in the team AI directives repo; freshness is tracked by OKF v0.2 frontmatter (generated, verified, stale_after) via /team-repair
  • Not for project-level constitutions (docs/adlc/memory/constitution.md, legacy .adlc/memory/constitution.md fallback) — those remain spec.constitution territory when spec-kit is in play

When to use

  • After team-setup Mode 3: the scaffold wrote a placeholder constitution — fill it with real principles
  • New team AI directives (cloned or existing): constitution is missing or still a placeholder
  • Amending principles: the team wants to add, reword, or remove principles
When NOT to use
  • Project-level constitution: use spec-kit's spec.constitution for docs/adlc/memory/constitution.md (legacy .adlc/memory/constitution.md fallback)
  • Constitution changes via CDR flow: if a constitution change was proposed as a CDR, let /team-levelup handle it
  • team AI directives not configured: run /team-setup first

Process

User Input
text
$ARGUMENTS

You MUST consider the user input before proceeding (if not empty).

Examples of User Input:

  • "Focus on testing and security principles" — steer proposals toward those domains
  • "Amend principle 3" — jump straight to amending a specific principle
  • "Add a principle about AI code review" — append a specific principle
  • Empty input: full elicitation flow (create or amend, auto-detected)
Role & Context

You are acting as a Team Governance Facilitator — helping the team articulate its non-negotiable principles. Your role involves:

  • Proposing principles grounded in the team's actual directives and practices (not generic boilerplate)
  • Ensuring every principle is declarative, testable, and has a clear rationale
  • Keeping the constitution concise — principles are rules, not essays
Outline
  1. Environment Setup (Phase 0): Resolve paths, detect constitution state
  2. Load Team Context (Phase 1): Read existing constitution + team directives to inform proposals
  3. Elicit Principles (Phase 2): Interactive create/amend loop
  4. Governance Section (Phase 3): Compose the lightweight governance paragraph
  5. Write Constitution (Phase 4): Write the file with OKF v0.2 frontmatter
  6. Commit & Summary (Phase 5): Offer commit, report results
Execution Steps
Phase 0: Environment Setup

Run the setup script from the skill's base directory:

bash
scripts/bash/setup-team-constitution.sh

Parse JSON for REPO_ROOT, TEAM_AI_DIRECTIVES, CONSTITUTION_FILE, CONSTITUTION_STATE, TD_IS_GIT, TD_CLEAN.

If the setup script is unavailable or fails, resolve manually:

  1. REPO_ROOT — walk up from cwd to find .adlc/, or git rev-parse --show-toplevel, or pwd.
  2. TEAM_AI_DIRECTIVES — TEAM_AI_DIRECTIVES env var, then .adlc/init-options.json → team_ai_directives, then REPO_ROOT/team-ai-directives.
  3. CONSTITUTION_FILE — {TEAM_AI_DIRECTIVES}/context_modules/constitution.md
  4. CONSTITUTION_STATE:
    • missing — file does not exist
    • placeholder — file exists and contains "No team-wide principles defined yet"
    • populated — file exists with real content
  5. TD_IS_GIT — git -C "$TEAM_AI_DIRECTIVES" rev-parse --is-inside-work-tree (exit 0 = true)
  6. TD_CLEAN — git -C "$TEAM_AI_DIRECTIVES" status --porcelain (empty = clean)

If TEAM_AI_DIRECTIVES is not configured:

text
Team AI directives repository not configured.
Run: team-setup
Or set: export TEAM_AI_DIRECTIVES=/path/to/team-ai-directives
Phase 1: Load Team Context

Read the following to inform principle proposals:

  1. Existing constitution at {CONSTITUTION_FILE} (if populated — you will amend; if placeholder/missing — you will create)
  2. Team rules index: {TEAM_AI_DIRECTIVES}/CDR.md — accepted rule/persona/example descriptors reveal what the team already cares about
  3. Existing rules: skim {TEAM_AI_DIRECTIVES}/context_modules/rules/ file names and headings
  4. AGENTS.md at {TEAM_AI_DIRECTIVES}/AGENTS.md — loading order and skill usage expectations

Principles must be grounded in what you find — e.g., if the rules directory is heavy on security modules, a "Security by Default" principle is evidence-based, not boilerplate. If the team AI directives is nearly empty, fall back to a small starter set and say so explicitly.

Phase 2: Elicit Principles
Create mode (missing or placeholder)
  1. Propose a starter set (3–7 principles) based on Phase 1 findings. For each principle, present:
markdown
### Proposed Principle N: {Name}

**Statement**: {Declarative, testable rule — one or two sentences}

**Rationale**: {Why this principle exists; what failure it prevents}

**Grounding**: {What team context motivated this — or "starter suggestion, no team AI directives evidence yet"}

Reply: [Y] accept / [e] edit / [n] reject
  1. For each response:

    • Y: add to the accepted list
    • e: apply the user's edits, present the revised principle for confirmation
    • n: drop it
  2. After the starter set, ask: "Any additional principles?" Loop until the user is done.

Show full SKILL.md (529 more words)Show less
Amend mode (populated)
  1. List the current principles (numbered, one-line each).
  2. Ask what to do: amend N / add new / remove N / full review.
  3. For amendments and additions, use the same propose → confirm/edit/reject loop as create mode.
  4. For removals, confirm explicitly — removals are the highest-impact change.

Principle quality bar (apply to every accepted principle):

  • Declarative and testable: an agent can check compliance ("Every X must Y"), not aspirational ("We value X")
  • Non-negotiable framing: principles are MUSTs; preferences and conventions belong in rules, not the constitution
  • Rationale included: one sentence on what failure the principle prevents
  • No vague language: replace "should" with MUST/NEVER, or move the item to rules
Phase 3: Governance Section

Compose a short Governance section. Keep it to these three points (do not expand):

markdown
## Governance

- **Amendments**: proposed as CDRs via `/team-init` or `/team-levelup`, reviewed and published via `/team-levelup`. Direct edits via `/team-constitution` are reserved for bootstrapping and explicit team decisions.
- **Compliance**: this constitution is loaded by `team-boot` at the start of every session. Agents and humans MUST follow it; on conflict, the constitution supersedes ad-hoc practices.
- **Alignment**: `/team-repair` (Check 6) verifies project constitutions inherit these principles. Project constitutions may extend, never contradict.
Phase 4: Write Constitution

Write {CONSTITUTION_FILE} with this exact structure:

markdown
---
type: Constitution
title: "{TEAM_NAME} Constitution"
description: "Team-wide principles and governance"
resource: ./context_modules/constitution.md
tags: [constitution]
generated: { by: agent:team-constitution, at: {TODAY}T00:00:00Z }
id: constitution
cdr_ref: null
created: {TODAY}
verified:
  - { by: agent:team-constitution, at: {TODAY}T00:00:00Z }
status: stable
stale_after: 180d
---

# {TEAM_NAME} Constitution

1. **{Principle Name}**
   {Statement. Rationale.}

2. **{Principle Name}**
   {Statement. Rationale.}

...

## Governance

{Governance section from Phase 3}

Rules for writing:

  • Preserve the existing OKF v0.2 frontmatter fields when amending; update generated.at to today and append to verified list. If the file carries custom fields (created, id, cdr_ref), preserve them. Remove any legacy v0.1 fields (timestamp, modified, age_days, evidence) if present — /team-repair handles this automatically.
  • title and H1: keep the existing team name if present; otherwise derive from the team AI directives directory name or ask.
  • Numbered flat list (1. **Name**) — no ### subsections per principle, no version/ratified date lines.
  • If CONSTITUTION_STATE was missing, create the parent directory first: mkdir -p "{TEAM_AI_DIRECTIVES}/context_modules".
Phase 5: Commit & Summary

If TD_IS_GIT is true and TD_CLEAN is true, offer a single commit on the current branch (no branch/PR flow — that remains the CDR lifecycle's job):

text
Commit the constitution update to team-ai-directives?
  git -C "{TEAM_AI_DIRECTIVES}" add context_modules/constitution.md
  git -C "{TEAM_AI_DIRECTIVES}" commit -m "docs: {create|amend} team constitution — {N} principles"
[Y/n]

If TD_CLEAN is false, skip the commit offer and note the team AI directives has uncommitted changes.

Report:

markdown
## Team Constitution Summary

**Mode**: {Create | Amend}
**File**: {CONSTITUTION_FILE}
**Principles**: N ({added} added, {amended} amended, {removed} removed)
**Committed**: {yes | no — reason}

### Principles

1. {Name} — {one-line statement}
2. ...

### Next Steps

1. Run `/team-repair` to validate the team AI directives and refresh verification timestamps
2. Review project constitutions for alignment (team-repair Check 6)
Key Rules
Grounded, Not Boilerplate
  • Proposals must cite team context when available (CDR descriptors, rule headings, AGENTS.md)
  • When the team AI directives is empty, say the starter set is generic and keep it small (3–5)
Team Format Only
  • OKF v0.2 frontmatter + numbered principles + Governance — no spec-kit template structure
  • No **Version** / **Ratified** lines — git history is the versioning
  • No ### subsections per principle — flat numbered list
Interactive, Not Automatic
  • Every principle is confirmed by the user before writing
  • Never silently rewrite an existing populated constitution — amend mode requires explicit per-principle decisions
Don't Cross the Streams
  • Project constitutions (docs/adlc/memory/constitution.md) are out of scope
  • CDR-driven constitution changes go through /team-levelup, not this skill
Workflow Guidance & Transitions
After /team-constitution
text
/team-setup (Mode 3 scaffold — placeholder constitution)
    ↓
/team-constitution (this skill — real principles)
    ↓
/team-repair (validate team AI directives, refresh freshness)

Ongoing amendments follow the CDR lifecycle (/team-init or /team-levelup → specify → clarify → publish), with /team-constitution available for explicit interactive edits.

Verification

  • {CONSTITUTION_FILE} exists with OKF v0.2 frontmatter (type: Constitution present, generated field present)
  • placeholder marker text is gone
  • Every principle has a bolded name, a declarative statement, and a rationale
  • Governance section present with the three points (amendments, compliance, alignment)
  • No placeholder tokens ([ALL_CAPS]), no version/ratified date lines
  • Amended files preserve pre-existing custom frontmatter fields with modified updated
  • Summary reported with mode, principle counts, and commit status

Configuration

  • TEAM_AI_DIRECTIVES — Path to the team AI directives (overrides .adlc/init-options.json).
  • .adlc/init-options.json — Project-level config file with team_ai_directives field.
  • Default fallback: team-ai-directives/ relative to project root.

12-Factor Alignment

Factor XI (Directives as Code) — the team's foundational governance document is created and maintained as a version-controlled artifact, never embedded ad-hoc in prompts.

Context

$ARGUMENTS

© tikalk, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 2 other files (scripts) in skills/team/team-constitution of tikalk/adlc-team-skills.

  • SKILL.md
  • scripts/bash/setup-team-constitution.sh
  • scripts/powershell/setup-team-constitution.ps1

Open the folder on GitHubat commit 2dbed36

Compare with similar skills

Team Constitution next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Team Constitution compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Team Constitution this skilltikalk/adlc-team-skills141—~3.2kAutomated safety check: PassMIT
Finishing a Development Branchobra/superpowers296k5 repos~1.9kAutomated safety check: PassMIT
Typescript Advanced Typesrolling-scopes/rsschool-app10k24 repos~4.2kAutomated safety check: PassMPL-2.0
PR Babysitteropeninterpreter/openinterpreter69k3 repos~4.2kAutomated safety check: PassApache-2.0
Code Review ChecklistshareAI-lab/learn-claude-code78k5 repos~1.1kAutomated safety check: PassMIT
Greplooponyx-dot-app/onyx32k4 repos~3.3kAutomated safety check: PassMIT

Similar skills

  • Walks the last step of a branch: confirm tests pass, detect the git environment, ask how to integrate, carry out your choice and clean up the worktree.

    296k GitHub starsUsed in 5 repos~1.9k tokens
    DevelopmentAuto-check passed
  • Typescript Advanced Types

    rolling-scopes/rsschool-app

    Master TypeScript's advanced type system including generics, conditional types, mapped types, template literals, and utility types for building type-safe applications.

    10k GitHub starsUsed in 24 repos~4.2k tokens
    DevelopmentAuto-check passed
  • PR Babysitter

    openinterpreter/openinterpreter

    Watches an open GitHub pull request until it merges, handling review comments, diagnosing CI failures and retrying flaky checks along the way.

    69k GitHub starsUsed in 3 repos~4.2k tokens
    DevelopmentAuto-check passed
  • Code Review Checklist

    shareAI-lab/learn-claude-code

    Reviews code against a five-part checklist covering security, correctness, performance, maintainability and testing, and reports findings in a fixed format.

    78k GitHub starsUsed in 5 repos~1.1k tokens
    DevelopmentAuto-check passed
  • Greploop

    onyx-dot-app/onyx

    Iteratively improves a PR (GitHub), MR (GitLab), or shelved changelist (Perforce) until Greptile gives it a 5/5 confidence score with zero unresolved comments.

    32k GitHub starsUsed in 4 repos~3.3k tokens
    DevelopmentAuto-check passed
  • Guidelines

    akash-network/node

    Behavioral guidelines to reduce common LLM coding mistakes. An agent skill from akash-network/node.

    1.1k GitHub starsUsed in 22 repos~577 tokens
    DevelopmentAuto-check passed

More from tikalk/adlc-team-skills

All 44 skills in this repo
  • Team Boot

    tikalk/adlc-team-skills

    A skill your agent uses when a session starts or resumes after compaction (auto via the sessionstart and sessioncompact event hooks) and the team AI directives context — constitution, CDR index…

    141 GitHub stars~2.2k tokensUpdated yesterday
    Auto-check passed
  • Architect Clarify

    tikalk/adlc-team-skills

    A skill your agent uses when ADRs need review, gaps need filling, or ADR status must be approved as Accepted before architecture generation.

    141 GitHub stars~4.7k tokensUpdated yesterday
    Auto-check passed
  • Change Clarify

    tikalk/adlc-team-skills

    A skill your agent uses when reviewing, accepting, rejecting, or deferring ChDRs mined by change-init, validating inferred decisions against their git and issue evidence before promotion to project…

    141 GitHub stars~2.9k tokensUpdated yesterday
    Auto-check passed
  • Change Init

    tikalk/adlc-team-skills

    A skill your agent uses when you want guided mining of git history, structured change-story clustering, or comprehensive rationale recovery before documenting.

    141 GitHub stars~3.5k tokensUpdated yesterday
    Auto-check passed
  • Change Publish

    tikalk/adlc-team-skills

    A skill your agent uses when accepted ChDRs are ready for promotion from drafts to project memory at docs/adlc/memory/chdr/ and the boot-facing chdr.md index needs regenerating.

    141 GitHub stars~2k tokensUpdated yesterday
    Auto-check passed
  • Evals Analyze

    tikalk/adlc-team-skills

    A skill your agent uses when evaluation results need triage and loop-closing — spec failures route to deterministic checks or context rules, generalization failures to the evaluator backlog.

    141 GitHub stars~1.2k tokensUpdated yesterday
    Auto-check passed

Categories

Questions about Team Constitution

What does Team Constitution do?

A skill your agent uses when bootstrapping a new team AI directives repo, establishing team-wide principles for the first time, or amending the constitution in team-ai-directives. Team Constitution is an agent skill from tikalk/adlc-team-skills. Use when bootstrapping a new team AI directives repo, establishing team-wide principles for the first time, or amending the constitution in team-ai-directives.

When should I use Team Constitution?

Team Constitution fits situations like: bootstrapping a new team AI directives repo; establishing team-wide principles for the first time; amending the constitution in team-ai-directives.

How do I install Team Constitution in Claude Code?

Run `npx skills add tikalk/adlc-team-skills --skill team-constitution -a claude-code`. Or copy the skill folder (skills/team/team-constitution in tikalk/adlc-team-skills) into .claude/skills/team-constitution in your project. Claude Code loads it when a task matches its description.

How do I install Team Constitution in Codex?

Run `npx skills add tikalk/adlc-team-skills --skill team-constitution -a codex`. Or copy the skill folder (skills/team/team-constitution in tikalk/adlc-team-skills) into .agents/skills/team-constitution in your project. Codex loads it when a task matches its description.

Can I use Team Constitution in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add tikalk/adlc-team-skills --skill team-constitution -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/team-constitution, .gemini/skills/team-constitution, .github/skills/team-constitution and .opencode/skills/team-constitution in your project.

What does Team Constitution need to run?

Going by SKILL.md and its folder, Team Constitution needs a shell and PowerShell for the scripts in its folder and the command-line tools its instructions call (git). Our summary lists: A Bash shell; PowerShell.

Does Team Constitution access the network?

SKILL.md contains no URLs. Its commands use git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Team Constitution safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Team Constitution use?

Team Constitution is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Team Constitution use?

About 3.2k tokens (SKILL.md is roughly 13k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Team Constitution?

Skills that share tags, products or a category with Team Constitution: Finishing a Development Branch (obra/superpowers, 296k stars), Typescript Advanced Types (rolling-scopes/rsschool-app, 10k stars), PR Babysitter (openinterpreter/openinterpreter, 69k stars) and Code Review Checklist (shareAI-lab/learn-claude-code, 78k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Team Constitution?

tikalk (a GitHub organization) maintains it in tikalk/adlc-team-skills, which has 141 GitHub stars. The repository holds 44 skills in this directory. The repository was last updated on October 6, 2026.

Source: tikalk/adlc-team-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.