skills

Operational guide for acceptance testing using ATDD principles. Activates when writing acceptance tests, implementing features with acceptance criteria, fixing acceptance test suites, or designing architecture for testability.

Guide Agile software development practices using Uncle Bob's teachings from the Clean Code series. Operational procedure for assessing team maturity, diagnosing Agile health, and fixing common anti-patterns. Activates when discussing Agile methodology, iteration planning, velocity, estimation, continuous integration, Definition of Done, or when user mentions Scrum, XP, sprint, velocity, planning game, or professional expectations.

Map Clean Architecture to your actual stack. Detect your framework, deployment model, and existing patterns. Convert architecture principles into decision rules you can verify. Draw boundaries the way your codebase needs — not from a textbook. Activate when designing system structure, defining use cases, placing modules, reviewing dependency direction, or choosing monolith vs microservices.

Comprehensive code review across 10 dimensions (Naming, Functions, Classes, Error Handling, Comments, Formatting, Tests, Architecture, Patterns, Professional Standards). Coordinates specialized skills for deep analysis. Final quality gate: code must pass with no critical issues.

Module boundaries, package organization, monorepo structure, dependency management, composer/npm/pip/cargo package design. Activate when defining package structure, managing coupling across module boundaries, or when the user mentions monorepo, package.json, composer.json, coupling, cohesion, circular dependency, or module design.

Apply functional programming principles to improve code quality. Activate when reviewing code with pure functions, immutability, state management, higher-order functions, functional composition, or when the user mentions FP, pure functions, immutability, map/filter/reduce, side effects, or functional architecture.

Write and refactor clean functions. Activate when writing new functions, refactoring existing ones, reviewing code for function quality, or when the user mentions function size, arguments, side effects, extract method, or complexity. Functions are the first unit of organization — if they're wrong, everything above them inherits the mess.

Operational guide for working with legacy code incrementally. Activates when dealing with untested, poorly structured, or difficult-to-change code. Use characterization tests, Boy Scout acts of kindness, clean module extraction, and strangulation technique to improve volatile code while protecting it with tests.

Analyze and improve naming in code. Activate when writing new code, reviewing existing code, renaming, refactoring, or doing code review. Also activate when the user mentions naming, unclear names, intent-revealing names, or readability. Every name is a chance to communicate or to confuse — when in doubt, activate.

Apply design patterns appropriately. Activate when code has recurring problems (creation, behavior variation, structural composition), when discussing pattern choice, or when reviewing pattern implementations. Patterns solve specific problems — activate when the problem is clear and a pattern can simplify.

Operational guide for professional software development practices — responsibility, ethics, estimates, saying no, commitments. Activates when discussing professional conduct, estimation, commitments, ethics, saying no, or when quality standards and professional responsibility are relevant.

Analyze code and provide specific, actionable refactoring suggestions based on Clean Code principles. Activates when code feels messy or hard to change, after implementation to improve code quality, or when the user mentions refactor, improve code, clean up, technical debt, or code smells.

Evaluate and improve class design with SOLID principles. Activate when designing classes or modules, evaluating class responsibilities, working with inheritance or interfaces, managing dependencies, or doing code review. Also activate when the user mentions SOLID, responsibility, cohesion, coupling, abstraction, or extensibility. SOLID principles control how classes relate — violations cause rigidity and fragility that compound over time.

Guide TDD workflow. Activate when implementing features, writing tests, fixing bugs, creating handlers/services/use cases, or when the user mentions test-first, TDD, red-green-refactor, failing test, or test-driven. TDD is the mandatory discipline for all feature work — activate proactively, not just when asked.

Operational framework for teaching Clean Code concepts. Activates when explaining or learning about Clean Code principles. Routes to specialized skills and applies learner-level-appropriate teaching strategies.