Skip to content
TheChatArchiveThe Chat Archive
Step 3.5 Flash· unknownHugging Face Frontier Reasoning Traces

Design a Tailwind token governance model mapping design decisions, linting rules, and…

  1. User

    Design a Tailwind token governance model mapping design decisions, linting rules, and compiler tweaks.

  2. Assistant

    We are designing a governance model for Tailwind CSS tokens. The goal is to have a structured way to manage design decisions, linting rules, and compiler tweaks.

    This model should include:

    1. A way to propose changes (e.g., via GitHub issues or a dedicated governance platform).
    2. A process for discussing and refining proposals.
    3. A voting mechanism (if applicable) to decide on the acceptance of proposals.
    4. Implementation guidelines for accepted proposals.
    5. Versioning and release process.
    6. Linting rules: how to enforce consistency and best practices in the token definitions.
    7. Compiler tweaks: how to handle changes that affect the Tailwind compiler (like new functions, modifiers, etc.).

    We'll break it down:

    1. Proposal Process

    • Proposal Template: A standardized template for submitting proposals. It should include:

      • Title
      • Description (what and why)
      • Design decisions (how it fits into the existing system)
      • Linting rules impact (if any)
      • Compiler tweaks impact (if any)
      • Backward compatibility considerations
      • Migration guide (if breaking change)
      • Examples (if applicable)
    • Submission Channel: GitHub repository with a specific issue template for proposals.

    2. Discussion and Refinement

    • Open discussion on the issue. The community (including core team) can comment, suggest changes, etc.
    • The proposer may update the proposal based on feedback.
    • A core team member or a designated maintainer will facilitate the discussion and ensure that all concerns are addressed.

    3. Voting (if needed)

    • For non-trivial changes, a formal vote may be called.
    • Voting body: Core team and potentially community members (depending on the project's governance model). We can have a system where core team has more weight, or a simple majority of core team, or even a community vote.
    • The voting period: e.g., 7 days.
    • The outcome: majority wins, but core team may have veto power for strategic reasons.

    4. Implementation Guidelines

    • Accepted proposals are assigned to a milestone.
    • The implementation should follow the project's contribution guidelines.
    • The proposer or a volunteer (could be a core team member) implements the change.
    • Code reviews by core team.

    5. Versioning and Release

    • Use semantic versioning.
    • Group changes into releases (minor and major versions for breaking changes).
    • Release notes must include all accepted proposals and their impact.

    6. Linting Rules

    • Define a set of linting rules for the token system (e.g., naming conventions, structure, etc.).
    • These rules should be part of the project's tooling (e.g., a custom ESLint plugin or a stylelint config).
    • Proposals that affect linting rules must be approved via the governance process.
    • The linting rules are versioned with the rest of the project.

    7. Compiler Tweaks

    • Changes to the Tailwind compiler (like new functions, directives, etc.) are also proposed via the same process.
    • Compiler changes must be backward compatible when possible, and if breaking, must have a clear migration path.
    • The compiler code is part of the same repository and follows the same contribution guidelines.

    Additional Considerations

    • Transparency: All proposals and discussions are public.
    • Inclusivity: Encourage participation from the community.
    • Efficiency: Avoid unnecessary bureaucracy for small changes (e.g., typo fixes can be PRs without a proposal). Define what requires a proposal.

    We can also think about having different tracks for:

    • Design tokens (colors, spacing, etc.)
    • Linting rules
    • Compiler features

    But they are all part of the same system and might interact, so a unified governance model is better.

    Example Workflow

    1. User creates an issue with the proposal template.
    2. Community discusses for 7 days.
    3. If no major objections, a core team member approves and labels as accepted.
    4. If contentious, a vote is called (by core team or community as per rules).
    5. Once accepted, the proposal is moved to a milestone for an upcoming release.
    6. Implementation happens via PRs, which are reviewed and merged.
    7. The release is cut with the changes.

    Governance Model Summary

    • Core Team: Final decision makers for the project. They are responsible for the overall direction and quality.
    • Community: Can propose, discuss, and vote (if the model allows) on changes.
    • Voting: Optional, used for controversial changes. The weight of votes can be defined (e.g., core team members have 2 votes, community 1, or just one vote per person).
    • Consensus: Aim for consensus in discussions, but fallback to voting if needed.

    Documenting the Governance Model

    We should have a GOVERNANCE.md file in the repository that explains the process in detail.

    Tools

    • Use GitHub Issues for proposals.
    • Use GitHub Projects for tracking milestones.
    • Use a voting tool if needed (can be done via reactions or a bot, or just a comment with +1/-1).

    Given the above, we can now draft a detailed governance model document.

    Let me structure it:

    Tailwind Token Governance Model

    1. Purpose

    This document outlines the process for making changes to the Tailwind CSS token system, including design decisions, linting rules, and compiler tweaks.

    2. Scope

    This governance model applies to:

    • Changes to the design token definitions (e.g., adding new tokens, changing existing ones).
    • Changes to the linting rules that enforce token usage and structure.
    • Changes to the Tailwind compiler that affect how tokens are processed (e.g., new functions, modifiers).

    3. Proposal Process

    3.1. Template

    All proposals must use the provided template (in PROPOSAL_TEMPLATE.md). The template includes:

    • Title
    • Description
    • Design Decisions
    • Linting Rules Impact
    • Compiler Tweaks Impact
    • Backward Compatibility
    • Migration Guide (if breaking change)
    • Examples

    3.2. Submission

    Proposals are submitted as GitHub issues in the main repository, using the "Proposal" issue template.

    3.3. Discussion

    • The issue is open for discussion for at least 7 days.
    • The community is encouraged to provide feedback.
    • The proposer is responsible for updating the proposal based on feedback.

    3.4. Decision

    After the discussion period, a core team member will:

    • If there is a clear consensus (positive and no major objections), mark the proposal as accepted.
    • If there is significant disagreement, the proposal may be put to a vote (see Section 4).

    4. Voting

    4.1. When to Vote

    • When a core team member deems the proposal contentious.
    • At the request of the proposer (if they feel the discussion is stuck).

    4.2. Voting Body

    • Core team members: 1 vote each.
    • Community members: 1 vote each (must have contributed to the project in the past, e.g., via PRs or issues, to prevent spam).

    4.3. Voting Period

    7 days.

    4.4. Outcome

    • Simple majority (more than 50%) of the votes cast.
    • Core team has veto power (if they believe the proposal is against the project's best interest, they can reject even if majority approves). Veto must be justified.

    5. Implementation

    • Accepted proposals are added to the next appropriate milestone (minor or major version).
    • The implementation is done via pull requests.
    • The pull request must reference the proposal issue.
    • The PR must pass all CI checks and be approved by at least one core team member.

    6. Versioning and Release

    • Follow Semantic Versioning.
    • Breaking changes (including token removals or renames) must be accompanied by a migration guide and are released as major versions.
    • New features and non-breaking changes are released as minor versions.
    • Bug fixes are patch versions.
    • Release notes must list all the proposals that are included in the release.

    7. Linting Rules

    • The linting rules are defined in the project's configuration (e.g., tailwind.config.js or a separate linter config).
    • Any change to linting rules must go through the proposal process.
    • The linting rules are versioned with the project.

    8. Compiler Tweaks

    • Compiler changes are part of the same codebase and must follow the same proposal process.
    • Compiler changes must be backward compatible when possible. If a breaking change is necessary, it must be clearly documented and justified.
    • Compiler changes must include tests.

    9. Expedited Process

    For trivial changes (e.g., fixing a typo in a token name, adding a token that is a clear extension of existing pattern and does not require design decision), a core team member may approve a direct PR without a proposal. This is at the core team's discretion.

    10. Roles

    10.1. Core Team

    • Final decision makers.
    • Responsible for the project's direction and quality.
    • Review and merge PRs.
    • Facilitate discussions and voting.

    10.2. Community

    • Can propose, discuss, and vote.
    • Can implement accepted proposals (if they are willing and able).

    11. Transparency

    All proposals, discussions, and votes are public.

    12. Amendments

    This governance model itself can be changed by a proposal following the same process.


    This is a starting point. We might adjust based on the project's size and community.

    Note: The above model assumes a relatively small core team and an active community. If the project is small, we might skip voting and let core team decide after discussion. If the project is large, we might need more formal voting.

    Given that Tailwind is a popular project, we might want to have a more structured core team and community involvement.

    But note: the question is about "Tailwind token" governance. Tailwind CSS already exists, so we are talking about the token system within Tailwind (like the default theme tokens). We are not designing governance for the entire Tailwind project, but we can assume it's a subset.

    However, if we are designing a new token system for a project that uses Tailwind, then we can have a simpler model.

    Given the ambiguity, I'll assume we are designing for a project that uses Tailwind and has its own token system (like a design system). But the question says "Tailwind token", so it might be about the tokens that Tailwind uses (like in its default theme). However, Tailwind's core team already has a process. But if we are to design a governance model for a team that manages a set of tokens for their product using Tailwind, then we can adapt.

    But the question says "Design a Tailwind token governance model", so I think it's about the tokens that are used in a Tailwind-based design system.

    So, let's adjust:

    We are designing a governance model for a design system that uses Tailwind CSS. The tokens are the design tokens (colors, spacing, etc.) that are mapped to Tailwind classes.

    So, the same model applies, but we don't need to worry about the Tailwind compiler tweaks? Actually, if we are extending Tailwind with custom tokens, we might need to adjust the Tailwind config and possibly write plugins. So compiler tweaks might be relevant if we are changing how Tailwind processes tokens (like adding new functions). But typically, in a design system, we just define tokens in the theme section of tailwind.config.js. So maybe compiler tweaks are not needed.

    But the question says "compiler tweaks", so maybe we are talking about the Tailwind compiler itself? That would be for the Tailwind project, not for a design system using Tailwind.

    Given the context, I think we are designing a governance model for the Tailwind project's token system. But that is already maintained by the Tailwind core team.

    Alternatively, we are designing a governance model for a set of tokens that are used to generate Tailwind classes (like a token-to-Tailwind mapping). This could be a separate system.

    To be safe, I'll design a governance model that covers:

    • Design tokens (the raw values, e.g., colors, spacing, etc.)
    • The mapping of these tokens to Tailwind classes (which might involve linting rules and compiler-like tweaks if we have a custom build step).

    But if we are just using Tailwind's theme configuration, then the tokens are defined in a JavaScript object and Tailwind generates classes. Then we only need to govern the token definitions and maybe the naming conventions (linting rules). Compiler tweaks might not be relevant.

    However, the question says "compiler tweaks", so maybe we are talking about a custom compiler that takes tokens and generates Tailwind classes? That is common in design systems that want to have a single source of truth for tokens and generate multiple outputs (CSS, Tailwind config, etc.).

    So, let's assume we have a system that:

    • Defines design tokens in a JSON or JavaScript format.
    • Has a linter to enforce token structure and naming.
    • Has a compiler that generates the Tailwind config (and possibly other outputs).

    Then we need to govern:

    1. The token definitions (design decisions).
    2. The linter rules (what is allowed in the token files).
    3. The compiler (how the tokens are transformed into Tailwind classes).

    So the governance model above still applies, but we adjust the "compiler tweaks" to mean the token-to-Tailwind compiler.

    Given that, I think the model I drafted is appropriate.

    But to make it more concrete, let's define:

    • Design decisions: What tokens exist, their values, and how they are grouped. For example, decide to add a new color palette, or change the spacing scale.
    • Linting rules: Rules like "token names must be kebab-case", "all tokens must have a description", "no circular references", etc.
    • Compiler tweaks: How the compiler maps token structures to Tailwind classes. For example, if we change the way we handle responsive variants, or if we add support for a new type of token (like aspect ratios).

    So, the same governance process applies.

    Now, let's write the final answer in a structured way.

    Note: The user asked to "Design a Tailwind token governance model", so we are expected to produce a document or a description of the model.

    We'll produce a concise version of the above.

    Final answer:

    Tailwind Token Governance Model

    1. Overview

    This governance model outlines the process for proposing, discussing, and implementing changes to a Tailwind-based design token system. It covers design decisions (token definitions), linting rules, and compiler tweaks (token-to-Tailwind mapping).

    2. Proposal Process

    • Submission: Proposals must be submitted via GitHub issues using the provided template.
    • Template: Includes title, description, design decisions, linting impact, compiler impact, backward compatibility, migration guide, and examples.
    • Discussion: Minimum 7-day discussion period. Community feedback is encouraged. Proposer updates proposal based on feedback.

    3. Decision Making

    • Consensus: Aim for consensus during discussion.
    • Voting: If consensus is not reached, a formal vote is called.
      • Voting Body: Core team (1 vote each) and eligible community members (1 vote each, defined as those with past contributions).
      • Voting Period: 7 days.
      • Outcome: Simple majority. Core team has veto power with justification.

    4. Implementation

    • Accepted proposals are assigned to a milestone.
    • Implementation via pull requests, referencing the proposal issue.
    • PRs require approval from at least one core team member and must pass CI.

    5. Versioning and Release

    • Semantic versioning.
    • Breaking changes (including token removals/renames) require major version and migration guide.
    • Release notes list all included proposals.

    6. Linting Rules

    • Defined in the project's linting configuration.
    • Changes to linting rules must follow the proposal process.
    • Linting rules are versioned with the project.

    7. Compiler Tweaks

    • The compiler (token-to-Tailwind mapper) is part of the codebase.
    • Changes to compiler behavior must follow the proposal process.
    • Compiler changes must be backward compatible when possible, and include tests.
    • Breaking compiler changes require major version and migration guide.

    8. Expedited Process

    • Core team may approve trivial changes (e.g., typo fixes, straightforward token additions) without a proposal. This is at their discretion.

    9. Roles

    • Core Team: Final decision makers, facilitate process, review PRs.
    • Community: Propose, discuss, vote, implement.

    10. Transparency

    All proposals, discussions, and votes are public in the GitHub repository.

    11. Amendments

    This governance model can be changed via the same proposal process.


    This is a comprehensive model that can be adapted to the specific needs of the project.

    Tailwind Token Governance Model

    A comprehensive governance framework for managing design tokens, linting rules, and compiler optimizations in Tailwind CSS-based projects. This model balances structured decision-making with agile iteration.

    Core Principles

    • Transparency: All decisions and discussions are public
    • Inclusivity: Community participation encouraged
    • Bias for Action: Minimize bureaucracy for trivial changes
    • Backward Compatibility: Breaking changes require clear migration paths
    • Single Source of Truth: All tokens managed in one canonical location

    1. Proposal Lifecycle

    1.1 Proposal Types & thresholds

    Change TypeExamplesRequires ProposalVoting Required
    TrivialTypo fixes, documentation updates❌ NoNever
    MinorNew tokens following existing patterns, lint rule tweaks✅ Yes (light review)Only if contested
    MajorToken schema changes, breaking compiler changes, new token types✅ Yes (full process)Always
    EmergencyCritical security fixes, regressions✅ Yes (expedited)Core team only

    1.2 Proposal Template Structure

    ## Proposal: [Clear Title]
    **Related Issue/PR**: #XXX
    
    ### 1. Problem Statement
    - Current limitation or pain point
    - Impact on users/developers
    
    ### 2. Proposed Solution
    - Technical implementation details
    - Code examples where applicable
    
    ### 3. Impact Assessment
    #### Design Tokens
    - [ ] New tokens added
    - [ ] Existing tokens modified
    - [ ] Tokens deprecated
    
    #### Linting Rules
    - [ ] New rules added
    - [ ] Existing rules modified
    - [ ] Rules deprecated
    
    #### Compiler Tweaks
    - [ ] New functions/modifiers
    - [ ] Generation logic changes
    - [ ] Performance optimizations
    
    ### 4. Backward Compatibility
    - [ ] Fully backward compatible
    - [ ] Breaking change (attach migration guide)
    
    ### 5. Migration Path
    (For breaking changes only)
    Step-by-step migration instructions
    
    ### 6. Examples
    Before/after comparisons, visual examples
    
    ### 7. Alternatives Considered
    Why this approach was chosen over others
    

    2. Governance Tracks

    Track A: Design Tokens

    Scope: Color palettes, spacing scales, typography scales, shadows, breakpoints, etc.

    Decision Criteria:

    • Consistency with existing token architecture
    • Accessibility compliance (WCAG contrast ratios)
    • Internationalization considerations
    • Design system alignment

    Linting Rules:

    # .tokenlintrc.yml
    rules:
      naming:
        level: error
        pattern: '^{category}-{scale}-{token}$' # e.g., color-primary-500
      required-properties:
        - value
        - description
        - category
      forbidden-values:
        - '#000000' # Use semantic tokens instead
        - '0px'     # Use '0' without units
    

    Track B: Linting Rules

    Scope: Token structure, naming conventions, value constraints, cross-token references

    Rule Categories:

    1. Structural (required fields, type checking)
    2. Semantic (value ranges, contrast ratios)
    3. Relational (token dependencies, circular references)
    4. Architectural (layer separation, theme boundaries)

    Validation Pipeline:

    // token-validator.js
    module.exports = {
      validateTokens: async (tokens) => {
        // 1. Syntax validation (JSON/YAML/JS)
        // 2. Schema validation against token schema
        // 3. Business rule validation (custom logic)
        // 4. Cross-reference validation
        // 5. Design consistency checks
      }
    }
    

    Track C: Compiler Tweaks

    Scope: Tailwind config generation, JIT compiler extensions, custom functions, variant handling

    Compiler Extensions Pattern:

    // token-compiler.js
    module.exports = {
      extendCompiler: (compiler, tokens) => {
        // 1. Register new CSS functions
        compiler.registerFunction('min-contrast', (value) => {
          return `contrast-check(${value}, 4.5)` // Example
        })
        
        // 2. Add custom variants
        compiler.addVariant('high-contrast', (modifier) => {
          return `.hc\\:${modifier}`; // High contrast variant
        })
        
        // 3. Optimize output
        compiler.optimize = (css) => {
          return purgeUnusedTokens(css, tokens.used)
        }
      }
    }
    

    3. Decision Matrix

    3.1 Decision Authority by Change Type

    Change TypeCore Team ApprovalCommunity VoteImplementation Deadline
    Trivial✅ Single maintainer❌3 days
    Minor✅ 1 core member⚠️ If >3 community objections2 weeks
    Major✅ 2 core members✅ Simple majority1 release cycle
    Emergency✅ Any core member❌24 hours

    3.2 Vote Calculation

    Thresholds:
    - Quorum: 25% of active contributors (last 90 days)
    - Majority: >50% of votes cast
    - Core Team Veto: 3/5 core members can override (must provide rationale)
    
    Weighted Voting (optional for large orgs):
    - Core Team: 3 points each
    - Maintainers: 2 points each  
    - Contributors: 1 point each
    - Required: 66% of total points
    

    4. Workflow Integration

    4.1 GitHub Workflow

    # .github/workflows/token-governance.yml
    name: Token Governance
    on:
      issues:
        types: [opened, edited]
      pull_request:
        branches: [main]
    
    jobs:
      proposal-check:
        runs-on: ubuntu-latest
        steps:
          - run: |
              if "{{ github.event.issue.title }}" contains "[PROPOSAL]":
                add-label: governance/proposal
                assign-reviewers: core-team
    
      lint-validation:
        needs: proposal-check
        runs-on: ubuntu-latest
        if: contains(github.event.issue.labels, 'governance/proposal')
        steps:
          - uses: actions/checkout@v3
          - run: npm run lint:token
          - run: npm run validate:compiler
    
      voting:
        needs: [proposal-check, lint-validation]
        runs-on: ubuntu-latest
        if: |
          github.event.issue.state == 'open' &&
          contains(github.event.issue.labels, 'accepted/community-vote')
        steps:
          - name: Create Voting Thread
            run: |
              gh issue comment ${{ github.event.issue.number }} \
                --body "Voting period: $(date -d '+7 days')"
          
          - name: Calculate Results
            run: |
              # Count reactions, comments with +1/-1
              # Post results to issue
    

    4.2 CI/CD Integration

    // token-pipeline.js
    const pipeline = {
      precommit: {
        validate: ['lint:token', 'test:compiler'],
        check: ['dependencies:outdated']
      },
      pull_request: {
        validate: ['lint:token', 'test:compiler', 'build:preview'],
        check: ['breaking:changes']
      },
      release: {
        generate: ['changelog:generated', 'docs:update'],
        publish: ['npm:publish', 'docs:deploy']
      }
    }
    

    5. Token Schema Definition

    // token-schema.ts
    interface DesignToken {
      $schema: 'https://example.com/token-schema.json';
      $id: string; // Unique identifier
      category: 'color' | 'spacing' | 'typography' | 'shadow' | 'custom';
      type: 'color' | 'dimension' | 'font-weight' | string;
      value: string | number; // Raw value
      /**
       * Computed values for different outputs
       */
      outputs?: {
        tailwind?: string; // e.g., 'bg-primary-500'
        css?: string; // e.g., 'background-color: #...'
        ios?: string; // e.g., 'UIColor(named: "primary500")'
        android?: string;
      };
      description?: string;
      doc?: string; // Documentation URL
      designer?: string; // Designer who created
      status: 'approved' | 'deprecated' | 'experimental';
      deprecation?: {
        reason: string;
        replacement?: string; // Token ID
        removalVersion: string;
      };
    }
    
    // Linting Schema
    interface TokenLintRule {
      name: string;
      level: 'error' | 'warn' | 'off';
      message: string;
      validate: (token: DesignToken, allTokens: DesignToken[]) => boolean;
    }
    

    6. Compiler Configuration

    // tailwind-token.config.js
    module.exports = {
      // Input sources
      tokens: {
        colors: './tokens/colors.json',
        spacing: './tokens/spacing.js',
        typography: './tokens/typography.ts'
      },
      
      // Compiler behavior
      compiler: {
        generateUtilities: true,
        generateVariants: ['responsive', 'hover', 'focus', 'dark'],
        extractUsage: {
          sources: ['./src/**/*.{js,jsx,ts,tsx,vue}'],
          extensions: ['default']
        }
      },
      
      // Linting configuration
      lint: {
        rules: {
          'token/no-hardcoded-values': 'error',
          'token/required-properties': 'error',
          'token/color-contrast': 'warn'
        }
      },
      
      // Output
      output: {
        config: './tailwind.config.js',
        css: './src/tokens.css',
        docs: './docs/tokens.md',
        types: './src/types/tokens.d.ts'
      }
    }
    

    7. Emergency Override Protocol

    For critical issues (security, accessibility violations, major regressions):

    1. Any core member can trigger emergency override
    2. Immediate fix applied to hotfix/ branch
    3. 24-hour review by remaining core members
    4. Hotfix release published immediately
    5. Retrospective proposal required within 7 days to make change permanent

    8. Success Metrics

    8.1 Health Indicators

    • Token Bloat: ≤ 5% growth per quarter
    • Lint Rule Adoption: >90% of tokens comply
    • Breaking Changes: <1 per minor release
    • Community Participation: >30% proposals from non-core members

    8.2 Quality Gates

    • All tokens must have:
      • ✅ Descriptive names
      • ✅ Documentation
      • ✅ Designer attribution
      • ✅ Tested contrast ratios (for colors)
      • ✅ Mobile-first values

    9. Appeals Process

    1. Stage 1: Core team review (3 business days)
    2. Stage 2: Community ombudsman review (5 business days)
      • Elected rotating community member
    3. Stage 3: Full community vote (7 days)
      • Requires 66% majority to override core team

    10. Documentation Requirements

    Every accepted proposal must update:

    • TOKEN_REGISTRY.md (master token list)
    • GOVERNANCE.md (if rules change)
    • CHANGELOG.md (with user impact)
    • Migration guide (for breaking changes)
    • Example implementations

    11. Tooling Stack Recommendations

    {
      "devDependencies": {
        "@tokenlint/core": "^1.0.0",
        "@tokenlint/tailwind": "^1.0.0",
        "token-compiler": "^1.0.0",
        "design-token-validator": "^1.0.0"
      },
      "scripts": {
        "token:lint": "tokenlint './tokens/**'",
        "token:validate": "token-validator --strict",
        "token:compile": "token-compiler --output ./tailwind.config.js",
        "token:propose": "npm run token:lint && npm run token:validate && echo 'Ready for proposal'"
      }
    }
    

    12. Onboarding Checklist for New Contributors

    • Understand token hierarchy (global → component → variant)
    • Run npm run token:propose before submitting PR
    • Follow naming convention: {category}-{scale}-{token}
    • Add both raw and computed values
    • Include usage examples in documentation
    • Check contrast ratios for color tokens
    • Verify no circular references
    • Update type definitions when adding token types

    This governance model provides:

    • Structure for large teams
    • Flexibility for rapid iteration
    • Quality control through automated validation
    • Community ownership via transparent voting
    • Safety nets for emergency situations

    Key Innovation: The triple-track system (tokens, lint, compiler) with unified governance prevents fragmentation while allowing specialized expertise. The emergency override ensures critical issues never get bogged down in process.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.