config_files

This skill should be used when iterating across multiple feedback rounds on a visual or creative artifact (SVG, image, diagram, HTML mockup, slide, logo) — especially when the user compares a design against earlier versions, says the design "regressed" or "was better before", asks to "keep track of versions", "go back to the old one", or "you lost the changes", or the session is long enough that early instructions could be forgotten.

Rules for using the Bash tool in Claude Code. This skill should be used when running shell commands via the Bash tool, especially for multi-command tasks, brew updates, build scripts, or any session involving significant shell usage. Use proactively before running Bash commands.

Access Craig's 3 email accounts — Gmail (personal), BoochTek (business), and SLUUG (old personal). Use this skill whenever the user asks to access emails, or when a task would benefit from email data (receipt hunting, conference confirmations, subscription audits, etc). Knows folder structures, MCP tool mappings, search syntax differences, and gotchas for each account.

This skill should be used when the user asks to "restore a website", "recover a site from the Wayback Machine", "download from archive.org", "rebuild a lost website", "convert a WordPress site to Hugo", or mentions recovering lost web content from the Internet Archive. Guides the full workflow from Wayback Machine inventory through Hugo site generation.

Code quality guidelines including naming, structure, and maintainability. This skill should be used when writing or reviewing code to ensure it meets quality standards. Use proactively when discussing naming conventions, code smells, readability, Sandi Metz rules, method length, class size, comments, refactoring for clarity, or maintainability concerns. (user)

Code refactoring methodology. Use this skill when improving code structure, when the user asks to simplify or clean up code, when reducing duplication, when improving readability, or after implementing features (the REFACTOR phase of TDD). Focuses on improving code without changing behavior.

Software development lifecycle guidance. This skill should be used when planning development work, conducting code reviews, or establishing development workflows. Use proactively when reviewing code, preparing commits, creating pull requests, refactoring, or discussing development process and best practices. (user)

Security guidelines for secure coding and code review. This skill should be used when architecting/designing systems, writing code, or reviewing code. Use proactively when discussing vulnerabilities, OWASP, injection attacks, XSS, CSRF, SQL injection, authentication, authorization, access control, encryption, secrets management, input validation, or secure coding practices. (user)

Persist learnings and insights across sessions. Use when the AI discovers something worth remembering, when a workflow pattern should be documented, when a mistake reveals a gap in instructions, or when the user asks to remember something.

Fetch news stories from Ground News with bias ratings and blindspot analysis. Use when aggregating news for the morning briefing or when the user wants news with media bias context.

Code implementation and feature development. Use this skill when implementing features, fixing bugs, or making tests pass. This is the GREEN phase of TDD — write minimal code to pass tests, then refactor. Also use the tdd, refactor, and design skills.

Writing and editing Markdown files. Use when creating or modifying .md files to ensure proper formatting.

Test-Driven Development methodology. Use this skill when writing tests, when the user asks for TDD, when implementing new features that need tests, or when the user says "write tests first" or similar. This skill focuses on the RED phase — writing failing tests that specify behavior.

Software design principles and patterns. This skill should be used when making architectural decisions, designing classes or modules, or evaluating code structure. Use proactively when discussing SOLID principles, coupling, cohesion, connascence, refactoring structure, class design, module boundaries, dependency injection, or the Four Rules of Simple Design. (user)

Testing philosophy and practices. This skill should be used when writing tests, designing test strategies, or reviewing test code. Use proactively when discussing TDD, red-green-refactor, test doubles, mocks, stubs, fakes, RSpec, Jest, pytest, unit tests, integration tests, test coverage, or test-first development. (user)

Create effective AI skills. This skill should be used when user wants to create a new skill (or update an existing skill) that extends an AI with specialized capabilities, knowledge, workflows, or tool integrations.