Team Rituals

Team Rituals

Scope

Covers

• Designing a small set of high-leverage team rituals that drive alignment, execution, learning, and belonging
• Turning rituals into an operating system (not “more meetings”): named rituals, clear owners, repeatable templates, and explicit outputs
• Creating “Golden Rituals” that are Named, Templated, and Known by every new hire by their first Friday

When to use

• “Our meetings are chaotic; design a better team cadence.”
• “Define our team operating system / rituals / ceremonies.”
• “Create named, templated Golden Rituals and a one-pager for onboarding.”
• “We need better alignment and decision velocity without adding meeting load.”

When NOT to use

• You need to define team culture code, values, or norms first (use building-team-culture — rituals should express decisions you’ve already made about culture)
• You need to facilitate or improve a single meeting or workshop (use running-effective-meetings — this skill designs an end-to-end ritual system, not one meeting)
• You need to set up product operations cadence or cross-team coordination (use product-operations)
• You need engineering-specific ceremonies like sprint retros, incident reviews, or deploy cadences (use engineering-culture)
• You need to define company values, org design, or strategy from scratch (do that first; rituals should express decisions you’ve made)
• You need HR/legal policy guidance (this is not compliance or legal advice)
• You’re trying to use rituals for surveillance or performance policing (this will backfire; redesign for trust and psychological safety)

Inputs

Minimum required

• Team type + size + composition (functions; cross-functional vs single function)
• Work mode: remote/hybrid/in-office + time zones
• What’s currently broken (symptoms) + what you want to improve (outcomes)
• Existing cadence/rituals (or “none”) and what people hate about them
• Constraints: meeting time budget, decision-making model, tooling (calendar/docs/chat)

Missing-info strategy

• Ask up to 5 questions from references/INTAKE.md (3–5 at a time).
• If inputs are still missing, proceed with clearly labeled assumptions and provide 2–3 options.
• Do not request secrets. If context is sensitive, ask for redacted/high-level descriptions.

Outputs (deliverables)

Produce a Team Rituals Pack in Markdown (in-chat; or as files if the user requests):

1. Context snapshot (team, work mode, constraints, goals)
2. Ritual inventory audit (current rituals + what to keep/change/kill)
3. Golden Rituals shortlist (3–7 named rituals mapped to outcomes)
4. Ritual specs + templates (one spec per Golden Ritual: purpose, cadence, owner, agenda, outputs, anti-patterns)
5. Onboarding primer (“Known by first Friday”: 1-page cheatsheet + where templates live)
6. Rollout plan (pilot, comms, calendar/docs setup, training)
7. Governance plan (review cadence, feedback loop, metrics, retirement/iteration rules)
8. Risks / Open questions / Next steps (always included)

Templates: references/TEMPLATES.md
Expanded guidance: references/WORKFLOW.md

Workflow (7 steps)

1) Intake + outcome definition (what the rituals are for)

• Inputs: user context; references/INTAKE.md.
• Actions: Clarify the top 2–3 outcomes (e.g., alignment, decision speed, execution reliability, learning). Set constraints (time budget, remote/async needs). Define what “good” feels like in 4–6 bullets.
• Outputs: Context snapshot + outcome list + constraints.
• Checks: You can explain the “why” in one sentence (“We’re doing this to ____ without ____.”).

2) Audit what exists (keep / change / kill)

• Inputs: current meeting list/cadence; pain points.
• Actions: Build a ritual inventory table. For each ritual: purpose, participants, cadence, outputs, and whether it’s working. Identify duplicates and “status-only” meetings.
• Outputs: Ritual inventory audit with a keep/change/kill recommendation.
• Checks: Every existing ritual has an explicit purpose and output; “kill” items have a replacement or rationale.

3) Design rules + time budget (make it a system, not meetings)

• Inputs: outcomes + audit.
• Actions: Define a small set of design rules (named, templated, artifact-first, owner-driven, async-by-default). Establish a weekly meeting time budget and decide what must be synchronous vs async.
• Outputs: Ritual design principles + time budget + naming scheme.
• Checks: Total sync time stays within budget; each ritual has an owner and an artifact output.

