Skip to content
Skills Library
Programming · Testing

slim-continuous-testing

/slim-continuous-testing

Implement comprehensive continuous testing strategies with documentation templates and automated pre-commit configurations for static analysis, security scanning, and code quality checks across multiple programming languages. Use when projects need testing automation setup, documentation templates for testing procedures, pre-commit hook configurations, or guidance on establishing continuous testing practices. Triggers include requests for "testing setup", "automated testing", "pre-commit hooks", "code quality checks", "test documentation", or "continuous integration testing".

Repository
slim ↗
Licence
Apache-2.0
Last repository change
26.06.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
3
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 26.06.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Implement comprehensive continuous testing strategies with documentation templates and automated pre-commit configurations for static analysis, security scanning, and code quality checks across multiple programming languages. Use when projects need testing automation setup, documentation templates for testing procedures, pre-commit hook configurations, or guidance on establishing continuous testing practices. Triggers include requests for "testing setup", "automated testing", "pre-commit hooks", "code quality checks", "test documentation", or "continuous integration testing".

Triggers from the description

testing setupautomated testingpre-commit hookscode quality checkstest documentationcontinuous integration testing
Original author description

Implement comprehensive continuous testing strategies with documentation templates and automated pre-commit configurations for static analysis, security scanning, and code quality checks across multiple programming languages. Use when projects need testing automation setup, documentation templates for testing procedures, pre-commit hook configurations, or guidance on establishing continuous testing practices. Triggers include requests for "testing setup", "automated testing", "pre-commit hooks", "code quality checks", "test documentation", or "continuous integration testing".

How it works

  1. Overview
  2. Workflow
  3. Language-Specific Guidance
  4. Integration with CI/CD
  5. Assets Available
Original SKILL.md headings · 202 lines, 1,022 words
SKILL.md preview
---
name: slim-continuous-testing
description: Implement comprehensive continuous testing strategies with documentation templates and automated pre-commit configurations for static analysis, security scanning, and code quality checks across multiple programming languages. Use when projects need testing automation setup, documentation templates for testing procedures, pre-commit hook configurations, or guidance on establishing continuous testing practices. Triggers include requests for "testing setup", "automated testing", "pre-commit hooks", "code quality checks", "test documentation", or "continuous integration testing".
---

# Continuous Testing Framework

## Overview

This skill helps establish comprehensive continuous testing strategies for software projects by providing documentation templates and automated configurations. It combines testing best practices with practical implementation tools, enabling projects to maintain high code quality through automated checks and clear testing procedures.

The skill provides two core templates that work together: comprehensive testing documentation and automated pre-commit configurations that enforce quality standards before code commits.

## Workflow

### Step 1: Assess Current Testing State

Before implementing continuous testing, evaluate the project's current state:

**Questions to ask the user:**
1. What programming languages does the project use?
2. Are there existing tests in the project?
3. What testing frameworks are currently in use (if any)?
4. Is there existing CI/CD infrastructure?
5. What level of testing automation is desired?

**Project Analysis:**
- Check for existing test directories (`tests/`, `test/`, `spec/`)
- Look for testing configuration files (`pytest.ini`, `jest.config.js`, etc.)
- Identify the primary programming language and frameworks
- Review current development workflow and tools

### Step 2: Determine Testing Strategy

Based on the assessment, help users choose appropriate testing approaches:

**Testing Categories to Consider:**
- **Static Code Analysis**: Syntax, style, and basic error checking
- **Unit Tests**: Function and component-level testing
- **Security Tests**: Vulnerability scanning and security linting
- **Build Tests**: Compilation and package creation verification
- **Integration Tests**: Component interaction testing
- **Performance Tests**: Load and performance benchmarking

**Template Selection Decision Tree:**
- **Need testing documentation?** → Use TESTING.md template
- **Need automated quality checks?** → Use pre-commit-config.yaml template
- **Need comprehensive testing setup?** → Use both templates together

### Step 3: Template Selection and Customization

Present the available templates and help users select what they need:

#### Option A: Testing Documentation Template

**When to use:** Projects need standardized testing documentation and procedures.

**Template:** `assets/TESTING.md`

**Customization steps:**
1. Replace `[INSERT PROJECT NAME HERE]` with the actual project name
2. Select appropriate testing categories from the provided checklist
3. Customize testing category sections with project-specific details:
   - Update file paths and locations
   - Specify testing frameworks being used
   - Add manual and automatic execution instructions
   - Define results storage locations
4. Add project-specific testing categories if needed
5. Include team-specific contributing guidelines

#### Option B: Pre-commit Automation Template

**When to use:** Projects need automated code quality and security checks.

**Template:** `assets/pre-commit-config.yaml`

**Customization steps:**
1. Select appropriate hooks based on programming languages:
   - **Python projects**: Keep isort, black, ruff, bandit hooks
   - **JavaScript projects**: Add ESLint, Prettier hooks
   - **Multi-language projects**: Keep language-agnostic and relevant language-specific hooks
2. Adjust hook configurations:
   - Update file size limits in `check-added-large-files`
   - Modify bandit configuration paths if using pyproject.toml
   - Add or remove specific hooks based on project needs
