By elct9620
Apply AI-powered coding skills to refactor legacy code safely, enforce Clean Architecture and DDD, select GoF design patterns, uphold SOLID principles, design secure database schemas and APIs, follow TDD for tests, fix bugs via root-cause analysis, detect code smells, review changes for quality, track features in ROADMAP.md, and implement new features end-to-end.
npx claudepluginhub elct9620/claudekit --plugin codingFix bugs by diagnosing root cause, reproducing with tests, and applying minimal fixes.
Clean up legacy code issues by identifying code smells and applying safe refactoring techniques.
The `<execute name="main">ARGUMENTS</execute>` is entry point for this command.
The `<execute name="main">ARGUMENTS</execute>` is entry point for this command.
Implement features based on the agent skills.
Apply Clean Architecture with four concentric layers (Entities, Use Cases, Interface Adapters, Frameworks & Drivers). Use when creating docs/architecture.md, designing new modules, or restructuring code with proper dependency direction. Make sure to use this skill whenever the user discusses layer boundaries, dependency direction, where to put new code, separating business logic from frameworks, or organizing project directory structure around architectural layers.
Select and apply GoF design patterns: Factory, Builder, Strategy, Observer, Adapter, Decorator. Use when solving recurring design problems or structuring multi-component changes. Make sure to use this skill whenever the user needs to decouple components, wrap legacy APIs, handle multiple algorithm variants, build complex objects step by step, or asks which pattern fits their situation.
Model business domains using DDD patterns: Entity, Value Object, Aggregate, Domain Event. Use when implementing business logic, defining domain concepts, or designing aggregate boundaries. Make sure to use this skill whenever the user works on business rules, creates domain objects, discusses bounded contexts, models workflows or processes, or asks about entity vs value object distinctions — even for simple CRUD features that involve domain invariants.
Apply SOLID, KISS, DRY, YAGNI principles to code design decisions. Use when building new features from scratch and need to decide on class structure, interface boundaries, or dependency direction. Make sure to use this skill when the user faces design trade-offs, asks about SOLID principles, debates whether to abstract or keep things simple, or needs to evaluate competing design approaches — but not for code smell detection (use refactoring skill instead).
Safely restructure code without changing behavior using Extract Method, Rename, Move Method techniques. Use when preparing code for new features, improving code quality incrementally, cleaning up messy code, reducing duplication, or simplifying complex logic. Make sure to use this skill whenever the user mentions refactoring, cleaning up code, making code more readable, splitting large files or methods, or removing code smells.
Design database schemas and API contracts at system boundaries. Use when creating or modifying database tables, API endpoints, or data serialization formats. Make sure to use this skill whenever the user adds database migrations, designs REST/GraphQL APIs, creates DTOs, defines request/response shapes, or works on data serialization — even for adding a single column or endpoint.
Prevent security vulnerabilities through threat modeling, trust boundary analysis, and defense in depth. Use when writing code that crosses trust boundaries, handles authentication or authorization, processes external input, manages secrets, or stores sensitive data. Make sure to use this skill whenever the user works on login flows, processes data from external sources, builds interfaces between systems, manages credentials, or writes code that moves data across trust zones — even for seemingly simple changes like accepting a new parameter or calling an external service.
Write tests using TDD (Red-Green-Refactor) and AAA pattern. Use for every new feature, behavior change, or bug fix. Covers unit, integration, and E2E test selection. Make sure to use this skill whenever the user asks to add tests, fix a bug (tests should come first), implement a feature with test coverage, or asks about what kind of tests to write — even for small one-line changes or trivial-looking fixes.
This is personalized agent skills for coding tasks. Mainly designed to Claude Code but fit for other LLMs as well.
Each team or individual has their own coding style, preferences, and best practices. In my opinion, each one or team should have their own coding skills to better fit their needs.
I use Ruby, TypeScript/JavaScript, and Golang the most. And love Clean Architecture, Domain-Driven Design, and Test-Driven Development. This skill set is build around these preferences.
| Type | Selection |
|---|---|
| Architecture | Clean Architecture |
| Design | Domain-Driven Design |
| Workflow | Test-Driven Development |
| Principles | SOLID, KISS, DRY |
| Coding | Design Patterns |
| Coding | Refactoring |
| Coding | Security |
This repository is designed as Claude Code Plugin which contains following components:
|- /coding-skills
|- commands/ # Workflow commands (entry points)
|- write.md # Implement new features with TDD
|- fix.md # Diagnose and fix bugs
|- refactor.md # Clean up legacy code
|- review.md # Post-implementation quality checks
|- roadmap.md # Spec-to-implementation tracking
|- skills/ # Individual skills with specific knowledge
|- testing/
|- clean-architecture/
|- domain-modeling/
|- design-patterns/
|- refactoring/
|- principles/
|- schema/
|- security/
The command as entry which defines the workflow, then adaptively select necessary skills to complete the task.
For example, the /write command use clean-architecture when the structure is not defined and follow instructions to create necessary layers.
Choose the appropriate command based on your task:
| Command | Purpose | Arguments |
|---|---|---|
/write | Implement features | feature|id [--skip-tests] |
/refactor | Clean up code | [path|module] |
/fix | Fix bugs | bug|issue|error |
/review | Review changes | [path|module|--staged] |
/roadmap | Track implementation | [init|update|status] [feature] |
| Skill | /write | /refactor | /fix | /review |
|---|---|---|---|---|
| coding:testing | ✓ | ✓ | ✓* | ✓* |
| coding:refactoring | ✓ | ✓* | ✓ | ✓ |
| coding:clean-architecture | ✓ | ✓ | ✓ | ✓ |
| coding:principles | ✓ | ✓ | ✓ | ✓* |
| coding:design-patterns | ✓ | ✓ | ✓ | ✓ |
| coding:domain-modeling | ✓ | - | ✓ | - |
| coding:schema | ✓ | ✓ | ✓ | ✓ |
| coding:security | ✓ | ✓ | ✓ | ✓ |
*Core skill for this command (always activated)
/roadmapis a standalone tracking command and does not use coding skills.
/write: Starting a new feature or adding new functionality/refactor: Improving code quality without changing behavior/fix: Diagnosing and fixing bugs with test verification/review: Reviewing recent changes for style consistency, test quality, and architecture alignment after /write or /fix/roadmap: Tracking spec-to-implementation progress, initializing a roadmap from specs, or checking feature status/write or /fix → /review → /refactor (if needed)
After implementing features (/write) or fixing bugs (/fix), run /review to check quality. If the review report contains findings, use /refactor to address them.
Use /roadmap init to create a tracking index from your SPEC.md, then /roadmap status to check progress as you implement.
To use this coding skills, install from the marketplace or use claude plugin add in Claude Code. Then choose the command which most fits the task.
Apache-2.0 License. See LICENSE for details.
Software engineering skills from Code Complete and A Philosophy of Software Design. 20 skills across 3 agents (build, post-gate, debug). Building workflow with adaptive gates (BUILD, REVIEW, commit). Scientific debugging via debug-agent.
End-to-end development workflow: design → draft-plan → orchestrate → review → pr-create → pr-review → pr-merge
Context-Driven Development: draft specs and plans before implementation. Structured workflows for features and fixes.
Persona-driven AI development team: orchestrator, team agents, review agents, skills, slash commands, and advisory hooks for Claude Code
A curated set of skills for each stage of development — propose, spec, design, plan, implement, ship.
Share bugs, ideas, or general feedback.
Implementation workflow skills: feature, fix, refactor, plan, debug
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge.
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge.
Sign in to claim