TDD & BDD

Understands TDD fundamentals in Java: red-green-refactor cycle with JUnit 5, basic assertions, and test lifecycle annotations. Writes simple unit tests for Java classes. Follows team BDD practices using Cucumber for acceptance tests with Gherkin syntax.

Understands TDD fundamentals in Node.js: red-green-refactor cycle with Jest/Vitest, describe/it blocks, and assertion matchers. Writes basic unit tests for JavaScript/TypeScript functions. Follows team BDD practices for writing feature specs with Cucumber.js.

Understands the red-green-refactor principle. Writes tests before code for simple functions. Familiar with BDD approach: describing behavior via Given-When-Then. Follows team testing guidelines.

Understands TDD concept (red-green-refactor). Writes tests before code for simple functions. Knows about BDD and Given-When-Then format. Uses descriptive test names.

Practices TDD in Rust: red-green-refactor with cargo test, doc tests. Writes tests before implementation for simple functions.

Practices TDD in Scala: red-green-refactor with ScalaTest/MUnit, property-based testing through ScalaCheck. Writes tests before implementation.

Knows basic TDD/BDD concepts for compiler engineering and can apply them in common tasks. Uses standard tools and follows established team practices. Understands when and why this approach is used.

Understands TDD principles for embedded: red-green-refactor, test-first for firmware modules. Writes tests before implementing simple functions.

Practices TDD for fullstack: Jest for frontend, pytest/jest for backend. Writes tests before implementation.

Understands TDD/BDD fundamentals for game testing: writing test scenarios in Given/When/Then format, basic unit test concepts for game logic, and test-first approach for deterministic game systems. Follows team guidelines for BDD scenarios in gameplay feature testing.

Understands TDD fundamentals for language tools: test-first development for parser rules, grammar test cases, and AST transformation verification. Writes basic tests for lexer/parser outputs. Follows team BDD practices for language feature specification testing.

Understands TDD/BDD fundamentals: red-green-refactor cycle, Given/When/Then scenario format, and test pyramid concept. Writes basic BDD scenarios in Gherkin syntax. Implements step definitions connecting BDD scenarios to automation code. Follows team testing standards and conventions.

Understands BDD fundamentals: Given/When/Then scenario structure, behavior-driven test case design, and collaboration between QA and developers on test specifications. Writes clear BDD scenarios in Gherkin that serve as both documentation and test cases. Follows team conventions for scenario organization.

Understands TDD/BDD fundamentals applied to security testing: writing security test scenarios in BDD format, test-first approach for security validations, and security acceptance criteria in Gherkin. Follows team practices for automated security test specifications.

Understands TDD fundamentals for smart contracts: test-first development with Hardhat/Foundry, basic assertion patterns for contract state verification, and gas usage testing. Writes simple tests for contract functions. Follows team BDD practices for describing contract behavior specifications.

Practices TDD in Java: red-green-refactor cycle, test-first for business logic. Writes BDD scenarios with Cucumber: Given-When-Then for acceptance criteria. Uses Mockito for dependency isolation.

Applies TDD for Node.js: red-green-refactor cycle for business logic, Jest test-first. Writes BDD scenarios via Cucumber.js for acceptance tests.

Practices TDD for business logic: domain services, value objects, use cases. Writes BDD scenarios for acceptance tests. Applies TDD when refactoring legacy code. Teaches juniors the approach.

Practices TDD for business logic. Uses BDD with behave or pytest-bdd. Writes acceptance criteria in Gherkin. Applies TDD during refactoring.

Applies TDD for Rust: property-based testing through proptest, test-driven trait design, integration test modules. Uses test fixtures.

Applies TDD/BDD: ScalaTest FlatSpec/WordSpec for BDD-style, property-based testing for domain logic, test-driven Akka actor design.

Confidently applies TDD/BDD for compiler engineering in non-standard tasks. Independently selects optimal approach and tools. Analyzes trade-offs and suggests improvements to existing solutions.

Applies TDD for embedded development: dual-target testing (host + target), hardware abstraction for testability, BDD acceptance criteria for firmware features.

Applies TDD/BDD: React Testing Library with TDD, backend test-driven design, Cypress BDD scenarios.

