Skip to main content
skill CX Codex

symmetric-dogfooding — Claude Code skill: what it does, how to install

symmetric-dogfooding sets up bidirectional integration testing between two interdependent repositories before release without mocks.

MIT 112 installs ★ 3 updated 2026-10-25

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add terrylica/cc-skills --skill symmetric-dogfooding -a claude-code
Open on GitHub

What symmetric-dogfooding does

This skill guides the agent through establishing mutual test coverage across paired codebases. When two active projects produce and consume each other's data formats or libraries, changes on one side frequently break the other. The workflow replaces mocks with integration tests using genuine outputs generated by the partner project.

Inside are templates for dependency setup across Python using uv, Rust via Cargo, and Node.js. It details task automation for moon.yml via the validate-symmetric target, creates dedicated tests/integration/ suites in both locations, and establishes release protocols for CLAUDE.md.

Cross-repository dependencies must pin explicit git tags or commit SHAs. Pointing to main or master branches breaks test reproducibility and is blocked by the protocol.

What it helps with

  • set up reciprocal integration tests across two repositories
  • validate cross-repo compatibility before publishing releases
  • test interface boundaries using production-like outputs instead of mocks
  • coordinate breaking API changes between interdependent services

Example prompts for the agent

  • Set up symmetric dogfooding between this repo and the backend client
  • Run the pre-release validation checklist against the partner repo branch
  • Add a new cross-repo integration point following the symmetric-dogfooding template

How to install symmetric-dogfooding

1Skills CLI (Vercel)

npx skills add terrylica/cc-skills --skill symmetric-dogfooding -a claude-code

2Manually: put the files in place

~/.claude/skills/symmetric-dogfooding/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/symmetric-dogfooding/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about symmetric-dogfooding

How to install symmetric-dogfooding in Claude Code?

Run npx skills add terrylica/cc-skills --skill symmetric-dogfooding -a claude-code in your terminal.

What does symmetric-dogfooding do?

It gives the AI assistant step-by-step procedures to link two repositories so each validates the other before shipping changes.

Why does the workflow forbid branch-based dependencies?

Floating branches introduce unpinned code changes. The skill requires pinning dependencies to explicit git tags or commit SHAs for deterministic test results.

Source text

SKILL.md · MIT
---
name: symmetric-dogfooding
description: Bidirectional integration validation where two repositories validate each other before release.
allowed-tools: Read, Bash, Write, Edit, Grep, Glob
---

# Symmetric Dogfooding

Bidirectional integration validation pattern where two repositories each consume the other for testing, ensuring both sides work correctly together before downstream adoption.

> **Self-Evolving Skill**: This skill improves through use. If instructions are wrong, parameters drifted, or a workaround was needed — fix this file immediately, don't defer. Only update for real, reproducible issues.

## Pattern Overview

```
┌─────────────────────────────────────────────────────────────────┐
│                    SYMMETRIC DOGFOODING                         │
│                                                                 │
│        Repo A ◄─────── mutual validation ───────► Repo B        │
│                                                                 │
│   EXPORTS:                              EXPORTS:                │
│   - Library/API                         - Library/API           │
│   - Data structures                     - Data structures       │
│                                                                 │
│   VALIDATES WITH:                       VALIDATES WITH:         │
│   - Repo B real outputs                 - Repo A real outputs   │
│   - Production-like data                - Production-like data  │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘
```

## When to Use This Skill

Use this skill when:

- Two repos have a producer/consumer relationship
- APIs evolve independently and need integration testing
- Data formats may drift between repos
- Both repos are actively developed

---

## TodoWrite Task Templates

### Template A: Setup Symmetric Dogfooding Between Two Repos

```
1. Identify integration surface (exports from A consumed by B and vice versa)
2. Document data formats, schemas, API signatures at boundary
3. Configure cross-repo dev dependencies in both repos
4. Pin versions explicitly (tags or SHAs, never main)
5. Create integration/ test directory in both repos
6. Write bidirectional validation tests (A validates with B outputs, B validates with A outputs)
7. Add validation tasks to the repo's task runner (moon.yml where the repo uses moon)
8. Document pre-release protocol in both CLAUDE.md files
9. Run full symmetric validation to verify setup
10. Verify against Symmetric Dogfooding Checklist below
```

### Template B: Pre-Release Validation

