Agent skill

Testing Patterns

by dilolabs in dilolabs/nosia

Writes Minitest tests with fixtures following 37signals conventions.

MITAuto-check passedTesting & QA

Install Testing Patterns

skills CLI
$ npx skills add dilolabs/nosia --skill testing-patterns -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install dilolabs/nosia testing-patterns --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/dilolabs/nosia.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.vibe/skills/testing-patterns .claude/skills/testing-patterns && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
testing-patterns
GitHub stars
213
Used in
1 other repo
Token cost
~1.4k tokens
SKILL.md length
241 words
Files
4 (incl. references)
Skills in repo
15
Repo updated
First seen
Licence
MIT

At a glance

Writes Minitest tests with fixtures following 37signals conventions.

  • Adding test coverage
  • SKILL.md covers Your role, Core philosophy, Project knowledge and Commands, plus 7 more sections
  • Calls rails
  • Creating fixtures

What it does

Testing Patterns is an agent skill from dilolabs/nosia. Writes Minitest tests with fixtures following 37signals conventions. Uses Minitest (not RSpec) and fixtures (not factories). Use when writing tests, adding test coverage, or creating fixtures. WHEN NOT: For RSpec or FactoryBot patterns (this project uses Minitest + fixtures exclusively). For test configuration/CI setup (see project docs).

Its SKILL.md is about 1.4k tokens, which your agent loads only when the skill is triggered. The skill folder holds 4 other files, including reference files (for example `references/controller-tests.md`, `references/fixture-patterns.md` and `references/system-tests.md`). Compatibility notes: Ruby 3.3+, Rails 8.0+, Minitest

It sits in Testing & QA, covering Test strategy, Test coverage and Integration testing. It works with Ruby and Ruby on Rails. The repository describes itself as: Self-hosted AI RAG + MCP Platform. The licence is MIT.

When your agent uses it

  • Adding test coverage
  • Creating fixtures

Example prompts

  • “Use the testing-patterns skill to write Minitest tests with fixtures following 37signals conventions”
  • “/testing-patterns”

Requirements

  • Compatibility (from SKILL.md): Ruby 3.3+, Rails 8.0+, Minitest

What it can do on your machine

Read from SKILL.md and the folder at commit 0ef5e5d. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • rails

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

  • Compatibility

    Ruby 3.3+, Rails 8.0+, Minitest

    From compatibility in the SKILL.md frontmatter.

Context cost

Testing Patterns loads about 1.4k tokens when it runs, and up to ~4.8k if it reads all its reference files. Until then it costs about 89 tokens; SKILL.md has 241 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~89
When it runs · the whole SKILL.md, loaded when a task matches
~1.4k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~4.8k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from dilolabs/nosia at commit 0ef5e5d, republished under its MIT licence (© dilolabs). 241 words, ~1,383 tokens.

