Skip to content
Skills Library
DevOps & cloud · Building & coding

Quality Gates

/Quality Gates

This skill should be used when the user wants to set up linting, configure auto-checking after edits, create a deploy checklist, set up pre-push checks, configure a CI pipeline, add quality gates, set up a hook for typechecking, enable post-edit validation, or auto-validate code changes. Triggered by phrases like "set up linting", "auto check after edits", "deploy checklist", "pre-push checks", "CI pipeline", "quality gates", "hook for typecheck", "post-edit validation", "auto-validate".

Licence
Apache-2.0
Last repository change
03.09.2026

Assessment and security

90/ 100Class: good
Format15 / 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
4
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 03.09.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

This skill should be used when the user wants to set up linting, configure auto-checking after edits, create a deploy checklist, set up pre-push checks, configure a CI pipeline, add quality gates, set up a hook for typechecking, enable post-edit validation, or auto-validate code changes. Triggered by phrases like "set up linting", "auto check after edits", "deploy checklist", "pre-push checks", "CI pipeline", "quality gates", "hook for typecheck", "post-edit validation", "auto-validate".

Triggers from the description

set up lintingauto check after editsdeploy checklistpre-push checksCI pipelinequality gateshook for typecheckpost-edit validation
Original author description

This skill should be used when the user wants to set up linting, configure auto-checking after edits, create a deploy checklist, set up pre-push checks, configure a CI pipeline, add quality gates, set up a hook for typechecking, enable post-edit validation, or auto-validate code changes. Triggered by phrases like "set up linting", "auto check after edits", "deploy checklist", "pre-push checks", "CI pipeline", "quality gates", "hook for typecheck", "post-edit validation", "auto-validate".

How it works

  1. Purpose
  2. PostToolUse Hooks
  3. Deploy Checklist
  4. CI Pre-Push Gate
  5. Stack Detection
  6. Workflow Integration
  7. Cross-References
Original SKILL.md headings · 124 lines, 561 words
SKILL.md preview
---
name: Quality Gates
description: This skill should be used when the user wants to set up linting, configure auto-checking after edits, create a deploy checklist, set up pre-push checks, configure a CI pipeline, add quality gates, set up a hook for typechecking, enable post-edit validation, or auto-validate code changes. Triggered by phrases like "set up linting", "auto check after edits", "deploy checklist", "pre-push checks", "CI pipeline", "quality gates", "hook for typecheck", "post-edit validation", "auto-validate".
---

# Quality Gates

## Purpose

Automatic quality validation at every stage of development — from individual file edits to full deployments. Quality gates catch errors early when they're cheapest to fix.

## PostToolUse Hooks

The most powerful quality gate: automatic validation every time a file is edited or created.

### How It Works
1. Agent uses `Edit` or `Write` to modify a file
2. PostToolUse hook fires automatically
3. Validation script detects the file type and runs the appropriate checker
4. Output is shown to the agent immediately
5. Agent sees errors and can fix them in the same session

### Setting Up
The plugin includes a ready-to-use hook in `hooks/hooks.json` that runs `scripts/post-edit-check.sh`. When installed as a plugin, this works automatically.

For manual setup in a project, add to `.claude/settings.json`:

```json
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "bash .claude/scripts/post-edit-check.sh"
          }
        ]
      }
    ]
  }
}
```

**Important:** The command must be exactly `bash .claude/scripts/post-edit-check.sh` — do not add arguments. The script reads `$CLAUDE_TOOL_INPUT` from the environment automatically.

See `references/hook-patterns.md` for stack-specific hook examples.

## Deploy Checklist

Before deploying any application, run through these 5 verification stages:

| Stage | What | Gate |
|-------|------|------|
| 1. Code Quality | Lint + Typecheck + Tests | All pass |
| 2. Build | Full build succeeds | Artifacts exist |
| 3. Environment | Required env vars present | All set (never read values) |
| 4. Container | Image builds and starts | No errors |
| 5. Post-Deploy | Health endpoint, logs | 200 OK, clean logs |