Applies TDD/BDD for game feature testing: writes comprehensive BDD scenarios for gameplay mechanics, implements automated tests for game balance and progression systems, and uses property-based testing for randomized game elements. Integrates BDD scenarios with game CI pipelines. Covers edge cases in multiplayer interactions and state transitions.

Applies TDD for language tool development: test-driven parser rule implementation, comprehensive grammar test suites with edge cases, and BDD scenarios for language feature specifications. Uses snapshot testing for AST/IR outputs. Implements test fixtures for complex language constructs. Integrates language conformance tests into CI.

Independently implements TDD/BDD in automation projects: designs BDD scenario libraries with reusable step definitions, implements data-driven BDD scenarios for comprehensive coverage, and applies test design techniques (equivalence partitioning, boundary values) within BDD framework. Integrates BDD test reports into CI/CD dashboards.

Independently writes comprehensive BDD scenarios: complex multi-step workflows with scenario outlines, data-driven scenarios for parameterized testing, and background sections for shared preconditions. Collaborates with developers to align BDD scenarios with implementation. Reviews BDD scenarios from team members for clarity and completeness.

Applies BDD for security requirements: Gherkin scenarios for authentication, authorization rules, compliance requirements. TDD for security utility functions.

Applies TDD for smart contract development: test-driven implementation of contract functions with comprehensive state verification, fuzz testing for edge cases, and BDD scenarios for complex DeFi workflows. Implements fork testing against mainnet state. Uses test coverage tools to ensure complete branch coverage of contract logic.

Introduces TDD/BDD culture in Java project: outside-in TDD for domain layer, Cucumber + Spring for integration scenarios. Designs testable architecture: ports and adapters, dependency injection. Mentors on testing practices.

Designs TDD/BDD workflow: test-first for domain logic, outside-in TDD for API endpoints, BDD for user-facing features. Trains team on TDD practices.

Defines testing strategy: testing pyramid, when TDD is mandatory vs when excessive. Designs BDD framework for the team. Integrates acceptance tests in CI with isolated environment.

Designs testable architecture. Applies TDD for API design. Uses BDD for collaboration with product. Trains the team on TDD.

Designs TDD approach: type-driven TDD (compiler-guided development), property-based testing strategy, contract-driven interop.

Designs TDD/BDD approach: type-driven TDD, property-based testing strategy, contract-driven development between services.

Expertly applies TDD/BDD for compiler engineering in designing complex systems. Optimizes existing solutions and prevents architectural mistakes. Conducts code reviews and trains colleagues on best practices.

Introduces TDD for firmware: dual-target development (host + MCU), test-driven HAL design, BDD for device acceptance criteria.

Designs TDD/BDD approach: end-to-end TDD workflow, BDD for feature specs, contract-driven development.

Designs testing strategy for game projects using TDD/BDD: automated test pyramids for game systems, BDD-driven acceptance testing for game features, and property-based testing for procedural content. Implements testing infrastructure for multiplayer simulation and load testing. Optimizes test execution for fast feedback in game CI. Mentors team on test-driven game development practices.

Designs testing architecture for language tooling platform: conformance test suites for language specification, fuzz testing for parser robustness, and BDD-driven feature acceptance. Implements golden file testing for code generation and formatting. Creates testing infrastructure for cross-platform language tool validation. Mentors team on test-driven compiler/LSP development.

Designs BDD/TDD testing strategy for the product: BDD frameworks selection and configuration, living documentation from BDD scenarios, and shift-left testing culture implementation. Creates reusable BDD step libraries and domain-specific testing DSLs. Optimizes test pyramid balance between unit, integration, and acceptance tests. Mentors team on advanced BDD patterns and test architecture.

Designs BDD strategy for product quality assurance: living documentation systems from BDD scenarios, behavior-driven requirement specification, and three amigos sessions facilitation. Creates BDD style guides and review processes. Implements traceability between BDD scenarios, requirements, and defects. Mentors team on effective BDD scenario writing and domain modeling.

Designs BDD approach for security: security acceptance criteria templates, automated compliance scenarios, integration with threat models. Implements security behavior specifications.

Designs testing architecture for smart contract platforms: formal verification integration with TDD workflows, invariant testing for protocol safety properties, and BDD-driven security audit preparation. Implements mutation testing for contract test suite quality assessment. Creates testing frameworks for cross-chain contract interactions. Mentors team on test-driven smart contract security.

