shift-left-testing
🎯Skillfrom proffesor-for-testing/agentic-qe
|Accelerates software quality by moving testing earlier in development, reducing defect costs through proactive validation, automated testing, and continuous improvement practices.
Installation
npx skills add https://github.com/proffesor-for-testing/agentic-qe --skill shift-left-testingSkill Details
"Move testing activities earlier in the development lifecycle to catch defects when they're cheapest to fix. Use when implementing TDD, CI/CD, or early quality practices."
Overview
# Shift-Left Testing
When implementing early testing practices:
- VALIDATE requirements before coding (testability, BDD scenarios)
- WRITE tests before implementation (TDD red-green-refactor)
- AUTOMATE in CI pipeline (every commit triggers tests)
- FOLLOW test pyramid: Many unit (70%), some integration (20%), few E2E (10%)
- FIX defects immediately - never let them accumulate
Quick Shift-Left Levels:
- Level 1: Unit tests with each PR (developer responsibility)
- Level 2: TDD practice (tests before code)
- Level 3: BDD/Example mapping in refinement (requirements testing)
- Level 4: Risk analysis in design (architecture testing)
Critical Success Factors:
- Defects found in requirements cost 1x; in production cost 100x
- Every commit must run automated tests
- Quality is built in, not tested in
Quick Reference Card
When to Use
- Reducing cost of defects
- Implementing CI/CD pipelines
- Starting TDD practice
- Improving requirements quality
Cost of Defects by Phase
| Phase | Relative Cost | Example |
|-------|--------------|---------|
| Requirements | 1x | Fix doc: 30 min |
| Design | 5x | Redesign: few hours |
| Development | 10x | Code fix: 1 day |
| Testing | 20x | Fix + retest: 2 days |
| Production | 100x | Hotfix + rollback + investigation |
Test Pyramid
```
/\ E2E (10%) - Critical user journeys
/ \
/ \ Integration (20%) - Component interactions
/ \
/________\ Unit (70%) - Fast, isolated, comprehensive
```
Shift-Left Levels
| Level | Practice | When |
|-------|----------|------|
| 1 | Unit tests in PR | Before merge |
| 2 | TDD | Before implementation |
| 3 | BDD/Example Mapping | During refinement |
| 4 | Risk Analysis | During design |
---
Level 1: Tests in Every PR
```yaml
# CI pipeline - tests run on every commit
name: CI
on: [push, pull_request]
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- run: npm ci
- run: npm run test:unit
- run: npm run test:integration
- run: npm run lint
quality-gate:
needs: test
steps:
- name: Coverage Check
run: npx coverage-check --min 80
- name: No New Warnings
run: npm run lint -- --max-warnings 0
```
---
Level 2: TDD Practice
```javascript
// Red: Write failing test first
test('calculates discount for orders over $100', () => {
const order = new Order([{ price: 150 }]);
expect(order.discount).toBe(15); // 10% off
});
// Green: Minimal implementation
class Order {
get discount() {
return this.total > 100 ? this.total * 0.1 : 0;
}
}
// Refactor: Improve while keeping green
```
---
Level 3: BDD in Refinement
```gherkin
# Example mapping before coding
Feature: Loyalty Discount
Scenario: Gold member gets 15% discount
Given a customer with "gold" membership
When they checkout with $200 in cart
Then discount applied is $30
And order total is $170
Scenario: New customer gets no discount
Given a customer with no membership
When they checkout with $200 in cart
Then no discount is applied
```
---
Level 4: Risk Analysis in Design
```typescript
// During architecture review
await Task("Risk Analysis", {
phase: 'design',
component: 'payment-service',
questions: [
'What happens when payment gateway times out?',
'How do we handle duplicate submissions?',
'What if inventory changed during checkout?'
]
}, "qe-requirements-validator");
// Output: Testability requirements, failure mode tests
```
---
Agent-Assisted Shift-Left
```typescript
// Validate requirements testability
await Task("Requirements Validation", {
requirements: userStories,
check: ['INVEST-criteria', 'testability', 'ambiguity'],
generateBDD: true
}, "qe-requirements-validator");
// Generate tests from requirements
await Task("Generate Tests", {
source: 'requirements',
types: ['unit', 'integration', 'e2e'],
coverage: 'comprehensive'
}, "qe-test-generator");
// Smart test selection for changes
await Task("Select Regression Tests", {
changedFiles: prFiles,
algorithm: 'risk-based',
targetReduction: 0.7 // 70% time savings
}, "qe-regression-risk-analyzer");
```
---
Agent Coordination Hints
Memory Namespace
```
aqe/shift-left/
├── requirements/* - Validated requirements
├── generated-tests/* - Auto-generated tests
├── coverage-targets/* - Coverage goals by component
└── pipeline-results/* - CI/CD test history
```
Fleet Coordination
```typescript
const shiftLeftFleet = await FleetManager.coordinate({
strategy: 'shift-left',
agents: [
'qe-requirements-validator', // Level 3-4
'qe-test-generator', // Level 2
'qe-regression-risk-analyzer' // Smart selection
],
topology: 'sequential'
});
```
---
Related Skills
- [tdd-london-chicago](../tdd-london-chicago/) - TDD practices
- [holistic-testing-pact](../holistic-testing-pact/) - Proactive testing
- [cicd-pipeline-qe-orchestrator](../cicd-pipeline-qe-orchestrator/) - Pipeline integration
- [shift-right-testing](../shift-right-testing/) - Production feedback
---
Remember
Earlier = Cheaper. Requirements defects cost 1x; production defects cost 100x. Test pyramid: 70% unit, 20% integration, 10% E2E. Every commit runs tests. TDD builds quality in.
With Agents: Agents validate requirements testability, generate tests from specs, and select optimal regression suites. Use agents to implement shift-left practices consistently.
More from this repository10
Automates security vulnerability scanning and penetration testing for n8n workflows, identifying potential risks and misconfigurations.
Validates database schemas, tests data integrity, verifies migrations, checks transaction isolation, and measures query performance.
Delivers unvarnished technical criticism with surgical precision, combining expert-level BS detection and zero-tolerance for low-quality work.
n8n-expression-testing skill from proffesor-for-testing/agentic-qe
Validates n8n workflow triggers by comprehensively testing webhook, schedule, polling, and event-driven mechanisms with robust payload and authentication checks.
Validates n8n integration connectivity, authentication flows, and error handling across external service APIs through comprehensive testing patterns.
Applies Six Thinking Hats methodology to systematically analyze software testing challenges from multiple perspectives, enhancing decision-making and test strategy development.
Provisions and manages consistent, cost-effective test environments using Docker, Kubernetes, and infrastructure as code for reliable software testing.
Prioritizes testing efforts by systematically assessing and ranking risks based on probability and potential impact across software components.
context-driven-testing skill from proffesor-for-testing/agentic-qe