```
1. Run the validate-symmetric task in releasing repo
2. Check if other repo has pending changes affecting integration
3. If yes, test against other repo's feature branch
4. Document any failures in validation log
5. Fix integration issues before release
6. Update version pins after successful validation
7. Coordinate if breaking changes require simultaneous release
8. Verify against Symmetric Dogfooding Checklist below
```

### Template C: Add New Integration Point

```
1. Identify new export/import being added
2. Update integration surface documentation
3. Add tests in both repos for new integration point
4. Run symmetric validation in both directions
5. Update version pins if needed
6. Verify against Symmetric Dogfooding Checklist below
```

### Symmetric Dogfooding Checklist

After ANY symmetric dogfooding work, verify:

- [ ] Both repos have integration tests that import the other
- [ ] Version pins are explicit (tags or commit SHAs)
- [ ] Pre-release checklist includes cross-repo validation
- [ ] Integration tests use real data (not mocks of the other repo)
- [ ] Breaking changes coordination documented
- [ ] Validation task runnable via single command

---

## Post-Change Checklist (Self-Maintenance)

After modifying THIS skill:

1. [ ] Templates cover common symmetric dogfooding scenarios
2. [ ] Checklist reflects current best practices
3. [ ] Example in references/ still accurate
4. [ ] Append changes to [evolution-log.md](./references/evolution-log.md)

---

## Implementation Guide

### Phase 1: Discovery and Mapping

**Identify the integration surface:**

- List all exports from Repo A consumed by Repo B
- List all exports from Repo B consumed by Repo A
- Document data formats, schemas, API signatures

**Map validation scenarios:**

- What real-world data from B can validate A outputs?
- What real-world data from A can validate B outputs?
- Identify edge cases that only appear in production usage

### Phase 2: Dependency Configuration

Configure cross-repo dev dependencies:

**Python (uv/pip):**

```toml
# Repo A pyproject.toml
[project.optional-dependencies]
validation = ["repo-b"]

[tool.uv.sources]
repo-b = { git = "https://github.com/org/repo-b", tag = "<tag>" }  # SSoT-OK
```

```toml
# Repo B pyproject.toml
[project.optional-dependencies]
validation = ["repo-a"]

[tool.uv.sources]
repo-a = { git = "https://github.com/org/repo-a", tag = "<tag>" }  # SSoT-OK
```

**Rust (Cargo):**

```toml
[dev-dependencies]
repo-b = { git = "https://github.com/org/repo-b", tag = "<tag>" }  # SSoT-OK
```

**Node.js:**

```json
{
  "devDependencies": {
    "repo-b": "github:org/repo-b#<tag>"
  }
}
```

**Critical**: Pin to tags or commit SHAs. Never use main/master branches.

### Phase 3: Test Infrastructure

**Directory structure in both repos:**

```
repo-a/
└── tests/
    ├── unit/              # Internal tests
    └── integration/       # Tests using repo-b real outputs
        └── test_with_repo_b.py

repo-b/
└── tests/
    ├── unit/              # Internal tests
    └── integration/       # Tests using repo-a real outputs
        └── test_with_repo_a.py
```

**Bidirectional validation test pattern:**

```python
# repo-a/tests/integration/test_with_repo_b.py
"""Validate Repo A outputs work correctly with Repo B inputs."""

def test_a_output_consumed_by_b():
    # Generate output using Repo A
    a_output = repo_a.generate_data()

    # Feed to Repo B - should work without errors
    b_result = repo_b.process(a_output)

    # Validate the round-trip
    assert b_result.is_valid()
```

### Phase 4: Task Automation

**moon.yml example** (task IDs use `-` because moon reserves `:` as the project/task separator):

```yaml
tasks:
  validate-symmetric:
    description: "Validate against partner repo"
    script: "uv sync --extra validation && uv run pytest tests/integration/ -v"

  validate-pre-release:
    description: "Full validation before release"
    deps: ["~:test-unit", "~:validate-symmetric"]
```

### Phase 5: Pre-Release Protocol

**Before releasing Repo A:**

1. Run `moon run :validate-symmetric` in Repo A (tests against current Repo B)
2. If Repo B has pending changes, test against Repo B branch too
3. Update version pins after successful validation

**Before releasing Repo B:**

