base_skill

Overview

This skill codifies an opinionated, security-first project initialization and development pattern focused on simplicity, TDD, and atomic todos. It enforces strict limits on function/file/module size and prescribes a reproducible TDD workflow so projects stay small, testable, and auditable. Use it to initialize or refactor codebases for AI-native development with clear docs and session state.

How this skill works

The skill inspects proposed or modified files against hard limits (lines per file, functions per file, lines per function, parameter counts, nesting depth) and refuses completion until violations are fixed. It enforces a functional-core/imperative-shell architecture, composition-first design, fail-fast error handling, and 100% business-logic test coverage. It also generates and validates atomic todos with required acceptance criteria and TDD execution logs.

When to use it

• Bootstrapping new Claude Code projects with security and spec-first defaults
• Refactoring codebases to reduce cognitive load and eliminate anti-patterns
• Enforcing TDD and test-first workflows on feature or bug work
• Onboarding teams to a single, auditable project structure and session state
• Validating CI quality gates (lint, typecheck, coverage) before merges

Best practices

• Keep every function ≤20 lines and ≤3 parameters; decompose immediately if violated
• Limit files to ≤200 lines and ≤10 functions; split by responsibility before continuing
• Prefer pure functions for business logic and isolate side effects at boundaries
• Write failing tests first (RED), implement minimally (GREEN), then run full quality gates (VALIDATE)
• Track every task as an atomic todo with measurable acceptance criteria and TDD execution logs
• Never merge code without passing linter, type checker, and coverage thresholds

Example use cases

• Initialize a secure TypeScript/React service scaffold with enforced simplicity rules and .env credential validation
• Add a new feature by creating an atomic todo, writing failing tests, implementing code under limits, and validating quality gates
• Diagnose and fix a reported bug by writing a repro test, failing it, fixing code, and running full validation
• Refactor a monolithic file into multiple focused modules to meet line/function limits and remove circular dependencies
• Create project docs and session state files to enable resumable, auditable work sessions