core-engineering

Explain object-oriented programming and SOLID principles with TypeScript examples.

Updated Mar 10, 2026

Search Tags:#typescript #design patterns #clean code #software architecture #oop #solid

Ready to run

npx skills add https://github.com/owenlim225/LockIn-Pro --skill core-engineering-owenlim225

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: core-engineering
Source: https://github.com/owenlim225/LockIn-Pro/tree/main/.agents/skills/core-engineering
Command: npx skills add https://github.com/owenlim225/LockIn-Pro --skill core-engineering-owenlim225

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill provides a comprehensive understanding of fundamental object-oriented design (OOD) principles, SOLID guidelines, and clean code practices, enabling developers to write more robust, maintainable, and scalable software.

Core Features & Use Cases

Object-Oriented Programming: Explains the four pillars (Abstraction, Encapsulation, Inheritance, Polymorphism) with code examples.
SOLID Principles: Details each of the five SOLID principles (SRP, OCP, LSP, ISP, DIP) with practical TypeScript illustrations.
Clean Code & Relationships: Covers DRY, KISS, YAGNI, Law of Demeter, and the distinctions between Association, Aggregation, and Composition.
Use Case: A developer is unsure how to refactor a monolithic class into more manageable, testable components. This Skill provides the principles and examples to guide the refactoring process.

Quick Start

Explain the Single Responsibility Principle with a TypeScript example.

Frequently Asked Questions about core-engineering

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

FAQPage Schema

How do I explain the Single Responsibility Principle with a TypeScript example?▼

The Single Responsibility Principle states a class should have only one reason to change. This Skill provides concrete TypeScript code examples demonstrating how to separate distinct responsibilities into isolated, maintainable classes.

What is the difference between composition and inheritance in object-oriented programming?▼

Composition and inheritance differ in object relationship design. This Skill explains composition over inheritance using TypeScript examples, detailing how composition creates flexible has-a relationships instead of rigid is-a inheritance hierarchies.

How do I refactor a monolithic class using SOLID principles and clean code practices?▼

Refactoring a monolithic class requires applying SOLID principles and clean code heuristics. This Skill guides the process by detailing SRP for splitting classes and DRY, KISS, YAGNI rules to ensure manageable, testable components.

When should I use association, aggregation, or composition in software architecture?▼

Association, aggregation, and composition define varying object relationship strengths in software architecture. This Skill clarifies when to use each relationship type, providing TypeScript illustrations to distinguish independent links from dependent lifecycles.

Does this Skill cover the Law of Demeter and other clean code heuristics for TypeScript?▼

The Law of Demeter and other clean code heuristics are fully covered for TypeScript. It explains DRY, KISS, YAGNI, and the Law of Demeter to help developers write robust, maintainable object-oriented code.

Can I learn all five SOLID design principles with practical object-oriented programming examples?▼

You can learn all five SOLID design principles with practical object-oriented programming examples. The Skill details SRP, OCP, LSP, ISP, and DIP using TypeScript illustrations to build scalable software architecture.