wojons

Build and orchestrate AI-driven development workflows (Ralph loops) that iterate until success using configurable patterns and multi-agent coordination

Validate true completion vs superficial "done" - ensure code is wired up, tested, and production-ready using multilingual completion semantics

Map dependencies and relationships between different test types

Select appropriate testing level based on project stage

Use when you need to analyze and optimize cloud costs across multiple cloud providers (AWS, Azure, GCP)

Implement distributed tracing using logs, including trace context propagation, span logging, correlation IDs, and OpenTelemetry integration for observability

Write exhaustive specifications for autonomous AI systems that leave nothing to chance, covering every detail from UI to database schemas with adversarial refinement

Verify command behavior and side effects against expected outcomes, not just exit codes - catch the "exit 0 but actually broken" cases

Manage federated specification files merged into NotebookLM notebooks for token-efficient context access, human learning materials, deep dive analysis, and on-demand research

Run comprehensive non-functional test suite

Optimize logging performance including overhead reduction, async logging, buffering, sampling, and performance impact analysis for high-throughput systems

Use when you need comprehensive accessibility auditing including WCAG compliance, legal requirements mapping, and user testing with disabilities

Analyze project documentation to identify missing context, then generate and store best practice guides using web search when available

Design and document comprehensive data flow architectures across systems, services, networks, databases, and protocols using systematic methodology

Run integration tests for component interactions

Test application performance and load handling

Apply systematic adversarial thinking patterns including devil's advocate, assumption busting, red teaming, and white hat security approaches

Parse, analyze, search, and extract insights from logs using various techniques including regex, parsing engines, and log analysis tools

Implement proper logging practices including log levels, structured logging, context propagation, and logging best practices for applications and systems

Use when you need to optimize database performance, schema design, indexing, and query performance across different database systems

Implement comprehensive log management including rotation, retention, forwarding, aggregation, storage, and lifecycle management

Use logs as part of comprehensive observability strategy including metrics, traces, alerts, and dashboards for system understanding and operational excellence

Analyze system and application performance using Linux kernel-level tools (perf, ftrace, eBPF, SystemTap) and application-level profiling to identify bottlenecks and optimize performance

Test application accessibility compliance

Test application compatibility across browsers, devices, and platforms

Use when you need to manage incidents and conduct post-mortem analysis to improve system reliability and security

Enterprise-grade AI-driven development workflow engine with steering packet architecture for real-time control, plugin system, agent orchestration, monitoring, and complex workflow patterns. Build-verify loops that iterate until success.

Analyze gaps between formal specifications (API specs, interface specs, architecture specs) and actual implementations with specialized support for structured specification formats

Analyze gaps between requirements/features that should be tested and actual test coverage, identifying testing deficiencies and prioritizing test improvements

Orchestrate and coordinate different test types in proper order

Understand the complete testing ecosystem and relationships between test types

Testing strategy for Minimum Viable Product

Testing strategy for Proof of Concept projects

Test application usability and user experience

Identify, document, and explicitly test assumptions rather than leaving them implicit and untested

Analyze and safely upgrade dependencies with breaking change detection, version compatibility checks, impact analysis, and migration planning

Compare system behavior against real-world expectations and domain knowledge rather than just technical specifications

Apply Sherlock Holmes' deductive method to debug code, diagnose system issues, and solve technical puzzles using systematic elimination and logical reasoning

Run regression tests to ensure new changes don't break existing functionality

Maintain directory organization with index files (_index.md/_index.yaml/_index.json) and consistency prompts (_prompt.md)

Think and act like an attacker to identify security vulnerabilities, weaknesses, and penetration vectors through adversarial security testing

Build defensive security capabilities, implement security by design, and practice ethical hacking to protect systems proactively

Core operational directive for incremental development using the Baby Steps Methodology - break work into smallest possible meaningful changes with validation at every step

Use when you need to test and validate the skills repository using the skills system itself, practicing "eating your own dog food"

Create consistent releases and changelogs

Run end-to-end tests for complete user workflows

Pack codebases, folders, or ZIP archives into LLM-friendly context format with smart filtering, file selection, and markdown structure

Identify discrepancies between documented requirements and actual implementation through systematic comparison and analysis

Review React components for best practices and performance issues

Run unit tests for individual code components

A 10-step methodology for building software with AI collaboration - from north star through automated Ralph loop execution with zero human-in-the-loop code writing

Use when you need comprehensive security scanning across applications, infrastructure, and dependencies with LLM-based analysis

Build basic to intermediate Agent Skills using structured templates and validation tools

Measure and report test coverage across all test types

Create comprehensive test plans considering all test types and dependencies

Run chaos engineering tests to build resilient systems

Run smoke tests to verify basic application functionality

Deploy applications to Vercel with automatic framework detection

Guide framework and library migrations with incremental strategies, breaking change analysis, compatibility testing, and automated migration tools

Use when you need to validate data quality, types, schemas, and consistency across systems

Challenge ideas, assumptions, and decisions by playing devil's advocate to identify weaknesses and prevent groupthink

Configure OpenCode settings using JSON or Markdown files for project-specific or global preferences

Verify every step exhaustively - debug with detailed tracing and test each component individually to leave no stone unturned

Test database interactions, schemas, and data integrity

Test application security vulnerabilities

Verify system claims and test results through independent validation rather than trusting assumptions

Use when you need to generate comprehensive API documentation for REST/HTTP, gRPC, GraphQL, and RPC APIs

Aggressively challenge and attempt to disprove assumptions through counterexamples, edge cases, and adversarial thinking