Index of every page on this site: llms.txt
All skills
Run it yourself

TDD and testing skills for iOS/macOS apps. Covers characterization tests, TDD workflows, test contracts, snapshot tests, test infrastructure, and deterministic quality gates (fitness functions, coverage ratchet, mutation testing). Use for test-driven development, adding tests to existing code, or building test infrastructure.

Use this Skill: https://skilld.dev/gh/rshankras/claude-code-apple-skills/testing

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈84 tokens for metadata: the name and description. ≈1.5k when used: this file. ≈26k more on demand in 14 files.

Description uses 4.2% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈337 characters, or 4.2%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

Testing & TDD Skills

Test-driven development workflows and testing infrastructure for Apple platform apps. Works with both new and existing codebases.

When This Skill Activates

Use this skill when the user:

  • Wants to do TDD (test-driven development) with AI-generated code
  • Needs to add tests before refactoring existing code
  • Wants to fix a bug using the red-green-refactor cycle
  • Needs test infrastructure (factories, mocks, contracts)
  • Asks about snapshot/visual regression testing
  • Wants to ensure AI-generated code is correct via tests
  • Wants deterministic gates around agent-written code (architecture invariants, coverage floors, mutation audits)

Available Skills

For Existing Codebases

characterization-test-generator/ Capture current behavior of existing code before refactoring. Generates tests that document what code actually does (not what it should do), giving you a safety net for AI-assisted refactoring.

tdd-bug-fix/ Reproduce-first bug fix workflow. Write a failing test that demonstrates the bug, then fix it. Ensures the bug never regresses — critical when AI generates fixes.

tdd-refactor-guard/ Pre-refactor safety checklist. Verifies test coverage exists before allowing AI to touch existing code. Prevents the "refactor without a safety net" problem.

For New Code

tdd-feature/ Red-green-refactor scaffold for new features. Generates the failing test first, then guides implementation to make it pass, then refactors. The core TDD workflow.

test-contract/ Protocol/interface test suites. Define the contract (e.g., "any DataStore must handle empty state, single item, 100 items, and errors"), and it generates a test suite any implementation must pass.

Infrastructure

snapshot-test-setup/ SwiftUI visual regression testing using swift-snapshot-testing. Generates snapshot test boilerplate, configuration, and CI integration.

test-data-factory/ Test fixture factories for your models. Makes writing tests faster by eliminating boilerplate data setup. Supports Builder pattern and static factory methods.

integration-test-scaffold/ Cross-module test harness with mock servers, in-memory stores, and test configuration. For testing networking + persistence + business logic together.

flow-walkthrough/ Drive each user flow in the Simulator (XCUITest + per-step screenshots), audit the navigation graph for dead-ends, and run a human discoverability check.

Deterministic Gates

fitness-functions/ Architecture fitness functions — tests that enforce a project's hard rules (module import boundaries, offline guarantees, count/copy contracts) from inside its own test target. Turns prose constraints into exit codes.

coverage-ratchet/ Coverage floor that only rises: a committed baseline the app target's line coverage may never drop below, gated by a generated xccov script. Includes an advisory CRAP report (complexity × uncovered).

mutation-testing/ EXPERIMENTAL, advisory-only muter setup scoped to engine targets — surviving mutants reveal covered-but-unasserted code. Never a merge gate; includes the manual deliberate-break fallback.

Keep Tests Fast

Agent-written tests get slow in the same few ways, and every phase runs the suite more often, so slow tests cost time on every build. SwiftShip's /apple:verify times the suite each phase and warns when it gets more than 25% slower or a single test takes over 10 s. Write tests so it never has to:

  1. One test with a list of inputs, not copies. Five near-identical tests are five setups. Use @Test(arguments:):
    @Test(arguments: ["", " ", "\n"])
    func rejectsBlankTitle(_ title: String) throws {
        #expect(throws: NoteError.blankTitle) { try Note(title: title) }
    }
  2. Fakes for the network, the clock and storage. No real URLSession calls: inject a protocol, or a URLProtocol stub. No real waiting: pass a clock or a date provider instead of waiting for time to pass. SwiftData: an in-memory ModelConfiguration(isStoredInMemoryOnly: true).
  3. No sleep, no fixed waits. Task.sleep, sleep() and long XCTWaiter timeouts make every run pay the worst case. Await the result, or wait on the specific element (waitForExistence(timeout:) returns as soon as it appears).
  4. UI tests launch the app once per class, not per test, when the tests don't need a fresh state: launch in setUp only when needed, or reset state through a launch argument instead of a relaunch. Test logic in unit tests, not through the UI; keep UI tests for flows.
  5. Unit tests touch no disk, network or Simulator. If a unit test needs one of those, it's an integration test (integration-test-scaffold/); keep it in its own target or test plan so the fast suite stays fast.

A test over 10 s is a bug in the test, not a fact of life: find which of the five it breaks.

How to Use

  1. Identify whether user is working on new code or existing code
  2. Read the relevant skill's SKILL.md for detailed workflow
  3. Detect project context (testing framework, architecture, existing tests)
  4. Generate tests following the skill's workflow
  5. Verify tests compile and run

Relationship to test-generator

The generators/test-generator/ skill generates test boilerplate (unit, integration, UI tests). These testing skills are complementary — they focus on workflows and methodology (TDD cycle, characterization testing, contracts) rather than just test file generation.

Cross-reference:

  • Use test-generator for "add tests to this class"
  • Use testing/tdd-feature for "I want to TDD this new feature"
  • Use testing/characterization-test-generator for "I need to safely refactor this"
  • Use testing/tdd-bug-fix for "fix this bug and make sure it never comes back"

Source: SKILL.md on GitHub

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

1 warning6d5 checks · Risk SAFE
  • Gen Agent Trust Hub8d

    The testing skill provides a comprehensive suite of TDD and infrastructure tools for Apple platform development. It is categorized as low risk due to potential indirect prompt injection from local source files, the recommendation to install external third-party testing tools via Homebrew, and the use of dynamic execution in helper scripts for parsing coverage data.

  • Socket6d

    No alerts

  • Snyk8d

    Risk: LOW · No issues

  • Runlayer8mo

    2/9 files flagged

  • ZeroLeaks7mo

    Scan incomplete

Signed by skilld at f958982. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub last week.

Activeupdated 2 weeks ago
What it can do
Reads files Edits files Runs commands
last_verified
2026-07-24
review_by
2027-06-22
All 7 allowed tools
ReadWriteEditGlobGrepBashAskUserQuestion

README badge

README badge for rshankras/claude-code-apple-skills/testing