programming-skills

Plugin programming-skills in wesleyegberto/software-engineering-skills. Commands read from the repo's manifest — 1 month ago.

Skills (22)

• anti-duplication

  Before implementing new code (endpoints, components, services, models), search the codebase for existing patterns to reuse. Prevent code duplication by finding and suggesting similar implementations. Auto-trigger when user asks to create, implement, add, or build new functionality. scope: review ver

• api-designer

  Use when designing REST or GraphQL APIs, creating OpenAPI specifications, or planning API architecture. Invoke for resource modeling, versioning strategies, pagination patterns, error handling standards.

• breaking-change-detector

  Detect and warn about breaking API/schema changes before implementation. Auto-trigger when modifying API routes, database schemas, or public interfaces. Validates changes against api-strategy.md versioning rules. Suggests migration paths for breaking changes. Prevents removing endpoints, changing re

• clean-architecture

  Structure software around the Dependency Rule: source code dependencies point inward from frameworks to use cases to entities. Use when the user mentions "architecture layers", "dependency rule", "ports and adapters", "hexagonal architecture", or "use case boundary". Covers component principles, bou

• clean-code

  Write readable, maintainable code through disciplined naming, small functions, and clean error handling. Use when the user mentions "code review", "naming conventions", "function too long", "code smells", or "readable code". Covers SRP, comment discipline, formatting, and unit testing. For refactori

• code-patterns

  Common design patterns with Java examples (Factory, Builder, Strategy, Observer, Decorator, etc.). Use when user asks "implement pattern", "use factory", "strategy pattern", or when designing extensible components.

• code-review-expert

  Expert code review of current git changes with a senior engineer lens in reviewing code for style, best practices, security, and performance. Use when the user asks for "feedback," a "review," or to "check" their changes. Detects SOLID violations, security risks, and proposes actionable improvements

• debugging-strategies

  Master systematic debugging techniques, profiling tools, and root cause analysis to efficiently track down bugs across any codebase or technology stack. Use when investigating bugs, performance issues, or unexpected behavior.

• domain-driven-design

  Model software around the business domain using bounded contexts, aggregates, and ubiquitous language. Use when the user mentions "DDD", "domain modeling", "bounded context", "aggregate root", "ubiquitous language", or "anti-corruption layer". Covers entities vs value objects, domain events, and con

• error-handling-patterns

  Master error handling patterns across languages including exceptions, Result types, error propagation, and graceful degradation to build resilient applications. Use when implementing error handling, designing APIs, or improving application reliability.

• git-advanced-workflows

  Master advanced Git workflows including rebasing, cherry-picking, bisect, worktrees, and reflog to maintain clean history and recover from any situation. Use when managing complex Git histories, collaborating on feature branches, or troubleshooting repository issues.

• git-commit

  Execute git commit with conventional commit message analysis, intelligent staging, and message generation. Use when user asks to commit changes, create a git commit, or mentions "/commit". Supports: (1) Auto-detecting type and scope from changes, (2) Generating conventional commit messages from diff

• git-guardrails-claude-code

  Set up Claude Code hooks to block dangerous git commands (push, reset --hard, clean, branch -D, etc.) before they execute. Use when user wants to prevent destructive git operations, add git safety hooks, or block git push/reset in Claude Code.

• multi-reviewer-patterns

  Coordinate parallel code reviews across multiple quality dimensions with finding deduplication, severity calibration, and consolidated reporting. Use this skill when organizing multi-reviewer code reviews, calibrating finding severity, or consolidating review results.

• parallel-debugging

  Debug complex issues using competing hypotheses with parallel investigation, evidence collection, and root cause arbitration. Use this skill when debugging bugs with multiple potential causes, performing root cause analysis, or organizing parallel investigation workflows.

• pragmatic-programmer

  Apply meta-principles of software craftsmanship: DRY, orthogonality, tracer bullets, and design by contract. Use when the user mentions "best practices", "pragmatic approach", "broken windows", "tracer bullet", or "software craftsmanship". Covers estimation, domain languages, and reversibility. For

