build-quality-gates
Systematic methodology for implementing comprehensive build quality gates using BAIME framework. Achieved 98% error coverage with 17.4s detection time, reducing CI failures from 40% to 5%.
- Category: discovered
- Tags: github, community
- Version: 1.0.0
- Author: walid
- Downloads: 0
- GitHub stars: 15
- Updated: 2025-12-22
Download the latest version (v1.0.0) from this page.
SKILL.md
---
name: build-quality-gates
title: Build Quality Gates Implementation
description: |
Systematic methodology for implementing comprehensive build quality gates using BAIME framework.
Achieved 98% error coverage with 17.4s detection time, reducing CI failures from 40% to 5%.
**Validated Results**:
- V_instance: 0.47 → 0.876 (+86%)
- V_meta: 0.525 → 0.933 (+78%)
- Error Coverage: 30% → 98% (+227%)
- CI Failure Rate: 40% → 5% (-87.5%)
- Detection Time: 480s → 17.4s (-96.4%)
category: engineering-quality
tags:
- build-quality
- ci-cd
- baime
- error-prevention
- automation
- testing-strategy
prerequisites:
- Basic familiarity with build systems and CI/CD
- Understanding of software development workflows
- Project context: any software project with build/deployment steps
estimated_time: 5-15 minutes setup, 2-4 hours full implementation
difficulty: intermediate
impact: high
validated: true
# Validation Evidence
validation:
experiment: build-quality-gates (BAIME)
iterations: 3 (P0 → P1 → P2)
v_instance: 0.876 (target ≥0.85)
v_meta: 0.933 (target ≥0.80)
error_coverage: 98% (target >80%)
performance_target: "<60s" (achieved: 17.4s)
roi: "400% (first month)"
---
# Build Quality Gates Implementation
## Overview & Scope
This skill provides a systematic methodology for implementing comprehensive build quality gates using the BAIME (Bootstrapped AI Methodology Engineering) framework. It transforms chaotic build processes into predictable, high-quality delivery systems through quantitative, evidence-based optimization.
### What You'll Achieve
- **98% Error Coverage**: Prevent nearly all common build and commit errors
- **17.4s Detection**: Find issues locally before CI (vs 8+ minutes in CI)
- **87.5% CI Failure Reduction**: From 40% failure rate to 5%
- **Standardized Workflows**: Consistent quality checks across all team members
- **Measurable Improvement**: Quantitative metrics track your progress
### Scope
**In Scope**:
- Pre-commit quality gates
- CI/CD pipeline integration
- Multi-language build systems (Go, Python, JavaScript, etc.)
- Automated error detection and prevention
- Performance optimization and monitoring
**Out of Scope**:
- Application-level testing strategies
- Deployment automation
- Infrastructure monitoring
- Security scanning (can be added as extensions)
## Prerequisites & Dependencies
### System Requirements
- **Build System**: Any project with Make, CMake, npm, or similar build tool
- **CI/CD**: GitHub Actions, GitLab CI, Jenkins, or similar
- **Version Control**: Git (for commit hooks and integration)
- **Shell Access**: Bash or similar shell environment
### Optional Tools
- **Language-Specific Linters**: golangci-lint, pylint, eslint, etc.
- **Static Analysis Tools**: shellcheck, gosec, sonarqube, etc.
- **Dependency Management**: go mod, npm, pip, etc.
### Team Requirements
- **Development Workflow**: Standard Git-based development process
- **Quality Standards**: Willingness to enforce quality standards
- **Continuous Improvement**: Commitment to iterative improvement
## Implementation Phases
This skill follows the validated BAIME 3-iteration approach: P0 (Critical) → P1 (Enhanced) → P2 (Optimization).
### Phase 1: Baseline Analysis (Iteration 0)
**Duration**: 30-60 minutes
**Objective**: Quantify your current build quality problems
#### Step 1: Collect Historical Error Data
```bash
# Analyze recent CI failures (last 20-50 runs)
# For GitHub Actions:
gh run list --limit 50 --json status,conclusion,databaseId,displayTitle,workflowName
# For GitLab CI:
# Check pipeline history in GitLab UI
# For Jenkins:
# Check build history in Jenkins UI
```
#### Step 2: Categorize Error Types
Create a spreadsheet with these categories:
- **Temporary Files**: Debug scripts, test files left in repo
- **Missing Dependencies**: go.mod/package.json inconsistencies
- **Import/Module Issues**: Unused imports, incorrect paths
- **Test Infrastructure**: Missing fixtures, broken test setup
- **Code Quality**: Linting failures, formatting issues
- **Build Configuration**: Makefile, Dockerfile issues
- **Environment**: Version mismatches, missing tools
#### Step 3: Calculate Baseline Metrics
```bash
# Calculate your baseline V_instance
baseline_ci_failure_rate=$(echo "scale=2; failed_builds / total_builds" | bc)
baseline_avg_iterations="3.5" # Typical: 3-4 iterations per successful build
baseline_detection_time="480" # Typical: 5-10 minutes in CI
baseline_error_coverage="0.3" # Typical: 30% with basic linting
V_instance_baseline=$(echo "scale=3;
0.4 * (1 - $baseline_ci_failure_rate) +
0.3 * (1 - $baseline_avg_iterations/4) +
0.2 * (600/$baseline_detection_time) +
0.1 * $baseline_error_coverage" | bc)
echo "Baseline V_instance: $V_instance_baseline"
```
**Expected Baseline**: V_instance ≈ 0.4-0.6
#### Deliverables
- [ ] Error analysis spreadsheet
- [ ] Baseline metrics calculation
- [ ] Problem prioritization matrix
### Phase 2: P0 Critical Checks (Iteration 1)
**Duration**: 2-3 hours
**Objective**: Implement checks that prevent the most common errors
#### Step 1: Create P0 Check Scripts
**Script Template**:
```bash
#!/bin/bash
# check-[category].sh - [Purpose]
#
# Part of: Build Quality Gates
# Iteration: P0 (Critical Checks)
# Purpose: [What this check prevents]
# Historical Impact: [X% of historical errors]
set -euo pipefail
# Colors
RED='\033[0;31m'
YELLOW='\033[1;33m'
GREEN='\033[0;32m'
NC='\033[0m'
echo "Checking [category]..."
ERRORS=0
# ============================================================================
# Check [N]: [Specific check name]
# ============================================================================
echo " [N/total] Checking [specific pattern]..."
# Your check logic here
if [ condition ]; then
echo -e "${RED}❌ ERROR: [Description]${NC}"
echo "[Found items]"
echo ""
echo "Fix instructions:"
echo " 1. [Step 1]"
echo " 2. [Step 2]"
echo ""
((ERRORS++)) || true
fi
# ============================================================================
# Summary
# ============================================================================
if [ $ERRORS -eq 0 ]; then
echo -e "${GREEN}✅ All [category] checks passed${NC}"
exit 0
else
echo -e "${RED}❌ Found $ERRORS [category] issue(s)${NC}"
echo "Please fix before committing"
exit 1
fi
```
**Essential P0 Checks**:
1. **Temporary Files Detection** (`check-temp-files.sh`)
```bash
# Detect common patterns:
# - test_*.go, debug_*.go in root
# - editor temp files (*~, *.swp)
# - experiment files that shouldn't be committed
```
2. **Dependency Verification** (`check-deps.sh`)
```bash
# Verify:
# - go.mod/go.sum consistency
# - package-lock.json integrity
# - no missing dependencies
```
3. **Test Infrastructure** (`check-fixtures.sh`)
```bash
# Verify:
# - All referenced test fixtures exist
# - Test data files are available
# - Test database setup is correct
```
#### Step 2: Integrate with Build System
**Makefile Integration**:
```makefile
# P0: Critical checks (blocks commit)
check-workspace: check-temp-files check-fixtures check-deps
@echo "✅ Workspace validation passed"
check-temp-files:
@bash scripts/check-temp-files.sh
check-fixtures:
@bash scripts/check-fixtures.sh
check-deps:
@bash scripts/check-deps.sh
# Pre-commit workflow
pre-commit: check-workspace fmt lint test-short
@echo "✅ Pre-commit checks passed"
```
#### Step 3: Test Performance
```bash
# Time your P0 checks
time make check-workspace
# Target: <10 seconds for P0 checks
# If slower, consider parallel execution or optimization
```
**Expected Results**:
- V_instance improvement: +40-60%
- V_meta achievement: ≥0.80
- Error coverage: 50-70%
- Detection time: <10 seconds
### Phase 3: P1 Enhanced Checks (Iteration 2)
**Duration**: 2-3 hours
**Objective**: Add comprehensive quality assurance
#### Step 1: Add P1 Check Scripts
**Enhanced Checks**:
1. **Shell Script Quality** (`check-scripts.sh`)
```bash
# Use shellcheck to validate all shell scripts
# Find common issues: quoting, error handling, portability
```
2. **Debug Statement Detection** (`check-debug.sh`)
```bash
# Detect:
# - console.log/print statements
# - TODO/FIXME/HACK comments
# - Debugging code left in production
```
3. **Import/Module Quality** (`check-imports.sh`)
```bash
# Use language-specific tools:
# - goimports for Go
# - isort for Python
# - eslint --fix for JavaScript
```
#### Step 2: Create Comprehensive Workflow
**Enhanced Makefile**:
```makefile
# P1: Enhanced checks
check-scripts:
@bash scripts/check-scripts.sh
check-debug:
@bash scripts/check-debug.sh
check-imports:
@bash scripts/check-imports.sh
# Complete validation
check-workspace-full: check-workspace check-scripts check-debug check-imports
@echo "✅ Full workspace validation passed"
# CI workflow
ci: check-workspace-full test-all build-all
@echo "✅ CI-level validation passed"
```
#### Step 3: Performance Optimization
```bash
# Parallel execution example
check-parallel:
@make check-temp-files & \
make check-fixtures & \
make check-deps & \
wait
@echo "✅ Parallel checks completed"
```
**Expected Results**:
- V_instance: 0.75-0.85
- V_meta: 0.85-0.90
- Error coverage: 80-90%
- Detection time: 15-30 seconds
### Phase 4: P2 Optimization (Iteration 3)
**Duration**: 1-2 hours
**Objective**: Final optimization and advanced quality checks
#### Step 1: Add P2 Advanced Checks
**Advanced Quality Checks**:
1. **Language-Specific Quality** (`check-go-quality.sh` example)
```bash
# Comprehensive Go code quality:
# - go fmt (formatting)
# - goimports (import organization)
# - go vet (static analysis)
# - go mod verify (dependency integrity)
# - Build verification
```
2. **Security Scanning** (`check-security.sh`)
```bash
# Basic security checks:
# - gosec for Go
# - npm audit for Node.js
# - safety for Python
# - secrets detection
```
3. **Performance Regression** (`check-performance.sh`)
```bash
# Performance checks:
# - Benchmark regression detection
# - Bundle size monitoring
# - Memory usage validation
```
#### Step 2: Tool Chain Optimization
**Version Management**:
```bash
# Use version managers for consistency
# asdf for multiple tools
asdf install golangci-lint 1.64.8
asdf local golangci-lint 1.64.8
# Docker for isolated environments
FROM golang:1.21
RUN go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.64.8
```
#### Step 3: CI/CD Integration
**GitHub Actions Example**:
```yaml
name: Quality Gates
on: [push, pull_request]
jobs:
quality:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Setup tools
run: |
go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.64.8
go install golang.org/x/tools/cmd/goimports@latest
- name: Run quality gates
run: make ci
- name: Upload coverage
uses: codecov/codecov-action@v3
```
**Expected Final Results**:
- V_instance: ≥0.85 (target achieved)
- V_meta: ≥0.90 (excellent)
- Error coverage: ≥95%
- Detection time: <60 seconds
## Core Components
### Script Templates
#### 1. Standard Check Script Structure
All quality check scripts follow this consistent structure:
```bash
#!/bin/bash
# check-[category].sh - [One-line description]
#
# Part of: Build Quality Gates
# Iteration: [P0/P1/P2]
# Purpose: [What problems this prevents]
# Historical Impact: [X% of errors this catches]
set -euo pipefail
# Colors for consistent output
RED='\033[0;31m'
YELLOW='\033[1;33m'
GREEN='\033[0;32m'
BLUE='\033[0;34m'
NC='\033[0m'
echo "Checking [category]..."
ERRORS=0
WARNINGS=0
# ============================================================================
# Check 1: [Specific check name]
# ============================================================================
echo " [1/N] Checking [specific pattern]..."
# Your validation logic here
if [ condition ]; then
echo -e "${RED}❌ ERROR: [Clear problem description]${NC}"
echo "[Detailed explanation of what was found]"
echo ""
echo "To fix:"
echo " 1. [Specific action step]"
echo " 2. [Specific action step]"
echo " 3. [Verification step]"
echo ""
((ERRORS++)) || true
elif [ warning_condition ]; then
echo -e "${YELLOW}⚠️ WARNING: [Warning description]${NC}"
echo "[Optional improvement suggestion]"
echo ""
((WARNINGS++)) || true
else
echo -e "${GREEN}✓${NC} [Check passed]"
fi
# ============================================================================
# Continue with more checks...
# ============================================================================
# ============================================================================
# Summary
# ============================================================================
echo ""
if [ $ERRORS -eq 0 ]; then
if [ $WARNINGS -eq 0 ]; then
echo -e "${GREEN}✅ All [category] checks passed${NC}"
else
echo -e "${YELLOW}⚠️ All critical checks passed, $WARNINGS warning(s)${NC}"
fi
exit 0
else
echo -e "${RED}❌ Found $ERRORS [category] error(s), $WARNINGS warning(s)${NC}"
echo "Please fix errors before committing"
exit 1
fi
```
#### 2. Language-Specific Templates
**Go Project Template**:
```bash
# check-go-quality.sh - Comprehensive Go code quality
# Iteration: P2
# Covers: formatting, imports, static analysis, dependencies, compilation
echo " [1/5] Checking code formatting (go fmt)..."
if ! go fmt ./... >/dev/null 2>&1; then
echo -e "${RED}❌ ERROR: Code formatting issues found${NC}"
echo "Run: go fmt ./..."
((ERRORS++))
else
echo -e "${GREEN}✓${NC} Code formatting is correct"
fi
echo " [2/5] Checking import formatting (goimports)..."
if ! command -v goimports >/dev/null; then
echo -e "${YELLOW}⚠️ goimports not installed, skipping import check${NC}"
else
if ! goimports -l . | grep -q .; then
echo -e "${GREEN}✓${NC} Import formatting is correct"
else
echo -e "${RED}❌ ERROR: Import formatting issues${NC}"
echo "Run: goimports -w ."
((ERRORS++))
fi
fi
```
**Python Project Template**:
```bash
# check-python-quality.sh - Python code quality
# Uses: black, isort, flake8, mypy
echo " [1/4] Checking code formatting (black)..."
if ! black --check . >/dev/null 2>&1; then
echo -e "${RED}❌ ERROR: Code formatting issues${NC}"
echo "Run: black ."
((ERRORS++))
fi
echo " [2/4] Checking import sorting (isort)..."
if ! isort --check-only . >/dev/null 2>&1; then
echo -e "${RED}❌ ERROR: Import sorting issues${NC}"
echo "Run: isort ."
((ERRORS++))
fi
```
### Makefile Integration Patterns
#### 1. Three-Layer Architecture
```makefile
# =============================================================================
# Build Quality Gates - Three-Layer Architecture
# =============================================================================
# P0: Critical checks (must pass before commit)
# Target: <10 seconds, 50-70% error coverage
check-workspace: check-temp-files check-fixtures check-deps
@echo "✅ Workspace validation passed"
# P1: Enhanced checks (quality assurance)
# Target: <30 seconds, 80-90% error coverage
check-quality: check-workspace check-scripts check-imports check-debug
@echo "✅ Quality validation passed"
# P2: Advanced checks (comprehensive validation)
# Target: <60 seconds, 95%+ error coverage
check-full: check-quality check-security check-performance
@echo "✅ Comprehensive validation passed"
# =============================================================================
# Workflow Targets
# =============================================================================
# Development iteration (fastest)
dev: fmt build
@echo "✅ Development build complete"
# Pre-commit validation (recommended)
pre-commit: check-workspace test-short
@echo "✅ Pre-commit checks passed"
# Full validation (before important commits)
all: check-quality test-full build-all
@echo "✅ Full validation passed"
# CI-level validation
ci: check-full test-all build-all verify
@echo "✅ CI validation passed"
```
#### 2. Performance Optimizations
```makefile
# Parallel execution for independent checks
check-parallel:
@make check-temp-files & \
make check-fixtures & \
make check-deps & \
wait
@echo "✅ Parallel checks completed"
# Incremental checks (only changed files)
check-incremental:
@if [ -n "$(git status --porcelain)" ]; then \
CHANGED=$(git diff --name-only --cached); \
echo "Checking changed files: $CHANGED"; \
# Run checks only on changed files
else
$(MAKE) check-workspace
fi
# Conditional checks (skip slow checks for dev)
check-fast:
@$(MAKE) check-temp-files check-deps
@echo "✅ Fast checks completed"
```
### Configuration Management
#### 1. Tool Configuration Files
**golangci.yml**:
```yaml
run:
timeout: 5m
tests: true
linters-settings:
goimports:
local-prefixes: github.com/yale/h
govet:
check-shadowing: true
golint:
min-confidence: 0.8
linters:
enable:
- goimports
- govet
- golint
- ineffassign
- misspell
- unconvert
- unparam
- nakedret
- prealloc
- scopelint
- gocritic
```
**pyproject.toml**:
```toml
[tool.black]
line-length = 88
target-version = ['py38']
[tool.isort]
profile = "black"
multi_line_output = 3
[tool.mypy]
python_version = "3.8"
warn_return_any = true
warn_unused_configs = true
```
#### 2. Version Consistency
**.tool-versions** (for asdf):
```
golangci-lint 1.64.8
golang 1.21.0
nodejs 18.17.0
python 3.11.4
```
**Dockerfile**:
```dockerfile
FROM golang:1.21.0-alpine AS builder
RUN go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.64.8
RUN go install golang.org/x/tools/cmd/goimports@latest
```
### CI/CD Workflow Integration
#### 1. GitHub Actions Integration
```yaml
name: Quality Gates
on:
push:
branches: [main, develop]
pull_request:
branches: [main]
jobs:
quality-check:
runs-on: ubuntu-latest
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Setup Go
uses: actions/setup-go@v4
with:
go-version: '1.21'
- name: Cache Go modules
uses: actions/cache@v3
with:
path: ~/go/pkg/mod
key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
- name: Install tools
run: |
go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.64.8
go install golang.org/x/tools/cmd/goimports@latest
- name: Run quality gates
run: make ci
- name: Upload coverage reports
uses: codecov/codecov-action@v3
with:
file: ./coverage.out
```
#### 2. GitLab CI Integration
```yaml
quality-gates:
stage: test
image: golang:1.21
cache:
paths:
- .go/pkg/mod/
before_script:
- go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.64.8
- go install golang.org/x/tools/cmd/goimports@latest
script:
- make ci
artifacts:
reports:
junit: test-results.xml
coverage_report:
coverage_format: cobertura
path: coverage.xml
only:
- merge_requests
- main
- develop
```
## Quality Framework
### Dual-Layer Value Functions
The BAIME framework uses dual-layer value functions to measure both instance quality and methodology quality.
#### V_instance (Instance Quality)
Measures the quality of your specific implementation:
```
V_instance = 0.4 × (1 - CI_failure_rate)
+ 0.3 × (1 - avg_iterations/baseline_iterations)
+ 0.2 × min(baseline_time/actual_time, 10)/10
+ 0.1 × error_coverage_rate
```
**Component Breakdown**:
- **40% - CI Success Rate**: Most direct user impact
- **30% - Iteration Efficienc