Security & Testing Claude 스킬

Systematic Debugging Framework

Implements a rigorous four-phase scientific framework to identify root causes and eliminate trial-and-error patching.

Systematic Type Migration

Orchestrates safe, incremental refactoring of legacy types into new type-safe implementations through a test-first workflow.

TDD Enforcement Algorithm

Enforces strict test-first development through a deterministic algorithmic decision tree that eliminates rationalizations for skipping tests.

Verification Stack

Implements automated verification pipelines to ensure code quality through testing, linting, and type checking before completing tasks.

Root Cause Tracing

Identifies the fundamental source of software bugs by systematically tracing execution backward through the call stack and implementing strategic instrumentation.

Vitest Test Runner

Facilitates fast unit testing and mocking within Vite-powered projects using a Jest-compatible API.

Systematic Feature Troubleshooting

Automates a methodical, hypothesis-driven debugging workflow to identify root causes and implement verified fixes for software bugs.

Feature Ship Workflow

Automates feature completion with rigorous quality gates including security audits, QA validation, and standardized documentation.

Auditing Context Manager

Synchronizes Claude's awareness with active code audits and runtime injections to prevent accidental overrides and improve debugging accuracy.

Condition-Based Waiting for Tests

Eliminates flaky tests and race conditions by replacing arbitrary timeouts with intelligent condition polling.

Verification Before Completion

Enforces a mandatory verification protocol requiring empirical evidence before claiming task completion or success.

Test-Driven Development (TDD)

Enforces a strict Red-Green-Refactor workflow to ensure high-quality code through mandatory test-first implementation.

Testing Anti-Patterns Guard

Enforces robust software testing standards by identifying and preventing brittle mocks, production code pollution, and incomplete test data structures.

Systematic Debugging

Enforces a disciplined four-phase root cause analysis process to eliminate guess-and-check troubleshooting and recurring software bugs.

Verification Before Completion

Enforces a rigorous verification workflow requiring command-based evidence before any task is marked as complete or successful.

Defense-in-Depth Validation

Implements multi-layered data validation patterns to make bugs structurally impossible across every architectural level.

MERN Code Reviewer

Performs comprehensive security, performance, and architecture audits for MongoDB, Express, React, and Node.js projects.

Foundry Smart Contract Testing

Streamlines the creation of robust Foundry-based test suites and deployment scripts for Solidity smart contracts.

Test-Driven Development (TDD)

Enforces a strict Red-Green-Refactor workflow to ensure all code is verified by failing tests before implementation.

React Component Test Manager

Automates the creation and updating of Vitest test files for React components with a focus on logic, isolation, and prop validation.

Async Testing Expert

Master asynchronous Python testing using pytest with production-grade patterns for FastAPI and database interactions.

Build & Error Recovery Specialist

Automates build verification, error recovery, and the application of code review feedback using LSP-enhanced diagnostics.

Web Application Testing

Automates local web application testing and UI debugging using Playwright and managed server lifecycles.

Defense-in-Depth Validation

Implements multi-layered data validation patterns to prevent bugs and failures from propagating through system boundaries.

Security Patterns & OWASP Best Practices

Implements secure coding standards and OWASP-aligned patterns to protect applications from vulnerabilities like SQL injection, XSS, and broken authentication.

Python pytest Patterns

Implements modern pytest patterns for robust Python unit, integration, and asynchronous testing.

QA Hardening & Production Readiness

Hardens codebases by orchestrating a specialized multi-agent team to perform security, error, and testing audits for production readiness.

Gherkin Acceptance Criteria

Generates structured Gherkin acceptance criteria using Given-When-Then syntax for testable requirements and user stories.

Expert Team Consultation

Provides multi-perspective code, architecture, and security reviews using a specialized team of four AI agents.

OpenSpec Change Verifier

Validates code implementations against project specifications, tasks, and design documents to ensure full alignment before archiving.