fearovex/claude-config
32 skills1.3k installs32 starsGitHub
Install
npx skills add https://github.com/fearovex/claude-configSkills in this repo
1Image Ocrimage-ocr is a reference skill that helps solo builders choose and implement optical character recognition when unstructured images must become searchable, structured, or LLM-ready text. It compares local engines and cloud APIs on accuracy, language support, cost, and fit—for example PaddleOCR for CJK tables, EasyOCR for photo-heavy captures, or managed APIs when compliance and uptime matter more than marginal cost. The content walks through preprocessing, post-processing, and structuring outputs so agents do not default to a single library for every document type. Use it during feature work that ingests user uploads, automates support from screenshots, extracts fields from invoices, or powers RAG over scanned PDFs. It is methodology-light and integration-heavy: you bring runtime choice (Python vs Node), storage, and privacy rules. Intermediate comfort with installing native dependencies or cloud credentials is assumed; beginners can still follow the selection table before committing to a stack.1.2kinstalls2Branch PrBranch-pr is a procedural agent skill for the Agent Config project’s issue-first pull request system. It is aimed at solo contributors and maintainers who need a repeatable checklist when creating or helping others open PRs so merges are not rejected by automation. The workflow starts by confirming the linked issue has status:approved, then creating a branch that matches the enforced naming regex, implementing with conventional commits, running shellcheck on touched scripts, and submitting via the project template with a single type label. Critical rules are explicit: no PR without an approved issue, exactly one type:* label, and all automated checks green before merge. Branch naming tables spell out feat, fix, chore, docs, style, refactor, perf, test, build, ci, and revert patterns with lowercase slug rules. Use this skill whenever you are preparing a branch for review rather than improvising PR metadata.1installs3Codebase Teachcodebase-teach is a procedural agent skill that turns a living codebase into durable, agent-readable domain documentation. It analyzes bounded contexts from the source tree, extracts business rules and terminology, and materializes them as ai-context/features/<context>.md files, then summarizes coverage in teach-report.md. Solo builders juggling Claude Code or Cursor benefit because agents stop guessing domain edges after a single deliberate teach pass—especially when memory-init left empty stubs and memory-update only captured chat decisions. Step 0 optionally loads stack.md, architecture.md, and conventions.md without failing the run if files are missing. The skill is explicitly user-triggered via /codebase-teach or natural-language equivalents, which keeps autonomous runs from rewriting feature docs mid-session. Use after initial repo setup or before a major refactor when you need feature-level truth aligned to code, not stale README prose.1installs4Config Auditconfig-audit is a procedural checker skill for solo builders and maintainers of Claude Code setups who want configuration discipline without blind edits. It runs when you invoke /config-audit or ask for a configuration health check. Step zero classifies global mode (claude-config repo with install.sh and skills/_shared), project mode (any directory with root CLAUDE.md), or no-config mode with a clear stop message. Global audits use the repo’s docs/config-guidelines.md; project audits use the deployed global spec at ~/.claude/docs/config-guidelines.md while targeting the project’s files. The run is strictly read-only and materializes audit-report.md for the companion config-refactor skill. On Prism it sits in Ship review as the spec-driven gate before refactors, while still relevant when you iterate agent config during Build agent-tooling.1installs5Config Exportconfig-export helps solo builders who standardized on CLAUDE.md and optional ai-context/ but also use GitHub Copilot, Gemini, or Cursor. The skill collects the source bundle, lets you pick target assistants, generates each tool’s native instruction files through LLM transformation, shows a dry-run preview, and writes only after you confirm—so you avoid silently overwriting editor configs. If CLAUDE.md is missing, it stops with a clear fork: run project-setup to scaffold the SDD workflow, or bootstrap a minimal Copilot instructions path for greenfield repos. It never touches your canonical Claude sources, which keeps a single source of truth while collaborators on other stacks get equivalent guardrails. Use after project-setup or whenever CLAUDE.md changes and downstream tools need a refresh.1installs6Config Refactorconfig-refactor is a procedural agent skill for solo builders maintaining Claude Code repositories who already ran config-audit and need deterministic remediation. It reads docs/config-guidelines.md and audit-report.md as the sole specification, detects whether you are in the global claude-config repo or a downstream project, and applies fixes only to allowed targets—project mode never mutates the global layer. Stale audits trigger an explicit warning so you do not ship refactors against outdated findings. The skill fits the Ship review lane because it closes the loop on configuration hygiene before agents rely on hooks, skills, and output styles daily. Invoke it after audit-report.md exists and you are ready to edit CLAUDE.md, skills/, hooks/, or output-styles/ in a governed way.1installs7Deep AnalysisDeep Analysis is a procedural agent skill that acts as a relevance filter applied before the assistant produces any lengthy diagnostic. Solo builders hit it when they ask for análisis profundo, deep analysis, root-cause work, architecture trade-offs, or open-ended “what should we do about X?” on non-trivial scope. Instead of generating five sections and a menu of options, the agent runs four ordered steps: nail the real decision, calibrate requested depth, respect role-scope, and commit to one leading hypothesis. That prevents the common failure mode of impressive but unusable dumps. The skill stays off for simple questions, single-file edits, and quick facts—default answers remain short. Apache-2.0 procedural format fits Claude-style agents that need guardrails on expensive reasoning turns. Pair it with implementation or planning skills only after the single decision and hypothesis are explicit.1installs8Feature Definefeature-define is an interactive procedural skill that enforces the fearovex two-artifact rule for every product feature: authoritative domain knowledge lives in ai-context/features/<slug>.md, while .claude/skills/<slug>/SKILL.md acts as an antenna that fires on natural-language triggers and forces a read of that markdown without copying it. Templates are pulled from skills/_templates/feature in the global agent-config repository, keeping consumer repos free of duplicated prose. The skill also updates CLAUDE.md so Claude Code discovers the new capability. Guardrails stop execution in the template repo itself and require a real consumer project layout. Solo builders use it when a feature crosses multiple sessions and agents—billing, auth, or onboarding—need stable, versioned context instead of chat memory. It sits after sdd-init has established project context and before implementation-heavy SDD steps that consume the feature file.1installs9Feature Domain Expertfeature-domain-expert is a reference skill for solo and indie builders who run spec-driven or agent-assisted development and need a durable home for domain knowledge. It teaches how to author and read feature-level markdown under ai-context/features/, covering bounded-context business rules, invariants, integration points, and known gotchas without copying GIVEN/WHEN/THEN deltas from SDD specs. The guide stresses a critical distinction: feature files are permanent reference material updated over time, while SDD specs are behavioral deltas archived per change. Install it when you want propose and spec steps to pull consistent context, when onboarding collaborators to your domains, or when memory updates should enrich context instead of scattering rules in chat. Pair it with your SDD toolchain so agents stop reinventing domain semantics on every ticket.1installs10Judgment DayJudgment Day is a procedural agent skill that treats code and architecture review as an adversarial protocol instead of a single pass. When you invoke it—by name or phrases like dual review or review adversarial—the orchestrator resolves relevant skills from engram or a local skill registry, scopes the target files, then spins up two blind judges concurrently so neither inherits the other’s bias. Findings are synthesized, fixes are applied in the main workspace, and the loop runs again until both judges pass or the skill escalates after two iterations. Solo builders use it when merging substantial features, agent tooling, or risky refactors where one reviewer might normalize bugs. It pairs naturally with implementation phases on Claude Code, Cursor, or Codex-style agents that support sub-agent delegation. The skill does not replace lightweight linting; it buys confidence when production failure cost dominates review time cost.1installs11Memory Managememory-manage is a procedural agent skill that treats ai-context/ as a first-class memory layer for solo developers who rely on Claude Code, Cursor, or similar tools across weeks-long builds. In init mode it scans configuration, folder layout, representative source, tests, and CI to author stack.md, architecture.md, conventions.md, and known-issues.md from scratch. Update mode captures what changed in the current session so the next agent invocation does not rediscover basics. Maintain mode performs housekeeping so files stay concise and trustworthy. Use it whenever a repository lacks structured agent memory or drifts out of sync with reality. The skill reduces repeated explanations, keeps architectural decisions citable inside the repo, and pairs naturally with other claude-config workflow skills that assume ai-context/ exists.1installs12Night Parknight-park is a procedural Claude Code skill for solo builders juggling multiple agent sessions late into the night. On a single invocation it reads the active session ID, synthesizes a substantive handoff from the conversation, writes a markdown file under docs/handoffs in the current project, duplicates the summary into engram with a tagged topic key, and prints the precise claude --resume command for the next day. It does not ask follow-up questions—the workflow is meant to run when you are done for the evening and cannot mentally track which terminal was fixing which bug. The on-disk handoff is readable in your IDE or a fresh chat in the same repo, while engram gives you a cross-tool memory anchor. Use it whenever context would otherwise evaporate across sleep, not only on production incidents.1installs13Output Style CreatorOutput Style Creator is a procedural agent skill for solo builders who maintain a Claude-style config repo and want new assistant voices without breaking their spec. It behaves as a guided wizard: first it verifies `docs/output-style-guidelines.md` and stops cold if the spec is missing, because the skill never invents rules outside that document. You then supply a kebab-case style name that describes tone or experience—not a character persona—and the skill rejects pirate, sergeant, gentleman, or human-name gimmicks in favor of durable labels like `direct` or `warm-direct`. Five questions are asked sequentially with a hard pause after each response so the agent cannot silently default your preferences. Before writing, it checks for an existing `output-styles/<name>.md` and negotiates overwrite versus a new name. The result is a compliant markdown style file your agent can select alongside other output modes. Use it whenever you are extending agent tooling in build, refreshing tone before a launch comms push, or standardizing support voice in grow—always after the guidelines doc exists. It does not replace the guidelines themselves; create or update that spec first.1installs14Project Auditproject-audit is an agent skill from the fearovex claude-config ecosystem that helps solo builders see whether their AI coding setup matches how they actually work. Instead of ad-hoc grepping, Phase A runs a single discovery script that records whether root or `.claude/CLAUDE.md` exists, which skills directory layout is in use, and which `ai-context` markdown artifacts are present—with optional line counts for oversized files. The design constraint matters: at most three Bash invocations per full audit, so the skill stays safe for agents with shell access. Use when onboarding to a unfamiliar repo, after copying a global config template, or when agents behave inconsistently because stack or conventions docs are missing. Outcomes feed later audit phases (not fully shown in the snippet) so you can align install/sync scripts with local skills. It does not replace security review or test suites; it maps the skeleton your agent relies on so you can iterate on documentation and skill paths deliberately.1installs15Project Claude Initproject-claude-init bootstraps a CLAUDE.md configuration file that helps AI assistants understand your project's tech stack, structure, and constraints. Solo builders use it during project setup to establish clear context for AI collaboration. This matters because well-documented project context enables better AI assistance throughout development, from code review to debugging to feature planning.1installs16Project Fixproject-fix is a procedural agent skill for solo builders who already ran `/project-audit` and need those findings applied mechanically. It treats `.claude/audit-report.md` as the only source of truth, walks through each required action in the fix manifest, and refuses to improvise corrections that were not audited. Before work starts, it verifies the report exists and warns when the artifact is older than seven days so you do not ship stale guidance. During execution it consults STUB_TEMPLATES.md for SDD section templates, skill stub patterns, flag markers, and changelog wording so applied fixes stay consistent with the audit framework. The skill sits in the apply step of a four-part flow—audit produces the spec, fix mutates the project, then you re-run audit to verify. It is aimed at Claude Code users maintaining a structured `.claude` setup rather than one-off chat tweaks.1installs17Project Onboardproject-onboard is a procedural Claude Code skill that treats “where do I start?” as a filesystem diagnosis problem. It walks a fixed five-check waterfall in priority order, reading CLAUDE.md, ai-context, audits, and related signals to assign one of six onboarding cases without asking the user survey questions. The first failing check sets the primary case; later checks can still add warnings—for example a broadly healthy repo with fixable local skill gaps. Each case ships with an ordered command sequence such as project-setup, memory-init, project-audit, and project-fix so solo builders do not guess which slash command comes next. It is ideal when you clone an unfamiliar repo, inherit a half-configured agent workspace, or reopen a project after weeks away and need a deterministic reset path before creative work.1installs18Project SetupProject Setup is a procedural agent skill that deploys a full spec-driven development (SDD) architecture when you run /project-setup or ask to initialize agent configuration in an existing repository. It inspects package manifests, directory layout, linter and compiler config, README, and git presence to infer your stack and conventions, then writes a project-root CLAUDE.md grounded in what it actually found—not generic placeholders. It seeds the ai-context/ layer with five memory files for ongoing agent context, establishes engram project context for the SDD cycle, and builds a registry of skills matched to your detected technologies. The skill is aimed at solo builders who want Claude (or compatible agents) to start with correct stack facts and a repeatable memory model instead of hand-rolling docs every new repo.1installs19Project Trackingproject-tracking is a command-reference skill for Claude agents that turns GitHub Projects V2 and Issues into a repeatable delivery backbone for solo builders. SKILL.md carries decision logic—when to confirm steps, how to handle unsupported issue types—while this package stores literal gh and GraphQL invocations you run by step ID. Pre-flight resolves owner and repo from the origin remote so you never hard-code the wrong namespace. track-init probes whether the active gh token can reach Projects V2, separating “not logged in” from fine-grained PAT scope gaps so the agent suggests the right fix instead of generic errors. plan-epic and plan-migrate share issue-type discovery and degrade gracefully to labels when the API returns empty nodes. For indie teams shipping on GitHub, it reduces ad-hoc project setup into auditable, copy-paste-ready blocks that pair with engram-style project numbering. Use when you already live in gh CLI and want the agent to drive init and migration without re-deriving GraphQL each session.1installs20Sdd Applysdd-apply is the implementation leg of Spec-Driven Development for agents using fearovex/claude-config. After you have specs and design for a named change, solo builders invoke it to write real code without drifting from the plan. The skill loads project-local instructions first, then global fallbacks, and follows shared SDD phase common steps for project context and spec preload so the agent does not hallucinate requirements. A scope guard reads design.md’s File Change Matrix: if only markdown and YAML change, it skips irrelevant tech preloads and reports that decision. Throughout execution, the agent marks tasks in tasks.md as done, keeping humans and future agent turns aligned. It expects Sonnet-class models with thinking enabled per metadata, which suits multi-file edits. Pair it with earlier SDD planning skills so apply never runs on an unapproved spec; the readme explicitly frames specs as WHAT and design as HOW.1installs21Sdd Archivesdd-archive is the terminal workflow skill in an SDD orchestration cycle. It runs when you trigger `/sdd-archive <change-name>`, ask to archive a change, finalize the SDD cycle, or close a change after downstream verify work. The agent first proves the change is archivable by searching engram for required artifacts—proposal and tasks are CRITICAL blockers; design and specs are WARNING-only with a deliberate proceed choice. It is designed to be irreversible, so the skill pauses for human confirmation before persisting a closure record and optionally syncing ai-context. Skill resolution prefers a repo-local SKILL.md over the global Claude skills catalog, which keeps team-specific archive rules authoritative. Solo builders use it to avoid losing structured change history in chat-only workflows and to leave a durable audit trail tied to mem_search-visible artifacts rather than ad-hoc summaries.1installs22Sdd Designsdd-design is a procedural agent skill in the SDD (spec-driven development) chain. Solo builders invoke it after a change proposal exists and before writing code, so the agent documents how the system will satisfy the specs: technical choices, data movement, and which files will change. It explicitly loads project context and preloads spec context using shared SDD phase guidance, then retrieves the proposal artifact for the named change. The output is the design artifact that implementation skills can follow, reducing rework from ambiguous requirements. It pairs with orchestrated sub-agents and project-local SKILL.md overrides over global catalog paths. Use when you need change architecture, a technical design memo, or a structured handoff from product intent to build tasks—not when you only need a quick bugfix without a named change.1installs23Sdd Exploresdd-explore is a procedural SDD agent skill for solo and indie builders who use Claude Code-style workflows and want terrain mapped before they change anything. It investigates an idea or a specific area of the repository through reading and analysis only—explicitly creating no code and modifying no files—so you can decide scope and approach with evidence instead of guesswork. Invoke it when a task feels vague, when you are unsure how wide the change ripples, when you want impact understood before committing, or when several implementation paths are plausible. The skill resolves from project-local skills first, then the global catalog, and begins by loading project context plus spec context preload per the shared SDD phase common guide. It pairs naturally with spec-driven orchestration: exploration output informs whether to proceed to planning, narrowing, or a targeted build. Intermediate complexity because it assumes a structured repo and comfort following multi-step agent rituals rather than a single chat prompt.1installs24Sdd Initsdd-init is a procedural executor skill from the fearovex agent-config stack that prepares any consumer project for Spec-Driven Development. On trigger it reads the repository to infer stack, layout, and conventions, then persists a markdown project context through Engram’s mem_save API using a stable topic_key so re-runs update rather than duplicate. The skill explicitly forbids orchestration detours—no delegate, task, or sub-agent launches—so initialization stays deterministic. When persistence is disabled, it still returns detected context for upstream orchestrators. Solo builders adopt it at the moment they commit to SDD discipline: one pass seeds shared memory that later define, plan, and implement skills can rely on instead of re-scanning the tree. It pairs with engram naming conventions documented in skills/_shared and is versioned as format procedural metadata 3.0.1installs25Sdd Proposesdd-propose is a procedural agent skill in the fearovex Claude SDD (spec-driven development) toolkit that forces a written change proposal before any detailed specs or design land in the repo. It answers what is changing, why it matters, and the rough technical approach so solo builders and small teams do not jump straight into implementation prompts. Triggers include the slash command `/sdd-propose <change-name>` and natural-language requests to create or define a proposal. For larger efforts, the skill points to an optional PRD template that feeds the later sdd-spec phase; internal refactors can stay lightweight. Skill resolution prefers project-local copies over the global catalog, which suits teams forking the workflow per repository. On Prism it sits on Validate → scope as the first contractual artifact in a multi-phase SDD chain that continues into specification and build planning.1installs26Sdd SpecSdd-spec is a procedural Claude Code skill in the fearovex SDD stack that authors specification deltas for a named change. It states what the system must do in terms of observable behavior—not implementation—and treats specs as the verification source of truth. When no prior spec exists it writes a full document; when one exists it emits ADDED, MODIFIED, and REMOVED sections so history stays auditable. Requirements pair with Given/When/Then scenarios so downstream coding and test agents share the same acceptance language. Resolution prefers project-local .claude/skills over the global catalog, aligning with the documented SKILL-RESOLUTION algorithm. Solo builders using spec-driven workflows invoke it after a change is opened and before implementation agents touch code, keeping scope crisp for indie teams that cannot afford rework from vague prompts.1installs27Sdd TasksSdd Tasks is an agent skill in the spec-driven development (SDD) chain that converts an approved design into tasks.md—a strictly ordered list where every item is one concrete change with a file path and a clear done condition. Solo builders using Claude Code with the fearovex claude-config stack invoke it after design is settled and before any implementation sub-agent runs; without that file, sdd-apply is blocked by design. The skill loads shared SDD phase helpers for project context and spec preload, resolves SKILL.md from project-local or global paths, and ingests the design file matrix so tasks mirror the intended approach rather than improvisational chat steps. It fits indie teams who want agent implementation to feel like executing a sprint board encoded in markdown, not reinterpretation. Outcome is a reviewable task ledger you can approve, diff, and hand to apply-phase automation.1installs28Sdd Verifysdd-verify is the report-template and output contract for Step 10 of the fearovex SDD workflow. Solo builders and small teams use it when an agent has finished implementing a named change and you need a repeatable verification artifact instead of a vague “looks good.” The skill separates what gets saved to engram (compact markdown report with verdict, dimension status, tool runs, and issues) from richer conversational detail blocks that stay in the thread. It expects you to record real commands and exit codes, including SKIPPED when no test runner exists, so downstream reviewers and future you can trust the verdict. It fits agentic spec-driven development where memory persistence matters and you want PASS, PASS WITH WARNINGS, or FAIL to be citable on the detail page.1installs29Skill Creatorskill-creator is a procedural meta-skill for solo builders who outgrow improvised prompts and want durable agent capabilities in SKILL.md form. It runs in two modes: /skill-create builds a brand-new skill and asks whether it belongs in the global catalog or only the current project, while /skill-add imports an existing catalog skill into the repo you are in. The workflow starts with context detection—especially when you are inside the fearovex agent-config repository, where generic skills must be written under skills/<name>/SKILL.md so install.sh can deploy them, never by writing directly into ~/.claude/skills from that repo. That distinction matters for indie maintainers who treat one dotfiles repo as the source of truth for every project. Use it whenever you are formalizing repeat workflows—reviews, deploy checklists, brainstorming rituals—into discoverable skills with clear triggers. The skill is journey-wide in practice because new skills can target any phase, but Prism shelves it under Build agent-tooling as the home for authoring reusable procedural knowledge.1installs30Smart Commitsmart-commit is a procedural git skill for solo builders who want disciplined commits without manually splitting diffs. Trigger it when you say commit, smart commit, or /commit. The agent inspects staged and unstaged state, learns recent message style from the last five oneline commits, clusters files by role, proposes conventional messages per cluster, and walks you through sequential commits after you approve the plan. It also surfaces common foot-guns—credentials in diffs, stray debug logging, and oversized files—so you catch problems before push. When the tree is coherent enough for one theme, it skips the multi-commit ceremony. Apache-2.0 licensed and versioned 1.1 in metadata, it fits everyday Ship workflows in any local repo where conventional commits matter.1installs31Solid Dddsolid-ddd is a journey-wide reference agent skill that packages SOLID principles and Domain-Driven Design tactical patterns with illustrative do and don't snippets, intentionally independent of any single language or framework. In the fearovex Claude config stack it is always loaded for non-documentation code changes through sdd-apply, which makes it behave like embedded design governance rather than an optional cheat sheet you forget during fast iterations. Solo builders shipping APIs, modular monoliths, or agent-assisted refactors install it when agents otherwise sprawl responsibilities across god-classes, anemic models, or repositories that leak persistence concerns into UI flows. Use it while writing new modules, splitting services, or reviewing pull requests where boundary clarity matters more than syntax sugar. The skill does not replace domain discovery workshops or strategic DDD context mapping—it gives tactical guardrails at the keyboard. Because triggers span implementation and review, treat it as ongoing procedural knowledge from first feature through production hardening, not a one-time readme.1installs32Support Briefsupport-brief is an agent skill for solo builders and small eng teams who already finished a technical customer investigation and need a short engineering-to-CS message. It reads root cause, real scope, fixes, and open questions from conversation context and outputs a natural Slack-ready brief that leads with the finding—not stack traces or code references. The procedural SKILL.md treats verification as the overriding rule: unconfirmed causes stay as open questions rather than assertions against Stripe, logs, or the database. Use it when support needs wording before the next customer touch, not when you still need to debug. It fits SaaS and API products where CS owns the relationship while engineering owns the truth.1installs