Download SKILL.mdSave it as .claude/skills/testing-patterns/SKILL.md (or your agent's skills folder). This skill also uses 3 other files; get the full folder from GitHub.
name
testing-patterns
description
Writes Minitest tests with fixtures following 37signals conventions. Uses Minitest (not RSpec) and fixtures (not factories). Use when writing tests, adding test coverage, or creating fixtures. WHEN NOT: For RSpec or FactoryBot patterns (this project uses Minitest + fixtures exclusively). For test configuration/CI setup (see project docs).
compatibility
Ruby 3.3+, Rails 8.0+, Minitest
license
MIT

You are an expert Rails testing architect specializing in Minitest with fixtures.

Your role

  • Write tests using Minitest, never RSpec
  • Use fixtures for test data, never factories (FactoryBot)
  • Write integration tests over unit tests when possible
  • Output: Fast, readable tests that verify behavior, not implementation

Core philosophy

Minitest is plenty. Fixtures are faster.

Why Minitest: Plain Ruby (no DSL), faster suite, simpler setup, part of Rails, easier to debug.
Why fixtures: 10-100x faster (loaded once), shared consistency, force realistic data, no factory DSL.
Test pyramid:
  • Few system tests (Capybara, full browser)
  • Many integration tests (controller + model)
  • Some unit tests (complex model logic only)

Project knowledge

Tech Stack: Minitest 5.20+, Rails 8.2, YAML fixtures Location: test/models/, test/controllers/, test/system/, test/integration/

Commands

  • bin/rails test -- Full suite
  • bin/rails test test/models/card_test.rb -- Specific file
  • bin/rails test test/models/card_test.rb:14 -- Specific line
  • bin/rails test:system -- System tests
  • bin/rails test:parallel -- Parallel execution

Model test structure

ruby
require "test_helper"

class CardTest < ActiveSupport::TestCase
  setup do
    @card = cards(:logo)
    @user = users(:david)
    Current.user = @user
    Current.account = @card.account
  end

  teardown do
    Current.reset
  end

  test "fixtures are valid" do
    assert @card.valid?
  end

  test "closing card creates closure record" do
    assert_difference -> { Closure.count }, 1 do
      @card.close(user: @user)
    end
    assert @card.closed?
    assert_equal @user, @card.closed_by
  end

  test "open scope excludes closed cards" do
    @card.close
    assert_not_includes Card.open, @card
    assert_includes Card.closed, @card
  end
end

Integration test structure

ruby
require "test_helper"

class CardsControllerTest < ActionDispatch::IntegrationTest
  setup do
    @card = cards(:logo)
    sign_in_as users(:david)
  end

  test "should create card" do
    assert_difference -> { Card.count }, 1 do
      post board_cards_path(@card.board), params: {
        card: { title: "New card", column_id: @card.column_id }
      }
    end
    assert_redirected_to card_path(Card.last)
  end

  test "requires authentication" do
    sign_out
    get card_path(@card)
    assert_redirected_to new_session_path
  end
end

Test helpers

ruby
# test/test_helper.rb
class ActionDispatch::IntegrationTest
  def sign_in_as(user)
    session_record = user.identity.sessions.create!
    cookies.signed[:session_token] = session_record.token
    Current.user = user
    Current.identity = user.identity
    Current.session = session_record
  end

  def sign_out
    cookies.delete(:session_token)
    Current.reset
  end
end

class ActiveSupport::TestCase
  fixtures :all
  parallelize(workers: :number_of_processors)
end

Common assertion patterns

ruby
# Record count changes
assert_difference -> { Card.count }, 1 do ... end

# Attribute updates
@card.close
assert @card.closed?
assert_equal @user, @card.closed_by

# Errors
assert_raises ActiveRecord::RecordInvalid do
  Card.create!(title: nil)
end

# Collections
assert_includes Card.open, @card
refute_includes Card.closed, @card

# HTTP responses
assert_response :success
assert_redirected_to card_path(Card.last)

# DOM assertions
assert_select "h1", "Cards"
assert_select ".card", count: 3

# Jobs and emails
assert_enqueued_with job: NotifyRecipientsJob do ... end
assert_emails 1 do ... end

Anti-patterns to avoid

ruby
# BAD: Using factories
let(:card) { FactoryBot.create(:card) }
# GOOD: Use fixtures
setup { @card = cards(:logo) }

# BAD: Testing implementation
test "calls create_closure" do
  @card.expects(:create_closure!)
  @card.close
end
# GOOD: Test behavior
test "closing creates closure" do
  @card.close
  assert @card.closed?
end

# BAD: Creating data when fixtures exist
setup { @user = User.create!(name: "Test") }
# GOOD: Use fixtures
setup { @user = users(:david) }

# BAD: Testing Rails functionality
test "validates presence of title" do ...
# GOOD: Only test custom validations
test "validates title doesn't contain profanity" do ...

Boundaries

  • Always: Use Minitest, use fixtures, test behavior not implementation, write integration tests for features, use descriptive test names, clean up in teardown
  • Ask first: Before testing private methods (test public interface), before testing Rails functionality (already tested), before using mocks/stubs (prefer real objects)
  • Never: Use RSpec, use FactoryBot, test implementation details, create unnecessary test data, skip system tests for critical features

Reference files

  • references/fixture-patterns.md -- YAML fixture patterns, ERB, UUID fixtures, associations
  • references/controller-tests.md -- Controller/integration test patterns, Turbo Stream assertions
  • references/system-tests.md -- Capybara system test patterns, setup, assertions

© dilolabs, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 3 other files (references) in .vibe/skills/testing-patterns of dilolabs/nosia.

  • SKILL.md
  • references/controller-tests.md
  • references/fixture-patterns.md
  • references/system-tests.md

Open the folder on GitHubat commit 0ef5e5d

Used in 1 other repository

We found 3 copies of this SKILL.md (exact, near-identical or edited) in other folders, from 1 other GitHub owner. This page covers the copy in dilolabs/nosia, which our catalogue first saw on October 7, 2026.

Compare with similar skills

Testing Patterns next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Testing Patterns compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Testing Patterns this skilldilolabs/nosia2131 repos~1.4kAutomated safety check: PassMIT
Rails Testingpproenca/dot-skills214—~2.1kAutomated safety check: PassMIT
Dotnet Testingnovotnyllc/dotnet-artisan233—~972Automated safety check: PassMIT
Wp Test Strategyjorgerosal/wordpress-skills100—~974Automated safety check: PassMIT
Assessing Test Coveragebitwarden/ai-plugins154—~1.1kAutomated safety check: PassCustom licence
Testing Strategiesrohitg00/awesome-claude-code-toolkit2.7k—~1.4kAutomated safety check: PassApache-2.0

Similar skills

  • Rails Testing

    pproenca/dot-skills

    Ruby on Rails testing best practices for writing effective, maintainable test suites with RSpec.

    214 GitHub stars~2.1k tokensUpdated 1 mo ago
    Testing & QAAuto-check passed
  • Dotnet Testing

    novotnyllc/dotnet-artisan

    Defines .NET test strategy and implementation patterns across xUnit v3 (Facts, Theories, fixtures, IAsyncLifetime), integration testing (WebApplicationFactory, Testcontainers), Aspire testing…

    233 GitHub stars~972 tokensUpdated 1 mo ago
    Testing & QAAuto-check passed
  • Wp Test Strategy

    jorgerosal/wordpress-skills

    WordPress testing strategy and review guidance. An agent skill from jorgerosal/wordpress-skills.

    100 GitHub stars~974 tokensUpdated 4 mo ago
    Testing & QAAuto-check passed
  • Assessing Test Coverage

    bitwarden/ai-plugins

    Official

    A skill your agent uses when determining what test coverage ALREADY exists for a specific change (a PR, Jira key, Tech Breakdown doc, Testmo CSV, changed paths, or named component).

    154 GitHub stars~1.1k tokensUpdated today
    Testing & QAAuto-check passed
  • Testing Strategies

    rohitg00/awesome-claude-code-toolkit

    Testing strategies including contract testing, snapshot testing, mutation testing, property-based testing, and test organization

    2.7k GitHub stars~1.4k tokensUpdated 4 mo ago
    Testing & QAAuto-check passed
  • Test Expert

    einverne/dotfiles

    Testing methodologies, test-driven development (TDD), unit and integration testing, and testing best practices across multiple frameworks.

    121 GitHub stars~2.3k tokensUpdated 28 days ago
    Testing & QAAuto-check passed

More from dilolabs/nosia

All 15 skills in this repo
  • API Patterns

    dilolabs/nosia

    Builds REST APIs using respondto blocks with Jbuilder templates following the 37signals same-controllers-different-formats philosophy.

    213 GitHub starsUsed in 1 repo~2.5k tokens
    Auto-check passed
  • Auth Setup

    dilolabs/nosia

    Implements custom passwordless authentication without Devise.

    213 GitHub starsUsed in 1 repo~2.9k tokens
    Auto-check passed
  • Caching Patterns

    dilolabs/nosia

    Implements HTTP caching with ETags, fragment caching, Russian doll caching, and Solid Cache configuration.

    213 GitHub starsUsed in 1 repo~1.9k tokens
    Auto-check passed
  • Concern Patterns

    dilolabs/nosia

    Creates and refactors model and controller concerns for shared behavior.

    213 GitHub starsUsed in 1 repo~1.8k tokens
    Auto-check passed
  • Event Tracking

    dilolabs/nosia

    Builds event tracking, activity feeds, and webhook systems following 37signals patterns with a generic Event model and Eventable concern.

    213 GitHub starsUsed in 1 repo~3.3k tokens
    Auto-check passed
  • Job Patterns

    dilolabs/nosia

    Implements shallow background jobs with later/now conventions using Solid Queue.

    213 GitHub starsUsed in 1 repo~1.6k tokens
    Auto-check passed

Categories

Questions about Testing Patterns

What does Testing Patterns do?

Writes Minitest tests with fixtures following 37signals conventions. Testing Patterns is an agent skill from dilolabs/nosia. Writes Minitest tests with fixtures following 37signals conventions.

When should I use Testing Patterns?

Testing Patterns fits situations like: adding test coverage; creating fixtures.

How do I install Testing Patterns in Claude Code?

Run `npx skills add dilolabs/nosia --skill testing-patterns -a claude-code`. Or copy the skill folder (.vibe/skills/testing-patterns in dilolabs/nosia) into .claude/skills/testing-patterns in your project. Claude Code loads it when a task matches its description.

How do I install Testing Patterns in Codex?

Run `npx skills add dilolabs/nosia --skill testing-patterns -a codex`. Or copy the skill folder (.vibe/skills/testing-patterns in dilolabs/nosia) into .agents/skills/testing-patterns in your project. Codex loads it when a task matches its description.

Can I use Testing Patterns in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add dilolabs/nosia --skill testing-patterns -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/testing-patterns, .gemini/skills/testing-patterns, .github/skills/testing-patterns and .opencode/skills/testing-patterns in your project.

What does Testing Patterns need to run?

Going by SKILL.md and its folder, Testing Patterns needs the command-line tools its instructions call (rails). Compatibility (from SKILL.md): Ruby 3.3+, Rails 8.0+, Minitest.

Does Testing Patterns access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Testing Patterns safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Testing Patterns use?

Testing Patterns is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Testing Patterns use?

About 1.4k tokens (SKILL.md is roughly 5.5k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 3.4k tokens, read only when the agent opens those files.

What are the alternatives to Testing Patterns?

Skills that share tags, products or a category with Testing Patterns: Rails Testing (pproenca/dot-skills, 214 stars), Dotnet Testing (novotnyllc/dotnet-artisan, 233 stars), Wp Test Strategy (jorgerosal/wordpress-skills, 100 stars) and Assessing Test Coverage (bitwarden/ai-plugins, 154 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Testing Patterns?

dilolabs (a GitHub organization) maintains it in dilolabs/nosia, which has 213 GitHub stars. The repository holds 15 skills in this directory. The repository was last updated on September 9, 2026.

Source: dilolabs/nosia on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.