Claude Skills by Jartan-LLC

How agents, skills, and commands work in Claude Code projects.

GitHub conventions -- branch naming, commit format, issue/PR templates, and safe issue/PR referencing in comments.

Work through review findings on a PR one at a time

API error response format -- machine-readable codes, human-readable reasons, status code rules.

Language-agnostic code hygiene -- no dead/reinvented/duplicated code, truthful names, real implementations, and scoped (never blanket) diagnostic suppressions.

Language-agnostic structural craft -- decompose on responsibility not size, prefer deep modules over shallow piles, and shape cohesion, coupling, interfaces, error contracts, and data invariants. Sibling to code-hygiene, comment-hygiene and readable-code.

Comment truthfulness -- what a comment must tell the reader that the code can't, the KEEP/DELETE/EXEMPT/CONDITIONAL taxonomy, tombstone and retold-fact detection, and comment density across a diff. Sibling to code-hygiene, code-structure and readable-code.

Create a GitHub issue using the appropriate template

Create a pull request for implemented changes from a GitHub issue

Documentation writing conventions -- style, structure, tone, and quality standards.

CSS design system principles -- token usage, semantic layering, mobile-first, component isolation.

Implement a GitHub issue, optionally from an existing plan

Logging conventions -- level usage, formatting style, structured output.

Analyze a GitHub issue and create an implementation plan

Language-agnostic local-clarity craft -- shape control flow, the naming of a whole set, and reading order so a body reads straight down with the smallest working set. Sibling to code-hygiene, comment-hygiene and code-structure.

Review a pull request using specialized reviewer agents

One severity model for code review -- Critical/Important/Minor by consequence-if-shipped (impact x reachability), with confidence as a separate report gate.

Integration test philosophy -- test observable behavior, fixture composition, canary markers for library internals.

Python asyncio, concurrent programming, and async/await patterns for high-performance applications.

Python data validation using type hints and runtime type checking with Pydantic v2's Rust-powered core.

Common Python anti-patterns and a pre-merge review checklist.

Render Python docstrings into a browsable, published API reference with Sphinx, autodoc, napoleon, and MyST.

Python code style, linting, formatting, naming conventions, and documentation standards.

Python configuration management via environment variables and typed settings.

Python error handling patterns including input validation, exception hierarchies, and partial failure handling.

Python observability patterns including structured logging, metrics, and distributed tracing.

Create distributable Python packages with proper project structure, pyproject.toml, and publishing to PyPI.

Pythonic idioms, PEP 8 standards, type hints, and best practices for building robust, efficient, and maintainable Python applications.

Profile and optimize Python code using cProfile, memory profilers, and performance best practices.

Python project organization, module architecture, and public API design.

Python resilience patterns including automatic retries, exponential backoff, timeouts, and fault-tolerant decorators.

Python resource management with context managers, cleanup patterns, and streaming.

Python testing strategies using pytest, TDD methodology, fixtures, mocking, parametrization, and coverage requirements.

Python type safety with type hints, generics, protocols, and strict type checking.

The uv package manager for fast Python dependency management, virtual environments, and modern project workflows.

Core principles for recursive multi-agent development -- nesting, scope ownership, TDD, context flow, token economics.

Wave execution rules -- agent constraints, wave barriers, review-fix evaluation, language awareness.

Build a project using recursive multi-agent development with TDD

How to decompose projects into wave plans -- module identification, dependency mapping, wave assignment, contract guidance, deliverables.

Quality patterns, anti-patterns, and contract richness guidelines for recursive development.