Results for “tdd”

Kotlin testing patterns with Kotest, MockK, coroutine testing, property-based testing, and Kover coverage. Follows TDD methodology with idiomatic Kotlin practices.

Test-driven development for Spring Boot using JUnit 5, Mockito, MockMvc, Testcontainers, and JaCoCo. Use when adding features, fixing bugs, or refactoring.

Test-driven development for Spring Boot using JUnit 5, Mockito, MockMvc, Testcontainers, and JaCoCo. Use when adding features, fixing bugs, or refactoring.

Test-driven development for Spring Boot using JUnit 5, Mockito, MockMvc, Testcontainers, and JaCoCo. Use when adding features, fixing bugs, or refactoring.

Provides 89 standard operating procedures for the Galyarder department, covering agent adapters, execution protocols, and multi-agent hygiene.

Executes a written implementation plan task-by-task with verification, review checkpoints, and sub-skill handoffs.

Guides test-first development with vertical slices, one test at a time, and refactoring after green.

Generate red-phase acceptance test scaffolds using the TDD cycle. Use when the user says "lets write acceptance tests" or "I want to do ATDD"

Generates new agent skills when a capability gap is identified, checking for duplicates first and validating quality before deployment.

Writes and maintains C++ tests with GoogleTest/GoogleMock, configures CMake/CTest, diagnoses failures, and adds coverage or sanitizers.

AL test development patterns for Business Central. Use when creating test codeunits, writing Given/When/Then test procedures, using Library Assert, configuring test projects, or implementing TDD workflows.

Guides test-first development with vertical slices, writing one behavior test at a time and refactoring only when green.

Implements SDD change tasks from specs and design, enforcing workload budgets, supporting chain strategies, and merging apply-progress across batches.

Guides backend development across API design, authentication, security, performance, architecture, and testing, with decision guides and defaults for production-ready systems.

Guides implementing features and bug fixes test-first, enforcing the red-green-refactor cycle with mandatory failure verification.

Guides writing a failing test before production code, iterating through red-green-refactor cycles, and fixing bugs test-first.

Verifies test effectiveness by introducing small bugs into production code and running the test suite to find weak or missing tests.

Runs a test-driven rendering loop for Copier templates, writing E2E assertions first and iterating until every flavor renders cleanly before committing.

Creates agent company packages that conform to the Agent Companies specification, either from scratch or by analyzing an existing repository.

Provides a workflow for writing, updating, and fixing C++ tests with GoogleTest/GoogleMock, configuring CMake/CTest, diagnosing failures, and adding coverage or sanitizers.

Consolidates 89 high-integrity SOPs for the Full department of the Galyarder Framework, covering adapter creation, execution protocols, and multi-agent hygiene.

Provides a Flutter testing strategy covering unit, widget, integration, and BLoC tests with code examples, dependencies, and coverage commands.

Provides comprehensive testing patterns for Perl applications using Test2::V0, Test::More, prove runner, mocking, and coverage analysis with Devel::Cover.

Drive development with tests by writing a failing test before implementing code, and reproduce bugs with tests before fixing them.

Enforces test-driven development with 80%+ coverage including unit, integration, and E2E tests for new features, bug fixes, or refactoring.

Implements features and writes code based on Plans.md tasks, with quality gates and routing to sub-skills for feature implementation and test writing.

Implements code features phase by phase from a JSON or Markdown plan, with configurable unit-test and quality-gate choices, token-budgeted execution, and resumable state.

Runs a complete quality engineering audit on any codebase, deriving behavioral requirements, generating spec-traced tests, performing multi-pass code review, and producing a consolidated bug report with verified patches.

BDD-driven test implementation: red-green loop mechanics, seams, mocking, and test quality under BDD Automation. Use when the user wants to write or improve tests during BDD implementation, needs guidance on test structure, or asks about test seams, mocking, or anti-patterns.

Triage a bug or issue by exploring the codebase to find root cause, then create a GitHub issue with a TDD-based fix plan. Use when user reports a bug, wants to file an issue, mentions "triage", or wants to investigate and plan a fix for a problem.

Red-green-refactor test-driven development discipline — write a failing test at the public interface first, minimal code to pass it, one slice at a time. Use when writing new logic or fixing a bug (write the regression test first), for any code where correctness matters more than raw speed.

Break a trusted implementation plan (or other provided context) into independently-grabbable, atomic work items, written to a single work-items.md file. Use when the user wants to convert a plan into work items, create implementation tickets or tasks, divide a plan into work units, or break the plan down into grabbable pieces. Do not use when there is no implementation plan yet or the plan is not yet trusted — use plan-implementation to produce the plan or iterative-plan-review to harden it first. Does not sequence work into demoable delivery phases — use plan-a-phased-build for that. Does not write code — use tdd to implement a work item.

Produce a plain-language manual test plan from the context supplied to it — an executive summary, a high-level list of named tests, and a detail section per test with the steps a person follows by hand and the outcomes they should expect. Use when you want to create, draft, generate, or outline a manual test plan, manual QA steps, hands-on verification steps, or an acceptance walkthrough for a feature, change, branch, plan, or PR. When the plan holds more than five tests and at least two natural categories emerge, both the test list and the detail sections are organized under plain-language categories. When nothing in the supplied context can be manually tested, it says so and asks for more context instead of producing a document. Does not analyze code for automated test coverage gaps — use automated-test-planning. Does not write test code — use tdd. Does not review code quality — use code-review. Does not stress-test an existing plan — use iterative-plan-review.