sardonyx0827
UserPersonal dotfiles: Zsh / Neovim / tmux / WezTerm unified with Rosé Pine, a cross-platform installer, CI-tested hooks, and agent configs for Claude Code, Codex, and Gemini CLI
Categories
Indexed Skills (24)
eval-harness
Formal evaluation framework for Claude Code sessions implementing eval-driven development (EDD). Use this skill whenever defining success criteria for a feature before building it, writing capability / regression / quality evals, measuring pass@k reliability, or setting up eval-driven checks to catch regressions across changes.
project-guidelines-example
Example project-specific skill template with architecture overview, code patterns, testing requirements, and deployment workflow
verification-loop
Build, type-check, lint, test, secret-grep, and diff-review quality gate for code changes. Use when you have finished a feature or significant change, are about to open a PR, or want to confirm quality gates pass after refactoring — running the full verify sequence and reporting pass/fail per phase. Detects the project's own toolchain rather than assuming one. For the one-shot slash command, see /verify.
backend-patterns
Backend architecture, API design, and server-side patterns for Node.js, Express, and Next.js API routes. Use when designing or building REST/RPC endpoints, structuring services/controllers/middleware, handling auth/validation/error responses, or optimizing database access from the server.
clickhouse-io
ClickHouse (OLAP / column-oriented) patterns for high-performance analytics and data engineering. Use this skill whenever designing ClickHouse tables and engines (MergeTree family), writing or optimizing analytical queries, modeling partitioning and ordering keys, setting up materialized views, or ingesting large datasets for real-time analytics.
codex-consultation
Consult OpenAI Codex MCP for second opinions on specs, architecture, design decisions, and bug-fix strategy. Use when proposing a specification or design, planning a large-scale modification, writing test strategy, or after 2 consecutive failed fix attempts on the same issue (root-cause analysis). Codex is for discussion only — never let it implement code unless explicitly instructed.
codex-image-gen
Delegate raster / AI image asset generation to OpenAI Codex's built-in image_gen tool via the `mcp__codex__codex` tool, then place the results into a specified project directory. Use whenever a task needs a generated bitmap image written to disk — photos, illustrations, hero images, OG/OGP images, banners, product mockups, textures, sprites — e.g. building a site and needing hero/OGP/feature images in public/, or any request to "generate an image" / "画像を生成" / "画像を作成". The built-in path needs NO OPENAI_API_KEY. Not for SVG/vector/icon-set work that is better produced directly in code (use frontend patterns instead).
debugging-protocol
Systematic debugging workflow with Codex MCP escalation. Use this skill whenever investigating a bug, test failure, unexpected behavior, error message, or regression — even if the cause seems obvious. Especially important when a first fix attempt has already failed, since it defines when and how to escalate to Codex MCP for root-cause analysis.
docker-patterns
Docker and container best practices for writing efficient, secure, production-ready images. Use this skill whenever you are writing or editing a Dockerfile or docker-compose.yml, configuring devcontainers, debugging a failing container build, shrinking image size, speeding up build times, or hardening a container against security vulnerabilities. If Docker is in scope, load this skill first.
frontend-patterns
React and Next.js frontend patterns for components, state management, performance, and UI. Use when writing or refactoring React components, choosing a state-management approach, fixing re-render/performance issues, or structuring hooks and data fetching. Read the Server/Client boundary section first in any App Router project.
github-actions-ci
GitHub Actions CI/CD patterns covering workflow anatomy, trigger strategies, caching, matrix builds, security hardening, reusable workflows, and pipeline debugging. Use this skill whenever writing or editing .github/workflows/*.yml files, debugging a failed CI run, setting up CI for a new repository, optimizing slow or flaky pipelines, or implementing release automation — even for small edits, since YAML structure and security pitfalls are easy to introduce silently.
golang-patterns
Idiomatic Go patterns and conventions for robust, maintainable code. Use this skill whenever writing, reviewing, refactoring, or designing Go code — packages/modules, interfaces, error handling, concurrency (goroutines/channels/context), and project layout. Load it before the first line of Go, since idiom and error/concurrency conventions are hard to retrofit.
golang-testing
Go testing patterns — table-driven tests, subtests, benchmarks, fuzzing, and coverage, following TDD. Use this skill whenever writing or fixing Go tests (`*_test.go`), adding coverage to existing code, benchmarking hot paths, fuzzing input validation, or following the RED-GREEN-REFACTOR cycle in a Go project. Use proactively when touching Go code that lacks tests.
iterative-retrieval
Pattern for progressively refining context retrieval when subagents don't know what context they need until they start. Use this skill whenever a subagent or fan-out task must discover relevant files / patterns / terminology on its own, when "send everything" overflows context and "send nothing" starves the agent, or when designing multi-agent retrieval that converges on the right context iteratively.
migration-playbook
Structured playbook for safely executing migrations: upgrading a major dependency version, framework migrations (e.g. React 17→18, Next.js 12→14, Vue 2→3), API deprecations, replacing one library with another, large-scale refactors touching many call sites, and database schema changes. Use this skill whenever the word "migrate", "upgrade", "deprecate", or "replace" applies to something with more than a handful of affected sites — even if it looks straightforward. Migrations that skip the inventory step consistently produce incidents from the sites nobody knew existed.
postgres-patterns
PostgreSQL patterns for query optimization, schema design, indexing, RLS, and connection pooling (Supabase-based). Use this skill whenever writing SQL queries or migrations, designing schemas, choosing indexes, troubleshooting slow queries, or implementing Row Level Security. It is a quick reference — escalate to the database-reviewer agent for in-depth review.
python-scripting-patterns
Python scripting best practices for automation, CLI tools, and Claude Code hooks. Use this skill whenever writing or modifying Python scripts, CLI tools, or Claude Code hooks written in Python (.py files under .claude/hooks/), automation scripts, data processing scripts, or any standalone Python utility — even for small edits, since stdin-parsing mistakes, broad except clauses, and missing exit-code discipline are easy to introduce silently and hard to debug later.
release-workflow
End-to-end release process: semver level decisions from Conventional Commits, changelog generation, annotated git tags, GitHub Releases via gh CLI, version bump locations, hotfix branching, and CI automation shape. Use this skill whenever you are cutting a release, bumping a version, generating or updating a changelog, creating a git tag or GitHub Release, deciding which semver level to apply (major/minor/patch), handling a hotfix release, or working through a release checklist. If the user asks "what version should this be?", "how do I tag this?", "create a release", or "we need a hotfix" — load this skill first.
request-harness
Use this skill when processing requests dropped into docs/requests/ (via /requests, /requests-watch, or when the user asks to handle pending requests/依頼). Covers intake, ticket lifecycle, task-type routing (code, visual materials, research, writing, ops), execution, delivery reports, and the unattended watch loop.
security-review
Use this skill when adding authentication, handling user input, working with secrets, creating API endpoints, or implementing payment/sensitive features. Provides comprehensive security checklist and patterns.
shell-scripting-patterns
Bash/zsh scripting best practices for dotfiles management and Claude Code hooks. Use this skill whenever writing or modifying shell scripts (.sh files), Claude Code hooks (PreToolUse/PostToolUse/Stop), zsh configs (.zshrc, .zprofile), or anything under .claude/hooks/ — even for small edits, since shell quoting and error-handling mistakes are easy to introduce silently.
subagent-prompt-design
Design and write well-formed prompts for SubAgents launched via the Agent/Task tool. Use this skill whenever you are about to delegate work to a SubAgent, write prompts for parallel fan-out exploration or multi-perspective review, decide which model tier a SubAgent should use, or structure the return format so the main context stays clean. If you are about to fire off a Task call without reading this first, stop and read it — a poorly written subagent prompt is worse than doing the work inline.
tdd-workflow
Use this skill when writing new features, fixing bugs, or refactoring code. Enforces test-driven development across unit, integration, and E2E tests, and defines the coverage policy.
typescript-testing
TypeScript and JavaScript testing patterns using Vitest (primary) and Jest. Activate this skill whenever you are writing or fixing tests in a TypeScript or JavaScript project, touching *.test.ts / *.spec.ts / *.test.tsx files, configuring vitest.config.ts or jest.config.ts, asking about mocking strategies (vi.fn, vi.mock, MSW), debugging flaky async tests, or wiring up coverage thresholds. Also activates when test output shows "floating promise", "timeout", or "cannot find module" in a test context. For TDD methodology and the coverage policy, see tdd-workflow.
Bio shown is the top-scored skill's repo description as a fallback — real GitHub bios land in a future update.