cokit-cli 1.0.9 → 1.2.2

package/templates/repo/.github/skills/{ck-backend-development → backend-development}/references/backend-code-quality.md

@@ -1,659 +1,659 @@
-# Backend Code Quality
-
-SOLID principles, design patterns, clean code practices, and refactoring strategies (2025).
-
-## SOLID Principles
-
-### Single Responsibility Principle (SRP)
-
-**Concept:** Class/module should have one reason to change
-
-**Bad:**
-```typescript
-class User {
-  saveToDatabase() { /* ... */ }
-  sendWelcomeEmail() { /* ... */ }
-  generateReport() { /* ... */ }
-  validateInput() { /* ... */ }
-}
-```
-
-**Good:**
-```typescript
-class User {
-  constructor(public id: string, public email: string, public name: string) {}
-}
-
-class UserRepository {
-  async save(user: User) { /* ... */ }
-  async findById(id: string) { /* ... */ }
-}
-
-class EmailService {
-  async sendWelcomeEmail(user: User) { /* ... */ }
-}
-
-class UserValidator {
-  validate(userData: any) { /* ... */ }
-}
-
-class ReportGenerator {
-  generateUserReport(user: User) { /* ... */ }
-}
-```
-
-### Open/Closed Principle (OCP)
-
-**Concept:** Open for extension, closed for modification
-
-**Bad:**
-```typescript
-class PaymentProcessor {
-  process(amount: number, method: string) {
-    if (method === 'stripe') {
-      // Stripe logic
-    } else if (method === 'paypal') {
-      // PayPal logic
-    }
-    // Adding new payment method requires modifying this class
-  }
-}
-```
-
-**Good (Strategy Pattern):**
-```typescript
-interface PaymentStrategy {
-  process(amount: number): Promise<PaymentResult>;
-}
-
-class StripePayment implements PaymentStrategy {
-  async process(amount: number) {
-    // Stripe-specific logic
-    return { success: true, transactionId: '...' };
-  }
-}
-
-class PayPalPayment implements PaymentStrategy {
-  async process(amount: number) {
-    // PayPal-specific logic
-    return { success: true, transactionId: '...' };
-  }
-}
-
-class PaymentProcessor {
-  constructor(private strategy: PaymentStrategy) {}
-
-  async process(amount: number) {
-    return this.strategy.process(amount);
-  }
-}
-
-// Usage
-const processor = new PaymentProcessor(new StripePayment());
-await processor.process(100);
-```
-
-### Liskov Substitution Principle (LSP)
-
-**Concept:** Subtypes must be substitutable for base types
-
-**Bad:**
-```typescript
-class Bird {
-  fly() { /* ... */ }
-}
-
-class Penguin extends Bird {
-  fly() {
-    throw new Error('Penguins cannot fly!');
-  }
-}
-
-// Violates LSP - Penguin breaks Bird contract
-```
-
-**Good:**
-```typescript
-interface Bird {
-  move(): void;
-}
-
-class FlyingBird implements Bird {
-  move() {
-    this.fly();
-  }
-  private fly() { /* ... */ }
-}
-
-class Penguin implements Bird {
-  move() {
-    this.swim();
-  }
-  private swim() { /* ... */ }
-}
-```
-
-### Interface Segregation Principle (ISP)
-
-**Concept:** Clients shouldn't depend on interfaces they don't use
-
-**Bad:**
-```typescript
-interface Worker {
-  work(): void;
-  eat(): void;
-  sleep(): void;
-}
-
-class Robot implements Worker {
-  work() { /* ... */ }
-  eat() { throw new Error('Robots don't eat'); }
-  sleep() { throw new Error('Robots don't sleep'); }
-}
-```
-
-**Good:**
-```typescript
-interface Workable {
-  work(): void;
-}
-
-interface Eatable {
-  eat(): void;
-}
-
-interface Sleepable {
-  sleep(): void;
-}
-
-class Human implements Workable, Eatable, Sleepable {
-  work() { /* ... */ }
-  eat() { /* ... */ }
-  sleep() { /* ... */ }
-}
-
-class Robot implements Workable {
-  work() { /* ... */ }
-}
-```
-
-### Dependency Inversion Principle (DIP)
-
-**Concept:** Depend on abstractions, not concretions
-
-**Bad:**
-```typescript
-class MySQLDatabase {
-  query(sql: string) { /* ... */ }
-}
-
-class UserService {
-  private db = new MySQLDatabase(); // Tight coupling
-
-  async getUser(id: string) {
-    return this.db.query(`SELECT * FROM users WHERE id = ${id}`);
-  }
-}
-```
-
-**Good (Dependency Injection):**
-```typescript
-interface Database {
-  query(sql: string, params: any[]): Promise<any>;
-}
-
-class MySQLDatabase implements Database {
-  async query(sql: string, params: any[]) { /* ... */ }
-}
-
-class PostgreSQLDatabase implements Database {
-  async query(sql: string, params: any[]) { /* ... */ }
-}
-
-class UserService {
-  constructor(private db: Database) {} // Injected dependency
-
-  async getUser(id: string) {
-    return this.db.query('SELECT * FROM users WHERE id = $1', [id]);
-  }
-}
-
-// Usage
-const db = new PostgreSQLDatabase();
-const userService = new UserService(db);
-```
-
-## Design Patterns
-
-### Repository Pattern
-
-**Concept:** Abstraction layer between business logic and data access
-
-```typescript
-// Domain entity
-class User {
-  constructor(
-    public id: string,
-    public email: string,
-    public name: string,
-  ) {}
-}
-
-// Repository interface
-interface UserRepository {
-  findById(id: string): Promise<User | null>;
-  findByEmail(email: string): Promise<User | null>;
-  save(user: User): Promise<void>;
-  delete(id: string): Promise<void>;
-}
-
-// Implementation
-class PostgresUserRepository implements UserRepository {
-  constructor(private db: Database) {}
-
-  async findById(id: string): Promise<User | null> {
-    const row = await this.db.query('SELECT * FROM users WHERE id = $1', [id]);
-    return row ? new User(row.id, row.email, row.name) : null;
-  }
-
-  async save(user: User): Promise<void> {
-    await this.db.query(
-      'INSERT INTO users (id, email, name) VALUES ($1, $2, $3)',
-      [user.id, user.email, user.name]
-    );
-  }
-
-  // Other methods...
-}
-
-// Service layer uses repository
-class UserService {
-  constructor(private userRepo: UserRepository) {}
-
-  async getUser(id: string) {
-    return this.userRepo.findById(id);
-  }
-}
-```
-
-### Factory Pattern
-
-**Concept:** Create objects without specifying exact class
-
-```typescript
-interface Notification {
-  send(message: string): Promise<void>;
-}
-
-class EmailNotification implements Notification {
-  async send(message: string) {
-    console.log(`Email sent: ${message}`);
-  }
-}
-
-class SMSNotification implements Notification {
-  async send(message: string) {
-    console.log(`SMS sent: ${message}`);
-  }
-}
-
-class PushNotification implements Notification {
-  async send(message: string) {
-    console.log(`Push notification sent: ${message}`);
-  }
-}
-
-class NotificationFactory {
-  static create(type: 'email' | 'sms' | 'push'): Notification {
-    switch (type) {
-      case 'email':
-        return new EmailNotification();
-      case 'sms':
-        return new SMSNotification();
-      case 'push':
-        return new PushNotification();
-      default:
-        throw new Error(`Unknown notification type: ${type}`);
-    }
-  }
-}
-
-// Usage
-const notification = NotificationFactory.create('email');
-await notification.send('Hello!');
-```
-
-### Decorator Pattern
-
-**Concept:** Add behavior to objects dynamically
-
-```typescript
-interface Coffee {
-  cost(): number;
-  description(): string;
-}
-
-class SimpleCoffee implements Coffee {
-  cost() {
-    return 10;
-  }
-
-  description() {
-    return 'Simple coffee';
-  }
-}
-
-class MilkDecorator implements Coffee {
-  constructor(private coffee: Coffee) {}
-
-  cost() {
-    return this.coffee.cost() + 2;
-  }
-
-  description() {
-    return `${this.coffee.description()}, milk`;
-  }
-}
-
-class SugarDecorator implements Coffee {
-  constructor(private coffee: Coffee) {}
-
-  cost() {
-    return this.coffee.cost() + 1;
-  }
-
-  description() {
-    return `${this.coffee.description()}, sugar`;
-  }
-}
-
-// Usage
-let coffee: Coffee = new SimpleCoffee();
-coffee = new MilkDecorator(coffee);
-coffee = new SugarDecorator(coffee);
-
-console.log(coffee.description()); // "Simple coffee, milk, sugar"
-console.log(coffee.cost()); // 13
-```
-
-### Observer Pattern (Pub/Sub)
-
-**Concept:** Notify multiple objects about state changes
-
-```typescript
-interface Observer {
-  update(event: any): void;
-}
-
-class EventEmitter {
-  private observers: Map<string, Observer[]> = new Map();
-
-  subscribe(event: string, observer: Observer) {
-    if (!this.observers.has(event)) {
-      this.observers.set(event, []);
-    }
-    this.observers.get(event)!.push(observer);
-  }
-
-  emit(event: string, data: any) {
-    const observers = this.observers.get(event) || [];
-    observers.forEach(observer => observer.update(data));
-  }
-}
-
-// Observers
-class EmailNotifier implements Observer {
-  update(event: any) {
-    console.log(`Sending email about: ${event.type}`);
-  }
-}
-
-class LoggerObserver implements Observer {
-  update(event: any) {
-    console.log(`Logging event: ${JSON.stringify(event)}`);
-  }
-}
-
-// Usage
-const eventEmitter = new EventEmitter();
-eventEmitter.subscribe('user.created', new EmailNotifier());
-eventEmitter.subscribe('user.created', new LoggerObserver());
-
-eventEmitter.emit('user.created', { type: 'user.created', userId: '123' });
-```
-
-## Clean Code Practices
-
-### Meaningful Names
-
-**Bad:**
-```typescript
-function d(a: number, b: number) {
-  return a * b * 0.0254;
-}
-```
-
-**Good:**
-```typescript
-function calculateAreaInMeters(widthInInches: number, heightInInches: number) {
-  const INCHES_TO_METERS = 0.0254;
-  return widthInInches * heightInInches * INCHES_TO_METERS;
-}
-```
-
-### Small Functions
-
-**Bad:**
-```typescript
-async function processOrder(orderId: string) {
-  // 200 lines of code doing everything
-  // - validate order
-  // - check inventory
-  // - process payment
-  // - update database
-  // - send notifications
-  // - generate invoice
-}
-```
-
-**Good:**
-```typescript
-async function processOrder(orderId: string) {
-  const order = await validateOrder(orderId);
-  await checkInventory(order);
-  const payment = await processPayment(order);
-  await updateOrderStatus(orderId, 'paid');
-  await sendConfirmationEmail(order);
-  await generateInvoice(order, payment);
-}
-```
-
-### Avoid Magic Numbers
-
-**Bad:**
-```typescript
-if (user.age < 18) {
-  throw new Error('Too young');
-}
-
-setTimeout(fetchData, 86400000);
-```
-
-**Good:**
-```typescript
-const MINIMUM_AGE = 18;
-if (user.age < MINIMUM_AGE) {
-  throw new Error('Too young');
-}
-
-const ONE_DAY_IN_MS = 24 * 60 * 60 * 1000;
-setTimeout(fetchData, ONE_DAY_IN_MS);
-```
-
-### Error Handling
-
-**Bad:**
-```typescript
-try {
-  const user = await db.findUser(id);
-  return user;
-} catch (e) {
-  console.log(e);
-  return null;
-}
-```
-
-**Good:**
-```typescript
-try {
-  const user = await db.findUser(id);
-  if (!user) {
-    throw new UserNotFoundError(id);
-  }
-  return user;
-} catch (error) {
-  logger.error('Failed to fetch user', {
-    userId: id,
-    error: error.message,
-    stack: error.stack,
-  });
-  throw new DatabaseError('User fetch failed', { cause: error });
-}
-```
-
-### Don't Repeat Yourself (DRY)
-
-**Bad:**
-```typescript
-app.post('/api/users', async (req, res) => {
-  if (!req.body.email || !req.body.email.includes('@')) {
-    return res.status(400).json({ error: 'Invalid email' });
-  }
-  // ...
-});
-
-app.put('/api/users/:id', async (req, res) => {
-  if (!req.body.email || !req.body.email.includes('@')) {
-    return res.status(400).json({ error: 'Invalid email' });
-  }
-  // ...
-});
-```
-
-**Good:**
-```typescript
-function validateEmail(email: string) {
-  if (!email || !email.includes('@')) {
-    throw new ValidationError('Invalid email');
-  }
-}
-
-app.post('/api/users', async (req, res) => {
-  validateEmail(req.body.email);
-  // ...
-});
-
-app.put('/api/users/:id', async (req, res) => {
-  validateEmail(req.body.email);
-  // ...
-});
-```
-
-## Code Refactoring Techniques
-
-### Extract Method
-
-**Before:**
-```typescript
-function renderOrder(order: Order) {
-  console.log('Order Details:');
-  console.log(`ID: ${order.id}`);
-  console.log(`Total: $${order.total}`);
-
-  console.log('Items:');
-  order.items.forEach(item => {
-    console.log(`- ${item.name}: $${item.price}`);
-  });
-}
-```
-
-**After:**
-```typescript
-function renderOrder(order: Order) {
-  printOrderHeader(order);
-  printOrderItems(order.items);
-}
-
-function printOrderHeader(order: Order) {
-  console.log('Order Details:');
-  console.log(`ID: ${order.id}`);
-  console.log(`Total: $${order.total}`);
-}
-
-function printOrderItems(items: OrderItem[]) {
-  console.log('Items:');
-  items.forEach(item => {
-    console.log(`- ${item.name}: $${item.price}`);
-  });
-}
-```
-
-### Replace Conditional with Polymorphism
-
-**Before:**
-```typescript
-function getShippingCost(order: Order) {
-  if (order.shippingMethod === 'standard') {
-    return 5;
-  } else if (order.shippingMethod === 'express') {
-    return 15;
-  } else if (order.shippingMethod === 'overnight') {
-    return 30;
-  }
-}
-```
-
-**After:**
-```typescript
-interface ShippingMethod {
-  getCost(): number;
-}
-
-class StandardShipping implements ShippingMethod {
-  getCost() {
-    return 5;
-  }
-}
-
-class ExpressShipping implements ShippingMethod {
-  getCost() {
-    return 15;
-  }
-}
-
-class OvernightShipping implements ShippingMethod {
-  getCost() {
-    return 30;
-  }
-}
-```
-
-## Code Quality Checklist
-
-- [ ] SOLID principles applied
-- [ ] Functions are small (< 20 lines ideal)
-- [ ] Meaningful variable/function names
-- [ ] No magic numbers (use constants)
-- [ ] Proper error handling (no silent failures)
-- [ ] DRY (no code duplication)
-- [ ] Comments explain "why", not "what"
-- [ ] Design patterns used appropriately
-- [ ] Dependency injection for testability
-- [ ] Code is readable (readable > clever)
-
-## Resources
-
-- **Clean Code (Book):** Robert C. Martin
-- **Refactoring (Book):** Martin Fowler
-- **Design Patterns:** https://refactoring.guru/design-patterns
-- **SOLID Principles:** https://en.wikipedia.org/wiki/SOLID
+# Backend Code Quality
+
+SOLID principles, design patterns, clean code practices, and refactoring strategies (2025).
+
+## SOLID Principles
+
+### Single Responsibility Principle (SRP)
+
+**Concept:** Class/module should have one reason to change
+
+**Bad:**
+```typescript
+class User {
+  saveToDatabase() { /* ... */ }
+  sendWelcomeEmail() { /* ... */ }
+  generateReport() { /* ... */ }
+  validateInput() { /* ... */ }
+}
+```
+
+**Good:**
+```typescript
+class User {
+  constructor(public id: string, public email: string, public name: string) {}
+}
+
+class UserRepository {
+  async save(user: User) { /* ... */ }
+  async findById(id: string) { /* ... */ }
+}
+
+class EmailService {
+  async sendWelcomeEmail(user: User) { /* ... */ }
+}
+
+class UserValidator {
+  validate(userData: any) { /* ... */ }
+}
+
+class ReportGenerator {
+  generateUserReport(user: User) { /* ... */ }
+}
+```
+
+### Open/Closed Principle (OCP)
+
+**Concept:** Open for extension, closed for modification
+
+**Bad:**
+```typescript
+class PaymentProcessor {
+  process(amount: number, method: string) {
+    if (method === 'stripe') {
+      // Stripe logic
+    } else if (method === 'paypal') {
+      // PayPal logic
+    }
+    // Adding new payment method requires modifying this class
+  }
+}
+```
+
+**Good (Strategy Pattern):**
+```typescript
+interface PaymentStrategy {
+  process(amount: number): Promise<PaymentResult>;
+}
+
+class StripePayment implements PaymentStrategy {
+  async process(amount: number) {
+    // Stripe-specific logic
+    return { success: true, transactionId: '...' };
+  }
+}
+
+class PayPalPayment implements PaymentStrategy {
+  async process(amount: number) {
+    // PayPal-specific logic
+    return { success: true, transactionId: '...' };
+  }
+}
+
+class PaymentProcessor {
+  constructor(private strategy: PaymentStrategy) {}
+
+  async process(amount: number) {
+    return this.strategy.process(amount);
+  }
+}
+
+// Usage
+const processor = new PaymentProcessor(new StripePayment());
+await processor.process(100);
+```
+
+### Liskov Substitution Principle (LSP)
+
+**Concept:** Subtypes must be substitutable for base types
+
+**Bad:**
+```typescript
+class Bird {
+  fly() { /* ... */ }
+}
+
+class Penguin extends Bird {
+  fly() {
+    throw new Error('Penguins cannot fly!');
+  }
+}
+
+// Violates LSP - Penguin breaks Bird contract
+```
+
+**Good:**
+```typescript
+interface Bird {
+  move(): void;
+}
+
+class FlyingBird implements Bird {
+  move() {
+    this.fly();
+  }
+  private fly() { /* ... */ }
+}
+
+class Penguin implements Bird {
+  move() {
+    this.swim();
+  }
+  private swim() { /* ... */ }
+}
+```
+
+### Interface Segregation Principle (ISP)
+
+**Concept:** Clients shouldn't depend on interfaces they don't use
+
+**Bad:**
+```typescript
+interface Worker {
+  work(): void;
+  eat(): void;
+  sleep(): void;
+}
+
+class Robot implements Worker {
+  work() { /* ... */ }
+  eat() { throw new Error('Robots don't eat'); }
+  sleep() { throw new Error('Robots don't sleep'); }
+}
+```
+
+**Good:**
+```typescript
+interface Workable {
+  work(): void;
+}
+
+interface Eatable {
+  eat(): void;
+}
+
+interface Sleepable {
+  sleep(): void;
+}
+
+class Human implements Workable, Eatable, Sleepable {
+  work() { /* ... */ }
+  eat() { /* ... */ }
+  sleep() { /* ... */ }
+}
+
+class Robot implements Workable {
+  work() { /* ... */ }
+}
+```
+
+### Dependency Inversion Principle (DIP)
+
+**Concept:** Depend on abstractions, not concretions
+
+**Bad:**
+```typescript
+class MySQLDatabase {
+  query(sql: string) { /* ... */ }
+}
+
+class UserService {
+  private db = new MySQLDatabase(); // Tight coupling
+
+  async getUser(id: string) {
+    return this.db.query(`SELECT * FROM users WHERE id = ${id}`);
+  }
+}
+```
+
+**Good (Dependency Injection):**
+```typescript
+interface Database {
+  query(sql: string, params: any[]): Promise<any>;
+}
+
+class MySQLDatabase implements Database {
+  async query(sql: string, params: any[]) { /* ... */ }
+}
+
+class PostgreSQLDatabase implements Database {
+  async query(sql: string, params: any[]) { /* ... */ }
+}
+
+class UserService {
+  constructor(private db: Database) {} // Injected dependency
+
+  async getUser(id: string) {
+    return this.db.query('SELECT * FROM users WHERE id = $1', [id]);
+  }
+}
+
+// Usage
+const db = new PostgreSQLDatabase();
+const userService = new UserService(db);
+```
+
+## Design Patterns
+
+### Repository Pattern
+
+**Concept:** Abstraction layer between business logic and data access
+
+```typescript
+// Domain entity
+class User {
+  constructor(
+    public id: string,
+    public email: string,
+    public name: string,
+  ) {}
+}
+
+// Repository interface
+interface UserRepository {
+  findById(id: string): Promise<User | null>;
+  findByEmail(email: string): Promise<User | null>;
+  save(user: User): Promise<void>;
+  delete(id: string): Promise<void>;
+}
+
+// Implementation
+class PostgresUserRepository implements UserRepository {
+  constructor(private db: Database) {}
+
+  async findById(id: string): Promise<User | null> {
+    const row = await this.db.query('SELECT * FROM users WHERE id = $1', [id]);
+    return row ? new User(row.id, row.email, row.name) : null;
+  }
+
+  async save(user: User): Promise<void> {
+    await this.db.query(
+      'INSERT INTO users (id, email, name) VALUES ($1, $2, $3)',
+      [user.id, user.email, user.name]
+    );
+  }
+
+  // Other methods...
+}
+
+// Service layer uses repository
+class UserService {
+  constructor(private userRepo: UserRepository) {}
+
+  async getUser(id: string) {
+    return this.userRepo.findById(id);
+  }
+}
+```
+
+### Factory Pattern
+
+**Concept:** Create objects without specifying exact class
+
+```typescript
+interface Notification {
+  send(message: string): Promise<void>;
+}
+
+class EmailNotification implements Notification {
+  async send(message: string) {
+    console.log(`Email sent: ${message}`);
+  }
+}
+
+class SMSNotification implements Notification {
+  async send(message: string) {
+    console.log(`SMS sent: ${message}`);
+  }
+}
+
+class PushNotification implements Notification {
+  async send(message: string) {
+    console.log(`Push notification sent: ${message}`);
+  }
+}
+
+class NotificationFactory {
+  static create(type: 'email' | 'sms' | 'push'): Notification {
+    switch (type) {
+      case 'email':
+        return new EmailNotification();
+      case 'sms':
+        return new SMSNotification();
+      case 'push':
+        return new PushNotification();
+      default:
+        throw new Error(`Unknown notification type: ${type}`);
+    }
+  }
+}
+
+// Usage
+const notification = NotificationFactory.create('email');
+await notification.send('Hello!');
+```
+
+### Decorator Pattern
+
+**Concept:** Add behavior to objects dynamically
+
+```typescript
+interface Coffee {
+  cost(): number;
+  description(): string;
+}
+
+class SimpleCoffee implements Coffee {
+  cost() {
+    return 10;
+  }
+
+  description() {
+    return 'Simple coffee';
+  }
+}
+
+class MilkDecorator implements Coffee {
+  constructor(private coffee: Coffee) {}
+
+  cost() {
+    return this.coffee.cost() + 2;
+  }
+
+  description() {
+    return `${this.coffee.description()}, milk`;
+  }
+}
+
+class SugarDecorator implements Coffee {
+  constructor(private coffee: Coffee) {}
+
+  cost() {
+    return this.coffee.cost() + 1;
+  }
+
+  description() {
+    return `${this.coffee.description()}, sugar`;
+  }
+}
+
+// Usage
+let coffee: Coffee = new SimpleCoffee();
+coffee = new MilkDecorator(coffee);
+coffee = new SugarDecorator(coffee);
+
+console.log(coffee.description()); // "Simple coffee, milk, sugar"
+console.log(coffee.cost()); // 13
+```
+
+### Observer Pattern (Pub/Sub)
+
+**Concept:** Notify multiple objects about state changes
+
+```typescript
+interface Observer {
+  update(event: any): void;
+}
+
+class EventEmitter {
+  private observers: Map<string, Observer[]> = new Map();
+
+  subscribe(event: string, observer: Observer) {
+    if (!this.observers.has(event)) {
+      this.observers.set(event, []);
+    }
+    this.observers.get(event)!.push(observer);
+  }
+
+  emit(event: string, data: any) {
+    const observers = this.observers.get(event) || [];
+    observers.forEach(observer => observer.update(data));
+  }
+}
+
+// Observers
+class EmailNotifier implements Observer {
+  update(event: any) {
+    console.log(`Sending email about: ${event.type}`);
+  }
+}
+
+class LoggerObserver implements Observer {
+  update(event: any) {
+    console.log(`Logging event: ${JSON.stringify(event)}`);
+  }
+}
+
+// Usage
+const eventEmitter = new EventEmitter();
+eventEmitter.subscribe('user.created', new EmailNotifier());
+eventEmitter.subscribe('user.created', new LoggerObserver());
+
+eventEmitter.emit('user.created', { type: 'user.created', userId: '123' });
+```
+
+## Clean Code Practices
+
+### Meaningful Names
+
+**Bad:**
+```typescript
+function d(a: number, b: number) {
+  return a * b * 0.0254;
+}
+```
+
+**Good:**
+```typescript
+function calculateAreaInMeters(widthInInches: number, heightInInches: number) {
+  const INCHES_TO_METERS = 0.0254;
+  return widthInInches * heightInInches * INCHES_TO_METERS;
+}
+```
+
+### Small Functions
+
+**Bad:**
+```typescript
+async function processOrder(orderId: string) {
+  // 200 lines of code doing everything
+  // - validate order
+  // - check inventory
+  // - process payment
+  // - update database
+  // - send notifications
+  // - generate invoice
+}
+```
+
+**Good:**
+```typescript
+async function processOrder(orderId: string) {
+  const order = await validateOrder(orderId);
+  await checkInventory(order);
+  const payment = await processPayment(order);
+  await updateOrderStatus(orderId, 'paid');
+  await sendConfirmationEmail(order);
+  await generateInvoice(order, payment);
+}
+```
+
+### Avoid Magic Numbers
+
+**Bad:**
+```typescript
+if (user.age < 18) {
+  throw new Error('Too young');
+}
+
+setTimeout(fetchData, 86400000);
+```
+
+**Good:**
+```typescript
+const MINIMUM_AGE = 18;
+if (user.age < MINIMUM_AGE) {
+  throw new Error('Too young');
+}
+
+const ONE_DAY_IN_MS = 24 * 60 * 60 * 1000;
+setTimeout(fetchData, ONE_DAY_IN_MS);
+```
+
+### Error Handling
+
+**Bad:**
+```typescript
+try {
+  const user = await db.findUser(id);
+  return user;
+} catch (e) {
+  console.log(e);
+  return null;
+}
+```
+
+**Good:**
+```typescript
+try {
+  const user = await db.findUser(id);
+  if (!user) {
+    throw new UserNotFoundError(id);
+  }
+  return user;
+} catch (error) {
+  logger.error('Failed to fetch user', {
+    userId: id,
+    error: error.message,
+    stack: error.stack,
+  });
+  throw new DatabaseError('User fetch failed', { cause: error });
+}
+```
+
+### Don't Repeat Yourself (DRY)
+
+**Bad:**
+```typescript
+app.post('/api/users', async (req, res) => {
+  if (!req.body.email || !req.body.email.includes('@')) {
+    return res.status(400).json({ error: 'Invalid email' });
+  }
+  // ...
+});
+
+app.put('/api/users/:id', async (req, res) => {
+  if (!req.body.email || !req.body.email.includes('@')) {
+    return res.status(400).json({ error: 'Invalid email' });
+  }
+  // ...
+});
+```
+
+**Good:**
+```typescript
+function validateEmail(email: string) {
+  if (!email || !email.includes('@')) {
+    throw new ValidationError('Invalid email');
+  }
+}
+
+app.post('/api/users', async (req, res) => {
+  validateEmail(req.body.email);
+  // ...
+});
+
+app.put('/api/users/:id', async (req, res) => {
+  validateEmail(req.body.email);
+  // ...
+});
+```
+
+## Code Refactoring Techniques
+
+### Extract Method
+
+**Before:**
+```typescript
+function renderOrder(order: Order) {
+  console.log('Order Details:');
+  console.log(`ID: ${order.id}`);
+  console.log(`Total: $${order.total}`);
+
+  console.log('Items:');
+  order.items.forEach(item => {
+    console.log(`- ${item.name}: $${item.price}`);
+  });
+}
+```
+
+**After:**
+```typescript
+function renderOrder(order: Order) {
+  printOrderHeader(order);
+  printOrderItems(order.items);
+}
+
+function printOrderHeader(order: Order) {
+  console.log('Order Details:');
+  console.log(`ID: ${order.id}`);
+  console.log(`Total: $${order.total}`);
+}
+
+function printOrderItems(items: OrderItem[]) {
+  console.log('Items:');
+  items.forEach(item => {
+    console.log(`- ${item.name}: $${item.price}`);
+  });
+}
+```
+
+### Replace Conditional with Polymorphism
+
+**Before:**
+```typescript
+function getShippingCost(order: Order) {
+  if (order.shippingMethod === 'standard') {
+    return 5;
+  } else if (order.shippingMethod === 'express') {
+    return 15;
+  } else if (order.shippingMethod === 'overnight') {
+    return 30;
+  }
+}
+```
+
+**After:**
+```typescript
+interface ShippingMethod {
+  getCost(): number;
+}
+
+class StandardShipping implements ShippingMethod {
+  getCost() {
+    return 5;
+  }
+}
+
+class ExpressShipping implements ShippingMethod {
+  getCost() {
+    return 15;
+  }
+}
+
+class OvernightShipping implements ShippingMethod {
+  getCost() {
+    return 30;
+  }
+}
+```
+
+## Code Quality Checklist
+
+- [ ] SOLID principles applied
+- [ ] Functions are small (< 20 lines ideal)
+- [ ] Meaningful variable/function names
+- [ ] No magic numbers (use constants)
+- [ ] Proper error handling (no silent failures)
+- [ ] DRY (no code duplication)
+- [ ] Comments explain "why", not "what"
+- [ ] Design patterns used appropriately
+- [ ] Dependency injection for testability
+- [ ] Code is readable (readable > clever)
+
+## Resources
+
+- **Clean Code (Book):** Robert C. Martin
+- **Refactoring (Book):** Martin Fowler
+- **Design Patterns:** https://refactoring.guru/design-patterns
+- **SOLID Principles:** https://en.wikipedia.org/wiki/SOLID