gohypergiant/agent-skills
Overview
This skill provides a comprehensive, command-only TypeScript file audit system that orchestrates multiple specialized audit skills (testing, best-practices, performance, documentation) with interactive, approval-driven changes. It uses isolated git worktrees and persistent audit-process files to track progress across sessions and avoid conflicts. The workflow enforces strict verification, PBT stability checks, and step-by-step saving to prevent lost context.
How this skill works
Given a file or directory path, the skill builds a TODO list of TypeScript files and creates an isolated git worktree for the audit. It runs four audit skills in a prescribed 8-step sequence per file: testing, combined best-practices+performance, verification, and documentation, saving progress after every step. All suggested edits are shown with a severity table and before/after diffs, and user approval is required for each numbered change. Tracking files live outside the worktree so audit metadata is never committed.
When to use it
- You need a repeatable, auditable TypeScript code review that includes tests, performance, and docs.
- You want to run parallel audits without interfering with main branches or other audits.
- You must ensure property-based tests are stable before merging changes.
- You need session persistence to resume large audits across multiple runs.
- You require interactive, granular approval for every change to maintain code ownership.
Best practices
- Always validate the path and verification commands before initializing an audit.
- Create a timestamped isolated worktree; never run audits directly on main branches.
- Run accelint-ts-testing first and never skip test coverage verification.
- Run best-practices and performance analyses together and merge or present conflicts explicitly.
- Show the emoji severity table and full before/after diffs for all issues before asking for approval.
- Save detailed progress to the audit-process file after every completed step.
Example use cases
- Audit a single TypeScript file with tests, performance tweaks, and documentation updates in one session.
- Run a multi-file audit over several sessions while preserving partial results and resume points.
- Verify new property-based tests by running the test suite 100 consecutive times before accepting changes.
- Perform parallel audits on different worktrees to avoid merge conflicts on a shared repository.
- Enforce strict interactive approval flow for teams that require explicit consent for each automated change.
FAQ
No. Every change is presented with severity and before/after code and requires explicit numbered approval.
What if property-based tests are introduced?
You must run the documented test command 100 times without coverage reporting and only proceed after 100 consecutive passes.
13 skills
This skill audits TypeScript files across multiple guidelines in parallel, tracks progress, and coordinates interactive approvals to ensure safe, comprehensive
This skill critiques Figma designs from operator personas, aligning UX with their roles, tasks, and systems to reduce cognitive load.
This skill helps you write robust Bash scripts using strict mode, guarded error handling, and safe patterns for production reliability.
This skill automates shell workflows and optimizes command-line tasks to improve reliability and speed across development, testing, and deployment pipelines.
This skill evaluates Agent Skills against official specifications and patterns, delivering multi-dimensional scores and actionable improvement guidance.
This skill helps you create, refactor, or audit AI skills by guiding packaging, naming, and integration steps for reliable agent capabilities.
This skill analyzes codebases to generate or update thorough README.md files with examples, API coverage, and install instructions.
This skill performs systematic TypeScript performance audits and applies targeted optimizations to reduce runtime and memory usage.
This skill helps you write, review, and refactor React tests with Testing Library, emphasizing accessible queries and user-centric interactions.
This skill guides Vitest testing in TypeScript projects with AAA pattern, parameterized tests, async patterns, and property-based testing for robust coverage.
Guide for creating Claude Code commands with skill integration. Use when users want to create a new Claude Code command specification, whether skill-based or standalone. Assists with command definition, skill discovery, argument specification, and command generation.
JavaScript and TypeScript best practices covering naming conventions, control flow, state management, TypeScript patterns (avoid any/enum, prefer type over interface), safety (input validation, assertions, error handling), performance optimization (reduce branching/looping, memoization, defer await, cache property access, storage API caching, avoid needless allocations, currying for hot paths), and documentation (JSDoc, comment markers). Use when writing JS/TS functions, refactoring code for performance, reviewing code quality, fixing type errors, optimizing loops or conditionals, adding validation, or improving error messages.
Comprehensive vitest testing patterns covering test structure, AAA pattern, parameterized tests, assertions, mocking, test doubles, error handling, async testing, and performance optimization. Use when writing, reviewing, or refactoring vitest tests, or when user mentions vitest, testing, TDD, test coverage, mocking, assertions, or test files (*.test.ts, *.spec.ts).