1. Run `moon run :validate-symmetric` in Repo B (tests against current Repo A)
2. If Repo A has pending changes, test against Repo A branch too
3. Update version pins after successful validation

**Coordinating breaking changes:**

- If A needs to break compatibility, update B first
- If B needs to break compatibility, update A first
- Consider simultaneous releases for tightly coupled changes

---

## Anti-Patterns

| Anti-Pattern               | Problem                        | Solution                      |
| -------------------------- | ------------------------------ | ----------------------------- |
| One-direction only         | Misses half the bugs           | Always test both directions   |
| Using main branch          | Unstable, breaks randomly      | Pin to tags or SHAs           |
| Skipping for small changes | Small changes cause big breaks | Always run full validation    |
| Mocking partner repo       | Defeats the purpose            | Use real imports              |
| Ignoring version matrix    | Silent production failures     | Maintain compatibility matrix |

---

## References

- [example-setup.md](./references/example-setup.md) - Real-world trading-fitness/rangebar-py example
- [evolution-log.md](./references/evolution-log.md) - Skill change history

**External:**

- [Dogfooding (DevIQ)](https://deviq.com/practices/dogfooding/)
- [CDC Testing (Microsoft)](https://microsoft.github.io/code-with-engineering-playbook/automated-testing/cdc-testing/)

---

## Troubleshooting

| Issue                       | Cause                          | Solution                                         |
| --------------------------- | ------------------------------ | ------------------------------------------------ |
| Dependency resolution fails | Version pin outdated           | Update tag/SHA pin to latest stable version      |
| Tests pass locally fail CI  | Different partner repo version | Pin exact same version in both environments      |
| Breaking change not caught  | One-direction testing only     | Run validate-symmetric in BOTH repos             |
| Integration surface unclear | Undocumented exports           | Map all imports/exports before setting up tests  |
| Too many parts moving       | Uncoordinated releases         | Coordinate breaking changes, test branches first |
| Mock data hiding bugs       | Using stubs instead of real    | Always import real partner repo for integration  |
| Version matrix explosion    | Too many combinations          | Limit support to N-1 versions, document clearly  |
| Circular dependency         | Both repos require each other  | Use optional-dependencies for validation only    |

## Post-Execution Reflection

After this skill completes, reflect before closing the task:

0. **Locate yourself.** — Find this SKILL.md's canonical path before editing.
1. **What failed?** — Fix the instruction that caused it.
2. **What worked better than expected?** — Promote to recommended practice.
3. **What drifted?** — Fix any script, reference, or dependency that no longer matches reality.
4. **Log it.** — Evolution-log entry with trigger, fix, and evidence.

Do NOT defer. The next invocation inherits whatever you leave behind.

© terrylica · MIT · terrylica/cc-skills

Similar skills

All skills for Testing and QA →

From the same set79

The whole set →
infra-deploy infra-deploy deploys self-hosted Cal.com to GCP Cloud Run on a Supabase PostgreSQL database, or runs it locally with Docker Compose. CX Codex +1 119installs email-triage email-triage sorts recent Gmail messages into three categories and ranks their urgency. Use it to request an email digest through the bot’s /digest command. CX Codex +1 117installs bot-process-control bot-process-control maintains process control rules for Gmail Commander bot instances in Restate and blocks duplicate Telegram pollers on workstations. CX Codex +1 117installs interactive-bot interactive-bot is a Claude Code skill that documents the Gmail Commander Telegram bot. It covers email slash commands, AI routing of free text through MCP, and compose/reply sessions. CX Codex +1 114installs calcom-access calcom-access is a Claude Code skill for five other platforms that gives the agent access to Cal.com API for bookings, event types, schedules and slot availability. The API key is read from 1Password via CALCOM_OP_UUID. CX Codex +1 107installs claude-code-proxy-patterns The claude-code-proxy-patterns skill covers proxy patterns for routing Claude Code models to different providers. Use it when setting up OAuth passthrough or investigating proxy authentication failures. CX Codex +1 106installs summarize summarize is a Claude Code skill that analyzes multi-gigabyte text files and session recordings step by step. It helps trace what happened when a file is too large to read normally. CX Codex +1 103installs booking-config booking-config configures Cal.com event types, schedules, and webhooks via CLI commands. Useful when you need to adjust booking pages and availability without opening the web interface. CX Codex +1 103installs

Project sponsors

Companies that keep this analytics open