4) Select 3–7 “Golden Rituals” (the minimal set)

• Inputs: outcomes + principles + constraints.
• Actions: Propose 3–7 Golden Rituals that cover: alignment, decisions, execution, learning, and belonging (as needed). Name them with memorable, team-relevant names.
• Outputs: Golden Rituals shortlist + mapping table (ritual → outcome).
• Checks: Each Golden Ritual earns its slot; no “nice-to-have” meetings.

5) Write ritual specs + templates (make them repeatable)

• Inputs: Golden Rituals shortlist; references/TEMPLATES.md.
• Actions: For each Golden Ritual, produce a spec: purpose, cadence, roles, agenda/format, prep, outputs, follow-ups, and anti-patterns. Create the corresponding agenda/notes template.
• Outputs: One “Ritual Spec” per Golden Ritual + copy/paste templates.
• Checks: Rituals are Named and Templated; outputs are explicit (decisions, priorities, action list, learnings).

6) Make them “Known by first Friday” (onboarding + rollout)

• Inputs: Ritual specs; onboarding constraints.
• Actions: Create a 1-page onboarding primer and a rollout plan: pilot order, comms, calendar creation, where templates live, and how new hires learn the rituals in week 1.
• Outputs: Onboarding primer + rollout plan.
• Checks: A new hire can find the rituals, understand purpose, and run one using templates by their first Friday.

7) Governance + quality gate (iterate, don’t accumulate)

• Inputs: full draft pack.
• Actions: Define governance: ritual owners, quarterly review, feedback loop, and retirement rules. Run references/CHECKLISTS.md and score with references/RUBRIC.md. Add Risks / Open questions / Next steps.
• Outputs: Final Team Rituals Pack.
• Checks: The pack is minimal, adoptable, and has a way to evolve without ritual sprawl.

Quality gate (required)

• Use references/CHECKLISTS.md and references/RUBRIC.md.
• Always include: Risks, Open questions, Next steps.

Examples

Example 1 (fix chaotic cadence): “We’re a 12-person product+engineering team (remote across PST/EST). Meetings feel random and we keep missing decisions. Design Golden Rituals, write templates, and create a first-Friday onboarding primer.”
Expected: a small set of named rituals with templates, mapped to outcomes, plus rollout + governance.

Example 2 (new manager operating system): “I’m inheriting a team of 7 ICs with low accountability and unclear priorities. Create a weekly operating cadence with minimal meetings and clear artifact outputs.”
Expected: ritual inventory audit + a minimal Golden Rituals set + artifact-first templates.

Boundary example (scope too broad): “Fix our company culture.” Response: ask what specifically is broken and at what scope; propose a small team-level ritual system only, or redirect to building-team-culture for culture code and norms work first.

Boundary example (single meeting): “Help me run a better weekly standup — just give me an agenda template.” Response: redirect to running-effective-meetings for a single meeting redesign. Use this skill if you want to design the full team operating cadence (standup is one ritual among several).

Boundary example (engineering ceremonies): “Set up our sprint retro, incident review, and deploy cadence for the engineering team.” Response: redirect to engineering-culture for engineering-specific ceremonies. This skill designs cross-functional team operating cadence, not engineering-specific process.

Anti-patterns (common failure modes)

1. Ritual sprawl — Adding new meetings without killing old ones. Every new ritual must justify its slot against the time budget. If you cannot retire something, you are adding load, not a system.
2. Status-only meetings — Rituals that exist solely for one-directional status reporting. These should be replaced with async updates (written status docs, dashboards) and sync time reserved for decisions, alignment, or learning.
3. No artifact output — Running a ritual that produces no durable artifact (decision log, commitment list, learning summary). If nothing is written down, the ritual did not happen. Every Golden Ritual must produce an output.
4. Cargo-cult adoption — Copying another company's rituals without adapting to your team's context, size, or work mode. “Google does weekly business reviews” does not mean your 6-person startup needs one.
5. Rituals without governance — Never reviewing whether rituals are still working. Institute a quarterly ritual audit with explicit keep/change/kill decisions and retirement rules.