Index of every page on this site: llms.txt
All skills
rohitg00 avatar

/verification-gates

@d2e5c34
by Rohit Ghumarerohitg00/skillkit1.6k stars
154
Run it yourself

Creates explicit validation checkpoints (verification gates) between project phases to catch errors early and ensure quality before proceeding. Use when the user asks about quality gates, milestone checks, phase transitions, approval steps, go/no-go decision points, or preventing cascading errors across a multi-step workflow. Produces acceptance criteria checklists, automated CI gate configurations, manual sign-off requirements, and conditional review rules for scenarios such as security changes, API changes, or database migrations.

  • 1 file
  • 6.8 KB
  • Updated 9 months ago
  • GitHub
Use this Skill: https://skilld.dev/gh/rohitg00/skillkit/verification-gates

Nothing lands on disk. Nothing to clean up.

Fork this Skill

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

SKILL.md

≈140 tokens for metadata: the name and description. ≈1.5k when used: this file.

Description uses 7.0% 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 ≈559 characters, or 7.0%.

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.

Verification Gates

You are implementing verification gates - explicit checkpoints where work is validated before proceeding. This prevents cascading errors and ensures quality at each phase.

Core Principle

Never proceed to the next phase with unverified assumptions from the previous phase.

A verification gate is a deliberate pause to confirm that prerequisites are met before continuing.

Standard Verification Gates

Gate 1: Requirements Verification

Before starting design:

  • All requirements are documented and clear
  • Ambiguities have been resolved with stakeholders
  • Non-requirements are explicitly stated
  • Acceptance criteria are defined
  • Edge cases are identified

Actions:

  1. Review requirements document
  2. Identify any unclear items
  3. Get explicit confirmation on ambiguous points
  4. Document answers

Gate 2: Design Verification

Before starting implementation:

  • Design addresses all requirements
  • Technical approach is validated
  • Interfaces are defined
  • Data model is complete
  • Error handling is planned
  • Design has been reviewed (self or peer)

Actions:

  1. Walk through design against requirements
  2. Review with rubber duck or teammate
  3. Check for missing pieces
  4. Get approval to proceed

Gate 3: Implementation Verification

Before calling task complete:

  • Code compiles/runs without errors
  • All tests pass
  • New code has test coverage
  • Code follows project conventions
  • No obvious bugs or issues
  • Dependencies are appropriate

Actions:

  1. Run full test suite
  2. Self-review the diff
  3. Check for code smells
  4. Verify against acceptance criteria

Gate 4: Integration Verification

Before merging:

  • Feature works end-to-end
  • Integration tests pass
  • No regression in existing functionality
  • Performance is acceptable
  • Documentation is updated

Actions:

  1. Test the full user flow
  2. Run integration test suite
  3. Compare performance metrics
  4. Review documentation changes

Gate 5: Deployment Verification

Before marking complete:

  • Feature works in target environment
  • Monitoring shows no errors
  • Feature flags are properly configured
  • Rollback plan exists
  • Stakeholders can verify

Actions:

  1. Smoke test in environment
  2. Check error logs and metrics
  3. Get stakeholder sign-off
  4. Document deployment

Gate Types

Automated Gates

Gates that can be enforced automatically:

# CI Pipeline Gates
gates:
  - name: lint
    command: npm run lint
    required: true

  - name: type-check
    command: npm run typecheck
    required: true

  - name: unit-tests
    command: npm test
    required: true
    coverage: 80%

  - name: build
    command: npm run build
    required: true

Manual Gates

Gates requiring human judgment:

## Manual Verification Checklist

Before Code Review:
- [ ] I've tested my changes locally
- [ ] I've written/updated tests
- [ ] I've read my own diff
- [ ] I've checked for security issues
- [ ] I've updated documentation

Before Deployment:
- [ ] Code review approved
- [ ] QA verified (if applicable)
- [ ] Stakeholder approved (if required)
- [ ] Deployment plan reviewed

Conditional Gates

Gates that apply in specific situations:

Condition Required Gates
Security-related Security review
Public API change API review + migration plan
Database change DBA review + backup plan
Performance-sensitive Performance test
Breaking change Deprecation notice + migration

Implementing Gates

In Your Workflow

Task Start
    │
    ▼
┌─────────────────┐
│ Gate: Prereqs   │ ← Verify before starting
│ - Requirements  │
│ - Dependencies  │
└────────┬────────┘
         │
         ▼
    Do the work
         │
         ▼
┌─────────────────┐
│ Gate: Completion│ ← Verify before proceeding
│ - Tests pass    │
│ - Code reviewed │
└────────┬────────┘
         │
         ▼
Task Complete

Gate Documentation Template

## Gate: [Name]

**When:** [Before what action]

**Purpose:** [What this gate ensures]

**Checklist:**
- [ ] Item 1
- [ ] Item 2
- [ ] Item 3

**Verification Method:**
- [How to verify each item]

**Failure Actions:**
- [What to do if gate fails]

**Approver:** [Who can approve passage]

Gate Metrics

Good gates have high effectiveness (catch most issues), low overhead (quick to pass), and high value (prevent expensive downstream fixes). Track which gate caught an issue and how much time was spent at each gate to tune your process over time.

Integration with CI/CD

# GitHub Actions example
jobs:
  gate-lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - run: npm ci
      - run: npm run lint

  gate-test:
    needs: gate-lint
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - run: npm ci
      - run: npm test

  gate-build:
    needs: gate-test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - run: npm ci
      - run: npm run build

  deploy:
    needs: gate-build
    # Only deploys if all gates pass

Quick Reference

Phase Gate Before Key Checks
Design Requirements Clear, complete, approved
Implementation Design Reviewed, feasible
Review Implementation Tests, conventions, working
Merge Review Approved, conflicts resolved
Deploy Merge Environment ready, plan exists

Integration with Other Skills

  • design-first: Gates validate design before implementation
  • task-decomposition: Gates between task phases
  • testing/red-green-refactor: Tests are key gate criteria
  • collaboration/structured-review: Review is a gate

Source: SKILL.md on GitHub

No rule matched.

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.

No third-party reports yet.

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

Last checked against GitHub last month.

Steadyupdated 9 months ago
version
1.0.0
tags
[
  "planning",
  "verification",
  "quality",
  "gates"
]
difficulty
beginner
Other metadata
triggers
[
  "verify before",
  "checkpoint",
  "quality gate",
  "make sure before",
  "validation"
]
estimatedTime
10
relatedSkills
[
  "planning/design-first",
  "planning/task-decomposition",
  "testing/red-green-refactor"
]

README badge

README badge for rohitg00/skillkit/verification-gates