See `references/deploy-checklist.md` for complete verification commands per stack.

## CI Pre-Push Gate

Run the full quality suite locally before pushing to remote:

```
Lint → Build → Test → Security Scan
```

**Key rules:**
- Run stages sequentially
- Exit on first failure
- Target under 2 minutes total
- Don't skip stages
- Save results to `.claude/reports/ci/`

See `references/ci-pipeline.md` for the full pipeline template.

## Stack Detection

The quality gates system auto-detects your project stack to run the right validators.

### Detection Priority

| Check | Detected Stack | Primary Validator |
|-------|---------------|-------------------|
| `tsconfig.json` exists | TypeScript | `npx tsc --noEmit` |
| `package.json` exists (no tsconfig) | JavaScript | `npx eslint` |
| `pyproject.toml` or `setup.py` exists | Python | `ruff check` |
| `Cargo.toml` exists | Rust | `cargo check` |
| `go.mod` exists | Go | `go vet ./...` |

### File Extension Fallback

When editing individual files, detect by extension:

| Extension | Validator |
|-----------|-----------|
| `.ts`, `.tsx` | TypeScript checker |
| `.js`, `.jsx` | ESLint (if configured) |
| `.py` | ruff or py_compile |
| `.rs` | cargo check |
| `.go` | go vet |
| Other | Silent pass |

## Workflow Integration

### During Development
- PostToolUse hooks catch errors on every edit
- Agent fixes issues immediately before they compound

### Before Pushing
- Run the CI pipeline locally: lint → build → test → security
- All stages must pass before pushing

### Before Deploying
- Run through the deploy checklist
- Verify build, environment, and health endpoints
- Ensure rollback plan is ready

## Cross-References

- `references/hook-patterns.md` — PostToolUse hook examples for every stack
- `references/deploy-checklist.md` — 5-stage pre-deploy verification
- `references/ci-pipeline.md` — Local CI pipeline pattern
Files in this package (4)
  • SKILL.md 4 KB
  • references/ci-pipeline.md 2 KB
  • references/deploy-checklist.md 2 KB
  • references/hook-patterns.md 3 KB

Versions

The database has no other skills named Quality Gates.

Database snapshot: 13.11.2026 · package version eb7ccc63f4fe (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

  • 90gate-ci
    Integrate API quality gates into CI — linting, breaking change detection, and coverage checks. Use when asked to "add API checks to CI", "detect breaking changes in CI", or "set up an API quality gate".
  • 100deploy
    Use when the user says "ship it", "ready to push", "release", "deploy", or wants pre-push gates (lint, typecheck, build, tests) plus commit/release/push in one flow. Standalone — never auto-invoked; push always requires explicit confirmation.
  • 100deploy
    Use when ready to ship — runs pre-push gates (lint, typecheck, build, tests, security sweep), commits, releases, and pushes. Standalone, never auto-invoked. Push always requires explicit confirmation. Trigger with /hyperflow:deploy, "ship it", "ready to push", "release", "cut a release", "deploy".
  • 100quality-gates
    Quality gates, automated checks, and enforcement rules for fullstack projects. Scripts for secrets scanning, env validation, pre-deploy checks, dependency audit, conventional commits. Use when setting up a new project, before deploying, or when checking code quality.
  • 90hyperflow-deploy
    Hyperflow ship phase. Use when the user is ready to release — verbs like ship, push, release, deploy, "cut a release", "ready to push". Runs pre-push gates (lint + typecheck + build + tests + security sweep), then asks before pushing. Never --no-verify, never force-push to main.
  • 100ci-scaffolding
    This skill should be used when the user says \"set up CI\", \"create GitHub Actions\", \"scaffold CI pipeline\", \"add CI/CD\", \"configure continuous integration\", \"create test workflow\", \"create release workflow\", \"add pre-commit hooks\", \"set up linting pipeline\",…

Feedback and reports

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