Defines team testing strategy: test pyramid (unit → integration → E2E), coverage targets, BDD for acceptance criteria. Implements automated quality gates. Balances development speed and coverage.

Defines testing strategy: when TDD is mandatory (domain logic), BDD for acceptance. Implements testing culture. Balances coverage and delivery speed.

Shapes testing culture in the team: code review with test focus, coverage goals, TDD workshops. Balances development speed and test coverage.

Introduces TDD/BDD culture in the organization. Creates guidelines. Evaluates TDD ROI. Integrates BDD into product development process.

Implements TDD culture: mandatory test-first for critical paths, quality metrics, testing best practices. Trains the team.

Implements TDD/BDD culture: mandatory test-first for critical paths, testing metrics, quality standards. Trains team.

Establishes TDD/BDD standards for the compiler engineering team and makes architectural decisions. Defines technical roadmap considering this skill. Mentors senior engineers and influences practices of adjacent teams.

Defines TDD/BDD strategy for the embedded team. Establishes dual-target workflow, BDD acceptance criteria templates.

Implements TDD/BDD culture: mandatory test-first for critical paths, quality metrics, best practices.

Defines testing strategy at product level. Establishes quality assurance standards. Implements shift-left testing culture.

Defines testing strategy for language tooling platform: conformance testing standards, performance regression testing requirements, and cross-platform validation processes. Establishes BDD practices for language feature specification and acceptance. Drives adoption of test-driven development culture in language tooling teams.

Defines testing strategy at the product level: BDD/TDD standards, quality assurance metrics, and shift-left testing culture across teams. Establishes BDD scenario libraries as living documentation for product behavior. Drives adoption of behavior-driven development as a collaboration tool between business, QA, and development. Creates testing COE (center of excellence) practices.

Defines TDD/BDD strategy at the team/product level. Establishes behavior-driven development standards. Conducts reviews and fosters test-first culture.

Defines BDD standards for security: scenario templates for OWASP categories, review process, documentation-as-tests. Implements security story mapping.

Defines testing strategy at product level. Establishes quality assurance standards. Introduces shift-left testing culture.

Shapes organizational testing culture: TDD/BDD standards, testing frameworks, shared test infrastructure. Defines quality metrics and acceptance criteria for releases.

Shapes organizational testing culture: TDD adoption strategy, BDD for cross-team contracts, test-first approach for critical paths. Defines testing maturity model.

Defines quality engineering strategy at organizational level: testing standards, infrastructure for testing at scale, shift-left testing culture.

Defines testing methodology for the company. Shapes engineering culture. Publishes adoption experience.

Shapes testing culture: TDD adoption strategy, Rust-specific testing patterns, test-driven architecture governance.

Shapes testing culture strategy: TDD adoption, property-based testing governance, test-driven architecture for Scala platform.

Shapes TDD/BDD strategy for compiler engineering at the organizational level. Defines best practices and influences technology choices beyond their own team. Is a recognized expert in this area.

Defines enterprise TDD/BDD approach for embedded. Establishes methodology for safety-critical firmware development with formal verification integration.

Shapes testing culture: TDD adoption, BDD governance, test-driven fullstack architecture.

Defines organizational QA strategy. Shapes quality engineering culture. Implements platform solutions for testing.

Defines organizational QA strategy for language tooling ecosystem: testing standards across compiler, LSP, and IDE tooling projects. Drives adoption of formal verification and property-based testing for critical language infrastructure. Implements platform testing solutions that scale across multiple language tool products. Shapes industry standards for language tool quality assurance.

Defines the organization's QA strategy. Builds quality engineering culture. Implements platform testing solutions.

Defines organizational QA strategy with BDD as a core practice: quality engineering culture, behavior-driven requirements management, and living documentation standards. Drives adoption of BDD across the organization as a business-technology alignment tool. Implements platform solutions for BDD scenario management and test evidence governance. Shapes quality assurance practices industry-wide.

Designs security-by-design methodology: threat-model-driven BDD, automated compliance verification, security requirement traceability. Defines security testing culture.

Defines organizational QA strategy. Shapes quality engineering culture. Introduces platform solutions for testing.