3. Configure language-specific tools:
   - Add `.markdownlintrc` if using markdown linting
   - Set up appropriate ignore patterns
   - Configure security scanning severity levels

#### Option C: Comprehensive Setup (Recommended)

**When to use:** Projects want both documentation and automation (most common scenario).

**Implementation approach:**
1. Start with the testing documentation template to establish procedures
2. Implement pre-commit automation to enforce quality standards
3. Ensure both templates reference each other appropriately

### Step 4: Implementation and Integration

#### For Testing Documentation (TESTING.md):

1. **Place the file** in the project root directory
2. **Update README.md** to reference the testing documentation:
   ```markdown
   ## Testing

   See [TESTING.md](TESTING.md) for comprehensive testing information.
   ```
3. **Integrate with CI/CD** by referencing testing procedures in pipeline configurations
4. **Team onboarding**: Include TESTING.md in contributor documentation

#### For Pre-commit Configuration:

1. **Install pre-commit** in the project:
   ```bash
   pip install pre-commit
   # or
   brew install pre-commit
   ```

2. **Place configuration** as `.pre-commit-config.yaml` in project root

3. **Install hooks**:
   ```bash
   pre-commit install
   ```

4. **Test the setup**:
   ```bash
   pre-commit run --all-files
   ```

5. **Update development documentation** to include pre-commit setup instructions

### Step 5: Validation and Team Adoption

#### Testing Documentation Validation:
- [ ] All placeholder values have been replaced
- [ ] Testing categories match project needs
- [ ] File paths and commands are accurate
- [ ] Team members can follow the procedures
- [ ] Documentation is linked from main project README

#### Pre-commit Validation:
- [ ] Configuration file is properly formatted
- [ ] All selected hooks are relevant to the project
- [ ] Hooks run successfully on existing codebase
- [ ] Team has been informed about new commit requirements
- [ ] CI/CD pipeline acknowledges pre-commit checks

### Step 6: Maintenance and Evolution

**Regular Review Tasks:**
- Update testing documentation as new test categories are added
- Adjust pre-commit hooks as project requirements change
- Review hook performance and adjust configurations for efficiency
- Keep testing frameworks and tools up to date

**Scaling Considerations:**
- Add more specialized testing categories as project grows
- Implement additional hooks for new languages or tools
- Consider team-specific customizations for different development areas
- Integrate with advanced CI/CD workflows and quality gates

## Language-Specific Guidance

### Python Projects
- Keep bandit for security scanning
- Use black for code formatting
- Include isort for import organization
- Consider adding mypy for type checking

### JavaScript/TypeScript Projects
- Add ESLint and Prettier hooks
- Include testing framework-specific linting
- Consider security scanning with tools like audit

### Multi-Language Projects
- Focus on language-agnostic hooks first
- Add language-specific hooks as separate entries
- Use fail_fast strategically to balance speed and coverage

## Integration with CI/CD

The templates work well with existing CI/CD pipelines:

**GitHub Actions Integration:**
- Pre-commit hooks can run in CI to catch issues missed locally
- TESTING.md procedures can be automated in workflow files
- Use both templates to establish consistent quality gates

**Other CI Systems:**
- Most CI systems can execute pre-commit hooks
- Testing documentation provides clear automation guidelines
- Templates support various testing framework integrations

## Assets Available

This skill includes two comprehensive templates:

- **`TESTING.md`**: Complete testing documentation template with multiple testing categories, execution instructions, and team collaboration guidance
- **`pre-commit-config.yaml`**: Multi-language pre-commit configuration with security scanning, code quality checks, and formatting tools

Both templates are designed to work independently or together, providing flexibility for different project needs and maturity levels.
Files in this package (3)
  • SKILL.md 8 KB
  • assets/TESTING.md 2 KB
  • assets/pre-commit-config.yaml 2 KB

Versions

The database has no other skills named slim-continuous-testing.

Database snapshot: 13.11.2026 · package version efe2ccd85899 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100git-hooks
    Set up and configure Git pre-commit hooks for code quality, secrets scanning, and commit message validation. Use when installing git hooks, configuring pre-commit checks, or enforcing code standards.
  • 100testing
    Comprehensive software testing skill covering unit tests, integration tests, TDD/BDD, mocking strategies, and test automation across multiple languages. Use this skill when writing test cases, designing test strategies, implementing test automation, or need guidance on testing…
  • 100git-quality-hooks
    Add or repair local Git hooks for staged secret scanning and project-specific quality checks without overwriting existing workflows. Use for pre-commit, commit-msg, pre-push, or a requested local gate before sharing code.
  • 100pre-commit-quality-review
    Use when the user asks to commit, amend, or squash code, or requests a pre-commit structural quality review.
  • 100pre-commit
    Full validation gate before committing — quality checks, tests, coverage, security scan, changelog, and companion review. Use right before a commit to verify code is ready. Trigger on "pre-commit", "validate before commit", "ready to commit", "run all checks".
  • 100git-hooks-setup
    Use when setting up git hooks (pre-commit, commit-msg, pre-push) with husky or native hooks for linting, formatting, commit conventions, and secret scanning.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.