Advanced Best Practices Platform

A Claude Code skill consolidating software development best practices across coding standards, code organization, performance, security, and maintainability. Serves as a comprehensive reference for establishing and enforcing quality standards in professional development teams.

When to Use This Skill

Choose Advanced Best Practices Platform when:

• You want to establish coding standards for a new project or team
• You need a comprehensive review checklist for code quality
• You want to audit an existing codebase for best practice violations
• You need to onboard new developers with consistent guidelines
• You want to improve overall code quality and maintainability

Consider alternatives when:

• You need specific language patterns (use a language-specific skill)
• You want code review automation (use a code review skill)
• You need architecture decisions (use an architecture workspace skill)

Quick Start

Copy
# Install the skill
claude install advanced-best-platform

# Audit code quality
claude "Audit this TypeScript module for best practice violations: [paste code]"

# Set up standards
claude "Create a coding standards document for our Node.js/TypeScript backend team"

# Review a PR
claude "Review this PR diff against our best practices: focus on error handling, naming, and complexity"

Core Concepts

Quality Dimensions

Dimension	Measures	Tools
Correctness	Does the code do what it should?	Tests, type system
Readability	Can others understand it?	Naming, structure, comments
Maintainability	Can it be changed safely?	Modularity, coupling, cohesion
Performance	Is it fast enough?	Profiling, benchmarks
Security	Is it safe from attacks?	OWASP checks, dependency audit
Reliability	Does it handle failures?	Error handling, retry logic

Naming Conventions

Variables: Descriptive nouns
  ✓ userCount, maxRetries, isValid
  ✗ x, temp, data, val

Functions: Verb + noun
  ✓ getUserById, validateEmail, calculateTotal
  ✗ process, handle, doStuff

Booleans: Question form
  ✓ isActive, hasPermission, canDelete
  ✗ active, permission, delete

Constants: SCREAMING_SNAKE
  ✓ MAX_RETRIES, API_BASE_URL
  ✗ maxretries, apiBaseUrl (for true constants)

Classes: PascalCase nouns
  ✓ UserService, PaymentProcessor
  ✗ HandleUser, DoPayment

Code Complexity Rules

Rule	Threshold	Remedy
Function length	< 30 lines	Extract helper functions
Parameters	< 4 parameters	Use options object
Nesting depth	< 3 levels	Early returns, extract functions
Cyclomatic complexity	< 10	Simplify conditionals
File length	< 300 lines	Split into modules
Class methods	< 10 public methods	Split responsibilities

Configuration

Parameter	Type	Default	Description
language	string	"typescript"	Primary language
strictness	string	"moderate"	Level: relaxed, moderate, strict
focus_areas	string[]	["all"]	Areas: naming, complexity, security, performance
team_size	number	5	Team size for appropriate standards
include_examples	boolean	true	Include do/don't code examples

Best Practices

1. Optimize for reading, not writing — Code is read 10x more than it's written. Choose clear names, consistent structure, and explicit logic over clever shortcuts. If a colleague can't understand your code in 30 seconds, simplify it.

2. Functions should do one thing — A function named processUserAndSendEmail does two things. Split it into processUser and sendEmail. Single-responsibility functions are easier to test, reuse, and debug.

3. Return early, reduce nesting — Instead of wrapping code in if (condition) { ... long block ... }, use if (!condition) return; at the top. This reduces nesting depth and makes the happy path clearer.

4. Don't comment what the code does — comment why — // increment counter adds nothing. // retry 3 times because the payment API has intermittent failures is valuable. Good code is self-documenting for the "what"; comments explain the "why."

5. Make illegal states unrepresentable — Use the type system to prevent invalid states. Instead of { status: string, data?: any, error?: string }, use a discriminated union: { status: 'success', data: T } | { status: 'error', error: string }.

Common Issues

Standards are too strict and slow development — Start with the most impactful rules (naming, error handling, no any types) and add more gradually. Standards should prevent real bugs, not enforce style preferences that don't affect quality.

Team doesn't follow standards — Automate enforcement with ESLint, Prettier, and CI checks. Rules that require manual review will be inconsistently applied. If a rule can't be automated, it should be a guideline, not a rule.

Legacy code violates all standards — Don't try to fix everything at once. Apply the "boy scout rule": leave code better than you found it. When you touch a file, fix the violations in the code you're changing, not the entire file.