Skip to content
OpenAgentSkill
Browsing is open · Catalog captured 2026-11-21 · Automatic updates and account services are paused.
Development

adopt-tiering

One-time migration that splits a repo's existing test suite into a fast unit tier and a slow integration tier — for a repo whose own spec-flow/TESTING.md policy chooses that split, not an assumption the pipeline makes. Classify tests by evidence (container/I-O/timing) and let the compiler + test timings arbitrate, physically separate them (Gradle source set + classpath scoping, or Rust src/ vs tests/ + nextest profiles), wire the CI failures artifact, and open a PR. Run once per repo. See docs/workflow.md ("Test policy"). Never merges.

rustyrazorblade · AI review on file

Installation

Read the source and dependencies before running a command. Copying does not install or execute anything.

npx skills add rustyrazorblade/skills --skill adopt-tiering

About this skill


name: adopt-tiering description: One-time migration that splits a repo's existing test suite into a fast unit tier and a slow integration tier — for a repo whose own spec-flow/TESTING.md policy chooses that split, not an assumption the pipeline makes. Classify tests by evidence (container/I-O/timing) and let the compiler + test timings arbitrate, physically separate them (Gradle source set + classpath scoping, or Rust src/ vs tests/ + nextest profiles), wire the CI failures artifact, and open a PR. Run once per repo. See docs/workflow.md ("Test policy"). Never merges. argument-hint: [optional notes; run from inside the target repo]

adopt-tiering — split an existing suite into unit / integration tiers

You are the PM/lead in the main session. Bring a repo that does not yet separate fast unit tests from slow integration tests onto that split (see Test policy in docs/workflow.md). This is a one-time migration per repo, and it applies only where the repo's own spec-flow/TESTING.md chooses the tiered policy. spec-flow assumes no split and ships no runtime default, so that file is the whole of the policy. Check it first, and say so plainly if it points somewhere else. The migration produces one review-ready PR and never merges.

This is repo infrastructure, not a feature — so it is not tied to a GitHub issue and does not go through groom → activate → implement. Move into a dedicated worktree using Claude Code's own isolation rather than creating one by hand — call the EnterWorktree tool (or simply ask to "work in a worktree") with a name like adopt-test-tiering. All work happens inside that worktree from here on; its branch name is whatever Claude Code assigns, not something this skill picks — that's fine, this migration isn't correlated back to anything by branch name the way an issue's work is.

Why the split has to be structural

The tiering model only holds if the boundary is enforced, not conventional: the unit tier must be fast by construction (no container, no I/O), so a container test must be unable to live in it. For Gradle that means classpath scoping (Testcontainers/JDBC only on the integration source set); for Rust it means integration tests live in tests/ binaries the unit default-filter excludes.

Steps

  1. Detect the runner and current layout.

    • Gradle — build.gradle.kts/build.gradle, src/test. Already tiered if a src/integrationTest source set / integrationTest JVM Test Suite exists.
    • Rust — Cargo.toml; unit tests in src/**, integration in tests/**. Already tiered if .config/nextest.toml defines the tier default-filters (see references/ci/). If the repo is already tiered, say so and stop. In a partially-tiered repo, handle only what's still mixed — this skill is idempotent.
  2. Classify the existing tests — delegate to the architect agent, then let the tooling arbitrate. Static tells give the first cut → integration tier: Testcontainers (GenericContainer, @Testcontainers), JDBC / DB drivers / a real DataSource, real sockets / HTTP clients, filesystem I/O, process spawning, Docker — anything needing a live external dependency. But you do not have to get this perfect from static analysis, because two mechanical checks arbitrate and make a misclassification either way recoverable:

    • Compilation is the enforcer. Once container/JDBC/network deps are scoped to the integration source set only (step 4), a dep-requiring test left in the unit tier won't compile — it fails loudly, it cannot silently sit there. Use this: attempt the split, and let unit-tier compile failures reclassify those tests to integration.
    • Test timings catch the rest. A test that is slow but compiles (heavy pure computation, allowed local I/O) shows up in the runner's test-time report; move the slow outliers to integration. So classify from the tells, then verify with the compiler and the timings — don't agonize over the static pass. A genuinely ambiguous test can go to unit and be corrected by a compile error / its timing, or to integration and be pulled back by CI → /spec-flow:sync-ci; both directions are recoverable. The architect returns a proposed assignment: each test → unit | integration, plus the tell that decided it.
  3. Present the plan to the owner — before moving anything. Show the proposed split: the integration-bound tests with the tell for each, and every ambiguous case. This is a large, mechanical change; let the owner adjust the classification before any file moves.

  4. Execute the split — delegate to tdd-developer / build-engineer.

    • Gradle — create the integrationTest source set (JVM Test Suite plugin on Gradle 7.3+, or a hand-rolled source set + task below it); move the integration-classified tests to src/integrationTest/…; move Testcontainers/JDBC/network deps to integrationTestImplementation only (so a container test can't compile under src/test); wire check to depend on integrationTest. Keep ./gradlew test (unit) and ./gradlew check (all) green.
    • Rust — ensure integration-classified tests live in tests/ binaries (move out of src/ unit modules where needed); add .config/nextest.toml:
      [profile.default]   # fast local tier
      default-filter = "not (kind(test) or package(integration-tests))"
      [profile.ci]        # full suite
      default-filter = "all()"
      
      Confirm cargo nextest run (unit) and cargo nextest run --profile ci --run-ignored all (all) pass. Match the repo's conventions; commit in focused steps.
  5. Wire CI to the contract. Copy the matching template from ${CLAUDE_PLUGIN_ROOT}/references/ci/ (github-actions-gradle.yml or github-actions-nextest.yml) into .github/workflows/, adjusting toolchain versions and any service

Read the complete source ↗