aibdd.auto.csharp.code-quality

Enforce C# integration test quality guidelines for SOLID and Step Definition refactors.

1|Updated Mar 6, 2026
One-click install
npx skills add https://github.com/zenbuapps/zenbu-powers --skill aibdd-auto-csharp-code-quality
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: aibdd.auto.csharp.code-quality
Source: https://github.com/zenbuapps/zenbu-powers/tree/main/skills/aibdd.auto.csharp.code-quality
Command: npx skills add https://github.com/zenbuapps/zenbu-powers --skill aibdd-auto-csharp-code-quality

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill codifies strict C# integration test quality guidelines for the aibdd.auto.csharp.it.refactor phase, ensuring maintainable, robust tests through SOLID principles, Step Definition organization, metadata cleanup, consistent logging, and architectural discipline.

Core Features & Use Cases

  • SOLID design principles enforcement for test code
  • Structured Step Definition organization for integration scenarios
  • Meta cleanup guidelines to keep test scaffolds clean and readable
  • Logging practices to ensure traceability and debuggability
  • Architectural guidelines to promote modular, testable components
  • Comprehensive code-quality rules to guide refactors in large test suites

Quick Start

Apply these C# quality guidelines to refactor your integration tests and verify SOLID, clean step definitions, and proper logging.

Frequently Asked Questions about aibdd.auto.csharp.code-quality

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I enforce SOLID principles when refactoring C# integration tests?

Enforce SOLID principles in C# integration test refactoring by applying architectural guidelines that validate naming, structure, and defensive coding patterns. This ensures test components remain modular, maintainable, and robust during large test suite refactors.

What is the best way to organize Step Definitions for C# integration testing?

Organize Step Definitions for C# integration testing using structured guidelines that validate step organization and metadata cleanup. This approach keeps test scaffolds clean, readable, and maintainable across complex integration scenarios.

How do I implement consistent logging practices in C# integration tests?

Implement consistent logging practices in C# integration tests by following logging guidelines that ensure traceability and debuggability. Proper logging validates test execution flows and simplifies debugging during integration test refactors.

Can I use standard .NET tooling for C# integration test quality checks without extra dependencies?

Yes, you can validate C# integration test quality using standard .NET tooling without extra runtime dependencies. The quality checks require no additional packages beyond standard .NET tooling to verify naming, structure, and defensive coding patterns.

What architectural guidelines should I follow for maintainable C# integration test code?

Follow architectural guidelines for maintainable C# integration test code that promote modular, testable components and SOLID adherence. These rules guide refactors by validating structural discipline, metadata cleanup, and defensive coding patterns across test suites.

Why does my C# integration test refactor fail code quality checks?

C# integration test refactors fail code quality checks when Step Definitions lack organization, metadata is not cleaned up, or logging practices are inconsistent. Validating naming conventions, structural discipline, and defensive coding patterns resolves these failures.