• programming

  Provides recipes for programming tasks. Use when executing programming tasks like creating code, creating tests, reactoring code, reviewing code. scope: implementation version: "1.0.0

• refactoring-patterns

  Apply named refactoring transformations to improve code structure without changing behavior. Use when the user mentions "refactor this", "code smells", "extract method", "replace conditional", or "technical debt". Covers smell-driven refactoring, safe transformation sequences, and testing guards. Fo

• software-design-complexity

  Manage software complexity through deep modules, information hiding, and strategic programming. Use when the user mentions "module design", "API too complex", "shallow class", "complexity budget", or "strategic vs tactical". Covers deep vs shallow modules, red flags for complexity, and comments as d

• software-design-principles

  Reference guide for software design properties and principles: SOLID, GRASP, Law of Demeter, cohesion, coupling, information hiding, conceptual integrity, modularisation, module-level principles (REP/CCP/CRP/ADP/SDP/SAP), composition over inheritance, and immutability. ALWAYS activate this skill whe

• terminal-monitor

  Utility skill for opening a named terminal pane (tmux or iTerm2) to monitor a background Agent-tool teammate or a plain Bash background task in real time. For agents (mode: agent), the pane is driven by pushing the native <teammate-message>/idle_notification events the orchestrator already receives

• tests-expert

  Generates test files, creates mocking strategies, analyzes code coverage, designs test architectures, and produces test plans and defect reports across functional, performance, and security testing disciplines. Use when writing unit tests, integration tests, or E2E tests; creating test strategies or

Slash commands (18)

• /programming-skills:code-design-patterns
• /programming-skills:code-refactor-clean
• /programming-skills:code-review-best-practices
• /programming-skills:code-review-performance
• /programming-skills:code-review-refactor
• /programming-skills:code-review-security
• /programming-skills:code-review
• /programming-skills:code-tech-debt
• /programming-skills:debug-error-analysis
• /programming-skills:debug-error-trace
• /programming-skills:debug
• /programming-skills:git-full-review
• /programming-skills:git-pr-enhance
• /programming-skills:git-workflow
• /programming-skills:test-coverage-analysis
• /programming-skills:test-edge-cases
• /programming-skills:test-generate-e2e-tests
• /programming-skills:test-generate-unit-tests

Subagents (11)

• code-explorer.agent
• code-reviewer.agent
• debugger

  Debugging specialist for errors, test failures, and unexpected behavior. Use proactively when encountering any issues.

• demonstrate-understanding

  Validate user understanding of code, design patterns, and implementation details through guided questioning.

• dx-optimizer

  Developer Experience specialist. Improves tooling, setup, and workflows. Use PROACTIVELY when setting up new projects, after team feedback, or when development friction is noticed.

• error-detective

  Search logs and codebases for error patterns, stack traces, and anomalies. Correlates errors across systems and identifies root causes. Use PROACTIVELY when debugging issues, analyzing logs, or investigating production errors.

• legacy-modernizer

  Refactor legacy codebases, migrate outdated frameworks, and implement gradual modernization. Handles technical debt, dependency updates, and backward compatibility. Use PROACTIVELY for legacy system updates, framework migrations, or technical debt reduction.

• principal-software-engineer

  Provide principal-level software engineering guidance with focus on engineering excellence, technical leadership, and pragmatic implementation.

• software-engineer

  Expert-level software engineering agent. Deliver production-ready, maintainable code. Execute systematically and specification-driven. Document comprehensively. Operate autonomously and adaptively.

• tech-debt-remediation-plan

  Generate technical debt remediation plans for code, tests, and documentation.

• test-automator

  Master AI-powered test automation with modern frameworks, self-healing tests, and comprehensive quality engineering. Build scalable testing strategies with advanced CI/CD integration. Use PROACTIVELY for testing automation or quality assurance.