parcadei/continuous-claude-v3
155 skills55.9k installs601k starsGitHub
Install
npx skills add https://github.com/parcadei/continuous-claude-v3Skills in this repo
1Discovery InterviewDiscovery Interview is an AI-driven discovery agent that transforms vague ideas into implementable specifications through deep, iterative questioning. It works with both technical and non-technical users across eight interview phases: initial orientation (project type detection), category-by-category deep dives (problem, UX, data, technical landscape, scale, integrations, security, deployment), research loops for knowledge gaps, conflict resolution, completeness verification, spec generation, and implementation handoff. The agent probes beyond surface answers, detects uncertainty, educates when needed, and documents decisions with clear rationale before producing a formal specification document. Eight-phase interview structure: orientation, category deep-dive, research loops, conflict resolution, completeness check, spec generation, and implementation handoff Detects knowledge gaps via signal patterns (I think..., maybe..., just simple) and offers research to resolve uncertainty before proceeding Generates formal specifications to shared/specs/ with executive summary, problem statement,3.9kinstalls2Mathmath is a parcadei/continuous-claude-v3 cognitive stack guide that routes agent tasks to sympy_compute.py for exact symbolic work instead of LLM guesswork. The quick-reference table maps goals to commands such as solve for equations, integrate and differentiate for calculus, and limit for analysis boundaries. Developers invoke math when agents must return provably correct algebra, calculus, or unit conversions inside Claude Code or similar environments. The skill is user-invocable false for help mode but documents when to pick each math tool so coding agents choose the right SymPy CLI invocation.795installs3Premortempremortem is a continuous-claude-v3 skill based on Gary Klein's pre-mortem technique and Shreyas Doshi's Tiger framework. Invoke /premortem for auto depth, /premortem quick for plans and PRs, or /premortem deep before implementation. The skill forbids pattern-matching tigers without verification: each high-severity risk must cite location, mitigation_checked evidence, and pass context, fallback, scope, and dev-only checks within ±20 lines. Output YAML separates verified tigers, elephants (unspoken concerns), paper tigers with existing mitigations, and false alarms. Allowed tools include Read, Grep, Glob, Task, AskUserQuestion, and TodoWrite across six tool permissions. Severity thresholds mark HIGH risks as blocking until mitigated or explicitly accepted, while MEDIUM and LOW items inform without halting progress. Developers reach for premortem when a design doc, API plan, or PR needs structured what-could-go-wrong analysis instead of informal worry lists before expensive implementation work begins.767installs4Github Searchgithub-search is a Claude Code skill that searches GitHub code, repositories, issues, and pull requests through an MCP-backed Python harness in continuous-claude-v3. Invocations run via uv run python -m runtime.harness scripts/mcp/github_search.py with --type set to code, repos, issues, or prs, plus a --query string supporting GitHub search syntax. Optional --owner and --repo filters narrow results to specific repositories. Developers reach for github-search when they need prior art, open bug reports, or pull request history without leaving the agent session or opening the GitHub web UI.688installs5Dead Codedead-code is a continuous-claude-v3 skill that finds unused functions and unreachable code using TLDR static analysis via Bash. Developers run commands such as tldr dead ., tldr dead src/, or tldr dead . --lang python with optional --entry flags to exclude main, cli, or test entry points. Output reports total functions, dead function counts, and file-line locations like old_helper (src/utils.py:42). Reach for dead-code before large refactors or release review when you need an evidence-backed list of candidates to delete rather than manual grep guessing.634installs6Refactorrefactor is a parcadei/continuous-claude-v3 skill implementing a safe refactoring pipeline: phoenix analysis, plan-agent planning, kraken implementation, plan-reviewer checks, and arbiter validation. It triggers on requests like refactor X, clean up this code, extract a module, or improve architecture across large-scale restructures. Review gates block sloppy merges so style, performance, and structural goals stay explicit. Developers reach for refactor when a change spans many files, needs an auditable plan before edits, or must pass automated review between implementation passes—not for one-line typo fixes.574installs7Agentic Workflowagentic-workflow from parcadei/continuous-claude-v3 defines a standard multi-agent pipeline for implementation tasks in Claude Code. The main conversation stays as pure orchestration while Research, planning, and implementation agents run with run_in_background true via the Task tool, never TaskOutput, to avoid flooding context with full transcripts. Each agent writes outputs to .claude/cache/agents/<stage>/ for injection into subsequent agents, keeping the main thread minimal. Developers reach for agentic-workflow when implementing features that need verified research, staged handoffs, and hours-long sessions without losing context or momentum across agent stages.542installs8Exploreexplore is a read-only meta-skill in parcadei/continuous-claude-v3 for mapping unfamiliar codebases before implementation. Invoked as /explore with a depth level, it traces entrypoints, summarizes architecture layers, builds call graphs, and surfaces files worth editing. Three depth modes—quick, deep, and architecture—scale exploration cost to task urgency. The skill uses Bash, Task, Read, Glob, Grep, and Write tools but performs no code changes. Developers and agent operators reach for explore when onboarding to brownfield repos, scoping refactors, or answering where logic lives without manually clicking through directories.539installs9Modular Codemodular-code is a skill from parcadei/continuous-claude-v3 that guides modular Python organization with concrete file-size tiers. Files of 150–500 lines are optimal, 500–1000 are large and candidates for splitting, 1000–2000 are too large, and 2000+ lines are critical and must be split. The skill triggers splits when a file exceeds 500 lines, mixes unrelated concerns, or causes scroll fatigue for reviewers and AI tools. Developers reach for modular-code when refactoring monolithic Python modules into focused packages that stay within AI-assisted editing limits.530installs10Recall Reasoningrecall-reasoning is an agent-memory skill from continuous-claude-v3 that queries two sources: an Artifact Index of handoffs, plans, and ledgers with post-mortems, and Reasoning Files capturing build attempts, test failures, and commit context. Developers invoke it when starting work similar to a prior session, debugging a recurring issue, or asking what was tried last time with a component or API. The skill is user-invocable false, so agents load it when similarity or history questions appear. recall-reasoning complements grep and git log by surfacing explicit reasoning chains and documented what-worked versus what-failed patterns across long multi-day agent runs.515installs11Math Helpmath-help is a Claude Code skill from parcadei/continuous-claude-v3 that documents the math cognitive stack—cognitive prosthetics for exact computation. A quick-reference table maps goals to tools: solve equations via sympy_compute.py solve, integrate and differentiate, compute limits, and related symbolic operations with CLI examples like solve "x**2 - 4 = 0" --var x. Triggers include help, guide, how do I, what math, math help, math tools, which tool, and math tutorial; user-invocable is false so agents invoke it automatically. Developers reach for math-help when Claude must pick the right math script instead of guessing formulas or doing mental arithmetic that drifts from exact symbolic results.514installs12Sub Agentssub-agents is a build-phase agent-tooling skill documenting Claude Code sub-agent creation and management. Developers use `/agents` for interactive setup or hand-author YAML-front-matter files in `.claude/agents/` with `name`, `description`, optional `tools`, and `model` fields (`sonnet`, `haiku`, `claude-opus-4-5-20251101`, `inherit`). Built-in agents include General-purpose (Sonnet, all tools), Plan (Sonnet, read-only), and Explore (Haiku, read-only). Examples cover code-reviewer, debugger, and implementer tool sets, plus resumable sessions via `claude -r "agentId"` and agent chaining patterns. Project agents in `.claude/agents/` override user agents in `~/.claude/agents/`. Allowed tools on the skill itself are Read, Write, and Bash. Developers reach for sub-agents when decomposing large coding tasks into scoped agents with least-privilege tool access and model-appropriate cost/latency tradeoffs.512installs13Research Agentresearch-agent is a parcadei/continuous-claude-v3 skill marked user-invocable false that runs as a spawned research subagent before feature work. It receives a research question, planning context, and a handoff directory, then queries MCP tools including Nia, Perplexity, and Firecrawl to collect external documentation, best practices, and library API details dated to 2024–2025 references. Findings are written into a handoff artifact for the parent planning workflow. Developers trigger research-agent when autonomous pre-build research must cover competitors, technical docs, or user insights without blocking the main coding agent. It standardizes how continuous-claude pipelines externalize research results instead of ad-hoc web searches inside implementation threads.507installs14Securitysecurity is a parcadei/continuous-claude-v3 skill implementing a dedicated /security audit workflow for sensitive code paths. The pipeline chains two agents: aegis performs the security audit identifying vulnerabilities, then arbiter verifies proposed fixes. Developers reach for security when prompted by security audit, vulnerability check, authentication review, or injection attack concerns—especially before handling auth, payments, or user data and after adding security-sensitive features. The workflow diagram shows scan-then-verify sequencing rather than single-pass linting. It complements general code review by focusing on exploit classes like injection and broken authentication rather than style or performance. Trigger phrases include is this secure, check for vulnerabilities, and review authentication code, making it a ship-gate skill for teams using continuous-claude-v3 agent sequences on high-risk modules.507installs15Agent Orchestrationagent-orchestration is a parcadei/continuous-claude-v3 skill defining rules for when Claude should delegate implementation to sub-agents instead of burning main context on file reads and edits. The anti-pattern consumes 2000+ tokens in the main thread reading, understanding, and editing directly; the recommended pattern spawns an implementation agent that returns a roughly 200-token summary after completing multi-file work. A task table maps multi-file implementation, complex refactors, and broad codebase exploration to agent delegation while keeping lightweight queries in main context. Developers reach for agent-orchestration when running continuous-claude sessions that must stay coherent across many turns without exhausting the primary context window. The skill is user-invocable false, meaning it applies automatically as orchestration policy rather than a manual slash command, shaping agent spawning behavior throughout extended build sessions.501installs16Git Commitsgit-commits is a ship-phase Git skill from Continuous-Claude-v3 that intercepts commit, push, and save-to-git requests in Claude Code. Instead of running `git commit` directly—which adds "Generated with Claude Code" and Co-Author trailers—it mandates `Skill("commit")` so commits appear user-authored. The `/commit` skill also generates `reasoning.md` capturing what was attempted, clears build-attempt state for the next feature, and optionally runs `generate-reasoning.sh` with the commit hash before `git push origin <branch>`. Trigger words include commit, push, save changes, and push to GitHub. The skill is user-invocable false—it activates automatically when agents would otherwise commit. Developers using Continuous-Claude-v3 reach for it implicitly whenever they want disciplined commit hygiene integrated with session reasoning capture.499installs17Rememberremember is a parcadei/continuous-claude-v3 skill that persists agent learnings through a /remember command, optionally tagged by type such as WORKING_SOLUTION, ARCHITECTURAL_DECISION, or FAILED_APPROACH. Entries are stored in PostgreSQL with BGE embeddings so future sessions can recall project context, user preferences, and prior decisions without repeating explanations. Developers reach for remember when long-running Claude workflows keep rediscovering the same constraints, re-attempting failed commands, or losing architectural rationale between terminals. The skill turns session-local chat into durable institutional memory that compounds across iterations instead of resetting every time the agent restarts.499installs18Ast Grep Findast-grep-find is a structural code search skill from parcadei/continuous-claude-v3 that routes queries through ast-grep MCP and a Python harness script. Developers invoke it with uv run python -m runtime.harness scripts/ast_grep_find.py, passing --pattern and --language flags to locate imports, function calls, class definitions, and rename targets while ignoring strings and comments. The skill limits allowed tools to Bash and Read, making it suited for agent-driven refactors and large-repo audits where grep or ripgrep produce false positives. Reach for ast-grep-find when you need AST-precision renames or pattern scans across Python and other ast-grep-supported languages during code review or migration work.497installs19Perplexity Searchperplexity-search is a parcadei/continuous-claude-v3 skill integrating Perplexity AI search into Claude or Cursor via Bash and Read tools. It supports direct ranked web results, AI-synthesized research with citations, chain-of-thought reasoning, and deep comprehensive research modes. Documented 2025 models include sonar for lightweight grounding, sonar-pro for complex queries, sonar-reasoning-pro for step-by-step reasoning, and sonar-deep-research for expert-level reports. Developers invoke perplexity-search when documentation is stale, comparing frameworks, verifying API behavior, or needing cited external context the local codebase cannot supply.497installs20Planning Agentplanning-agent is a Claude Code subagent skill in parcadei/continuous-claude-v3 that researches a codebase, writes implementation plans, and produces handoffs before build work begins. The agent reads conversation context, continuity ledgers, and brownfield codebase maps from scout or pathfinder, then spawns parallel exploration agents to gather dependencies and patterns. Finished plans land in thoughts/shared/plans/PLAN-.md while handoff summaries go to thoughts/handoffs/ as plan-.md files for downstream kraken or build agents. The skill activates inside Continuous Claude v3's /build workflow alongside other specialized agents, preserving session state across context compaction. Reach for planning-agent when a feature request needs a researched, file-level implementation plan instead of immediate coding. Skip planning-agent for one-line fixes, typo edits, or tasks where the implementation path is already obvious. planning-agent fits brownfield repos needing codebase research and greenfield projects that still benefit from structured sequencing.497installs21Repo Research Analystrepo-research-analyst is a skill in parcadei/continuous-claude-v3 that acts as a repository research analyst spawned with a local repository path and an optional research focus. It conducts systematic exploration to uncover project patterns, documentation structures, coding guidelines, and conventions before you commit to a build plan. The skill instructs agents to treat the current year as 2025 when searching for recent framework documentation, keeping recommendations aligned with up-to-date practices. Developers reach for repo-research-analyst when onboarding to a monorepo, evaluating a fork, or preparing a PR strategy and need structured findings instead of ad-hoc file grepping. Output is a research-oriented summary of how the repo is organized, which subsystems matter for the stated focus, and which conventions must be respected during implementation.493installs22Agent Context Isolationagent-context-isolation is a Claude Code skill from parcadei/continuous-claude-v3 that keeps the primary context window clean during multi-agent work. It instructs agents to launch background Tasks with run_in_background=true, write results to files under .claude/cache/agents/<agent-type>/, and have the main session read those files instead of ingesting full subagent transcripts. The skill marks user-invocable as false because it applies as an always-on coordination rule. Developers reach for agent-context-isolation when parallel subagents, long-running reviews, or cross-project Claude sessions start exhausting context or mixing unrelated output.492installs23Continuity Ledgercontinuity-ledger is a parcadei/continuous-claude-v3 skill designed to preserve perfect context and decision history across long Claude Code sessions so agents never lose architectural choices, open questions, or partial implementation state after compaction. Developers invoke continuity-ledger during multi-hour refactors, sprawling bug hunts, or multi-day feature branches where default context windows drop earlier rationale. The skill fits the continuous-claude workflow family focused on session persistence rather than one-shot code generation. It helps agents record what was decided, why alternatives were rejected, and which files remain in flux—creating a durable ledger agents reload after breaks. Reach for continuity-ledger when session restarts, context limits, or parallel agent handoffs risk erasing critical thread memory mid-project. The ledger captures rejected alternatives and in-progress file lists so resumed sessions avoid re-litigating settled decisions. continuity-ledger pairs with continuous-claude-v3 orchestration when parallel Task handoffs or overnight agent runs would otherwise drop rationale from earlier turns.490installs24Hookshooks is a skill from parcadei/continuous-claude-v3 that documents Hook Development Rules for Claude Code. The pattern pipes stdin through a shell wrapper that runs `npx tsx` on a TypeScript handler inside `.claude/hooks/`. Handlers parse JSON HookInput, return `continue` or `block` results, and optionally emit system reminders. Developers reach for it when automating guardrails, reminders, or validations at hook events during long coding sessions. The skill is not user-invocable directly; it guides file edits in the hooks directory. Use it when extending Claude Code with event-driven automation.490installs25Reviewreview is the /review workflow skill in parcadei/continuous-claude-v3 that coordinates multi-perspective code review with parallel specialists. A critic agent reviews implementation code while a plan-reviewer evaluates plan alignment; outputs merge in a review-agent synthesis step. Triggers include requests to review code, review a PR, check changes before merge, or run quality gates on significant diffs. The ASCII workflow diagram documents three roles—critic, plan-reviewer, and review-agent—so agents do not collapse architecture and implementation concerns into a single pass. Developers reach for review when they want continuous, structured feedback comparable to a small review committee instead of one generic lint or chat pass. It is designed to run before merging substantial feature branches or refactors where missed plan drift or edge-case bugs are costly.489installs26Debugdebug is a parcadei/continuous-claude-v3 read-only investigation skill for bootstrapping debugging sessions during manual testing or implementation. When invoked with a plan or ticket file, debug examines logs, database state, and git history to understand what went wrong without modifying source files—preserving the primary agent window context. Developers reach for debug when encountering error messages, unexpected behavior during feature testing, or agent loop failures that need structured root-cause analysis. The skill asks targeted questions about expected versus actual behavior, then investigates system state to narrow the failure surface before proposing fixes in a separate editing session.486installs27Parallel Agentsparallel-agents is a parcadei/continuous-claude-v3 skill for parallel agent orchestration in Claude Code. It mandates `run_in_background: true`, forbids TaskOutput calls that return full agent transcripts into parent context, and uses file-based confirmation where agents append completion status to shared files instead of streaming large return values. The pattern supports simple confirmation batches and scalable parallel work across repo areas. Developers invoke parallel-agents when a large refactor, multi-module feature, or broad exploration can be split across concurrent agents while keeping the orchestrator context lean and recoverable from disk artifacts.486installs28Compound Learningscompound-learnings is a parcadei/continuous-claude-v3 skill that turns ephemeral session insights into permanent agent capabilities. It gathers learnings from recent work, identifies patterns that repeat across tasks, and recommends or writes durable artifacts such as SKILL.md files, Cursor rules, and sub-agent definitions. Allowed tools include Read, Glob, Grep, Write, Edit, Bash, and AskUserQuestion, so the skill can scan session history and materialize new configuration. Developers reach for compound-learnings after finishing a feature arc, debugging marathon, or repo onboarding when they notice the same corrections happening twice. Trigger phrases include improve my setup, learn from sessions, compound learnings, and what patterns should become skills. The outcome is a compounding agent toolchain instead of one-off chat memory.484installs29Create Handoffcreate-handoff is a parcadei Continuous-Claude-v3 skill that snapshots active development context into YAML handoffs for the next agent session. Handoffs save under `thoughts/shared/handoffs/{session-name}/` with required fields `goal`, `now`, `done_this_session`, `blockers`, and file lists—roughly 400 tokens versus ~2000 for equivalent markdown. Sessions mark outcomes as SUCCEEDED, PARTIAL_PLUS, PARTIAL_MINUS, or FAILED before `/resume_handoff` reloads state. Developers invoke create-handoff at stopping points, before context auto-compact near 90% capacity, or when ending a coding day. The skill integrates with PreCompact hooks and pairs with resume_handoff and recall skills in the same continuity ledger system.483installs30Hook Developerhook-developer from continuous-claude-v3 is the authoritative Claude Code hooks reference for developers extending agent behavior. It documents when each hook fires, whether it can block tool execution, and primary use cases in a quick-reference table covering PreToolUse and PostToolUse among others. Developers use hook-developer when creating hooks, debugging input/output formats, registering hooks in settings.json, or learning which hooks block versus inject context. The skill ensures custom developer workflows trigger automatically at the correct moment during long-running sessions.483installs31Proveprove is a high-priority skill from parcadei/continuous-claude-v3 invoked via `/prove` with triggers including verify, show that, is it true, and formalize. It runs five phases: RESEARCH before Lean, DESIGN with sorry skeletons, TEST via counterexample search, IMPLEMENT by filling sorries, and VERIFY through proof audit. Prerequisites require Lean4 via the lake toolchain, installable through elan if missing. Allowed tools span Bash, Read, Write, Edit, WebSearch, WebFetch, AskUserQuestion, Grep, and Glob. prove targets mathematicians and engineers who want machine-checked guarantees rather than informal arguments, using /loogle-search for Mathlib type-signature discovery during research. With 455 installs on skills.sh from a 3.9K-star repository, prove automates checkpoints across phases so users avoid learning Lean syntax while still receiving verified proof artifacts.483installs32Testtest is the /test comprehensive testing workflow skill from parcadei/continuous-claude-v3. It orchestrates a multi-stage pipeline: diagnostics for type checking, parallel arbiter runs for unit tests alongside integration tests, then atlas for end-to-end verification. Developers invoke it with phrases like run all tests, test the feature, verify everything works, or full test suite—typically before releases, merges, or after major changes. The parallel execution model reduces wall-clock time compared to sequential unit-then-integration runs. test consolidates scattered test commands into one agent-routed workflow so verification coverage spans type safety, isolated units, service integration, and browser or API E2E paths.482installs33Research Externalresearch-external from continuous-claude-v3 is an external research workflow invoked as /research-external with optional focus and flags. It researches documentation, web pages, and APIs for libraries, best practices, and general topics—not local codebase exploration. The skill uses Bash, Read, Write, and Task tools under a sonnet model and guides users through phased AskUserQuestion flows when arguments are partial. Documentation anchors best practices to 2024–2025. Developers reach for research-external when competitor intel, API docs, or market signals must be collected autonomously mid-flow.481installs34Background Agent Pingsbackground-agent-pings is a non-user-invocable Claude Code skill from parcadei/continuous-claude-v3 that defines a trust-the-reminder pattern for background agent orchestration. When a developer launches Task with run_in_background=true and specifies an output path such as .claude/cache/agents/<type>/output.md, the skill instructs the agent to immediately continue unrelated work rather than poll. System reminders surface progress signals—new tools used, token counts, and output-file writes—so the agent checks the output file only when notified. Developers reach for background-agent-pings when running parallel specialist subagents during long builds, refactors, or research without blocking the primary session thread.480installs35Debug Hooksdebug-hooks is a Claude Code skill from parcadei/continuous-claude-v3 with allowed tools Bash, Read, and Grep that walks developers through hook failure diagnosis. The workflow starts by observing before editing: list .claude/cache directories, inspect learnings outputs, and tail debug logs. It targets common triggers such as hooks not firing, PostToolUse not triggering, SessionEnd failures, and unexpected hook output. Developers reach for debug-hooks when Claude Code automation stops behaving after hook changes, rather than guessing at hook script edits. The observe-first pattern reduces false fixes and surfaces whether the problem is configuration, path, or event-type related.480installs36Describe Prdescribe-pr is a skill in parcadei/continuous-claude-v3 aimed at generating accurate, structured pull request descriptions from repository changes. Instead of developers manually summarizing diffs, context, and impact, the skill produces review-ready PR bodies that capture what changed and why. It fits the pre-merge ship workflow when opening or updating pull requests on GitHub or similar hosts. Developers reach for describe-pr when they have substantive code changes but lack time or discipline to write clear PR narratives. The skill reduces reviewer friction by standardizing change summaries, risk notes, and testing context in one structured document.478installs37Braintrust Tracingbraintrust-tracing is a non-user-invocable skill from parcadei/continuous-claude-v3 that explains how Claude Code sessions export traces to Braintrust, including sub-agent correlation limits and workarounds. It diagrams hook flow from SessionStart through UserPromptSubmit, PreToolUse, PostToolUse, Stop, SubagentStop, and SessionEnd, showing how root spans, turn spans, LLM spans, and tool spans nest. The skill clarifies that SessionStart does not receive injected Task prompt context, while parent-session Task spans retain agentId, token counts, tool_use metrics, and full sub-agent summaries. Developers reference braintrust-tracing when wiring Braintrust observability, diagnosing missing sub-agent parent links, or understanding span fields like root_span_id and session_id. With 459 installs on skills.sh from a 3.9K-star continuous-claude-v3 repository, braintrust-tracing is architecture documentation for agent telemetry—not a standalone tracing SDK.476installs38Implement Planimplement_plan is a development workflow skill in the continuous-claude-v3 suite for turning plans into executed work. Developers invoke implement_plan when a specification or step list already exists and the agent should carry out implementation tasks in order rather than improvising scope. The skill fits plan-driven coding sessions where breaking work into tracked steps improves consistency across long agent runs. Use implement_plan after planning is complete and concrete development tasks need systematic execution.476installs39Tldr Codetldr-code is a Bash-allowed skill in parcadei/continuous-claude-v3 that routes agents through the tldr CLI instead of reading entire files. It documents a five-layer analysis stack—AST signatures, cross-file call graphs, CFG complexity, DFG variable flow, and PDG slicing—totaling about 1,200 tokens versus roughly 23,000 tokens for raw reads, a stated 95% savings. Commands cover tldr tree, structure, search, calls, impact, cfg, dfg, slice, dead, arch, imports, importers, change-impact --git, diagnostics, and semantic search for natural-language queries like authentication flow. Keyword triggers include debug, refactor, call graph, dead code, and architecture exploration. Developers reach for tldr-code when Claude agents must map unfamiliar repos, trace who-calls-what, find dead code, or assess git change impact without blowing context limits on large TypeScript or Python trees during refactors, onboarding, or incident response.475installs40Recallrecall is a non-user-invocable memory skill in continuous-claude-v3 that runs semantic search against stored learnings and returns the top 5 results with full content, learning type, confidence, and session context. Invocation uses /recall <query> and executes recall_learnings via uv run python under $CLAUDE_OPC_DIR with PYTHONPATH set. Example queries include hook development patterns, wizard installation, and TypeScript errors. A developer reaches for recall when an agent should pull prior debugging notes, install steps, or architectural decisions from earlier Claude sessions instead of starting from zero.474installs41Workflow Routerworkflow-router is a goal-based workflow orchestration skill from parcadei/continuous-claude-v3. It acts as a top-level router: when a developer starts a new task without naming a workflow, asks how to approach something, or wants to explore, plan, build, or fix, the skill selects appropriate specialist agents and allocates resources. Step one determines the user's primary goal, then routes to downstream skills or Task agents. Developers reach for workflow-router at session start or when facing ambiguous multi-step work that could branch into research, implementation, or debugging. It prevents ad-hoc agent selection by encoding a consistent goal-to-workflow mapping across complex coding sessions.474installs42Mcp Scriptsmcp-scripts is a parcadei/continuous-claude-v3 agent skill with 458 skills.sh installs that defines rules for Python files under scripts/. Scripts must accept all parameters via argparse CLI arguments, include a USAGE docstring at the top, call tools through call_mcp_tool("server__tool", params), handle errors with informative messages, and print results to stdout for Claude to parse. Hardcoding parameters or importing directly from servers/ is forbidden—scripts must use runtime.mcp_client instead. Tool IDs follow a double-underscore convention such as morph__warpgrep_codebase_search or perplexity__perplexity_ask. Testing uses uv run python -m runtime.harness scripts/<file>.py --help. Developers reach for mcp-scripts when adding or editing automation scripts that wrap MCP servers inside the Continuous Claude v3 harness.473installs43Opc Architectureopc-architecture is a non-user-invocable skill in parcadei/continuous-claude-v3 explaining OPC (Orchestrated Parallel Claude), which extends Claude Code CLI without replacing it. Claude Code remains the execution engine while OPC adds four coordination layers: hooks intercepting PreToolUse, PostToolUse, and SessionStart events; skills loaded from .claude/skills/; scripts under opc/scripts/; and a PostgreSQL database storing PIDs and agent state across instances. Spawning an agent means a PreToolUse hook fires on Task, then subprocess.Popen runs claude -p as a child process that reads and writes .claude/cache/agents/ while broadcasting completion to PostgreSQL. The skill clarifies OPC is not a separate app and does not intercept API calls—it is hook registration in settings.json plus docker-compose PostgreSQL, Redis, and PgBouncer. Developers reach for opc-architecture when wiring Continuous-Claude-v3, debugging parallel agents, or avoiding duplicate spawn paths that leave Task tool and claude -p implementations running in parallel.473installs44Helphelp is a high-priority, user-invocable skill from parcadei/continuous-claude-v3 triggered by help, what can you do, show capabilities, or how do I. Running `/help` starts interactive guided discovery; subcommands include `/help workflows` for orchestration skills, `/help agents` for the specialist catalog, `/help tools` for CLI utilities like tldr, prove, and recall, `/help hooks` for active hook behavior, `/help advanced` for MCP and frontmatter customization, and `/help <name>` for deep dives on a specific skill or agent. Allowed tools include AskUserQuestion, Bash, Read, Glob, and Grep so the skill can inspect the live workspace. With 455 installs on skills.sh, help is the orientation layer for engineers who inherit a continuous-claude-v3 repo and need a map of available automation before choosing /build or /research workflows.471installs45Slash Commandsslash-commands is a continuous-claude-v3 reference for Claude Code slash command authoring and usage. It explains how to create user-triggered prompts with /command-name syntax, embed bash execution, reference files, and distinguish slash commands from skills. The skill catalogs built-in commands including /clear, /compact, /config, and /cost for history, settings, and token usage. Developers reach for slash-commands when standardizing quick prompts, wiring bash into repeatable agent actions, or deciding between slash commands and skills for a workflow.471installs46Completion Checkcompletion-check is a non-user-invocable skill in parcadei/continuous-claude-v3 that stops agents from marking infrastructure done when code exists but never runs. It instructs tracing execution from user intent through grep patterns such as Task( and claude -p, confirming hooks are registered in .claude/settings.json—not only present under .claude/hooks/, validating PostgreSQL connection strings instead of stray sqlite: usage, and running end-to-end tests with debug logs. A six-item completion checklist covers path tracing, hook registration, backend confirmation, E2E invocation, dead-code searches, and configuration alignment. Worked examples contrast a BeadsTaskGraph that compiles but never replaces Task tool spawning with a wired flow where subprocess agents execute and PostgreSQL stores PIDs. Reach for completion-check after building OPC hooks, coordination scripts, or database backends when agents might confuse implemented with connected. The skill pairs naturally with opc-architecture in the same repository.470installs47Firecrawl Scrapefirecrawl-scrape is a Claude Code skill in parcadei/continuous-claude-v3 that runs a Python harness against Firecrawl MCP to scrape pages or run web searches on demand. Developers pass `--url` for a direct page or `--search` for query-based retrieval, then choose `--format` as markdown (default), html, or text. The workflow uses `uv run python -m runtime.harness scripts/mcp/firecrawl_scrape.py` with Bash and Read tools, making it suited when agents need structured page content for RAG, docs ingestion, or competitive research without hand-writing scrapers.470installs48Search Toolssearch-tools is a continuous-claude-v3 skill defining a search tool hierarchy for agent-assisted development. Conceptual or architectural questions route to LEANN embedding-based semantic search with PreToolUse auto-redirect from semantic Grep queries. Structural lookups—function calls, class usages, refactor patterns—use AST-grep. Plain text search prefers Morph, described as 20x faster than Grep, with Grep as fallback when no Morph API key exists. Developers reach for search-tools when agents waste tokens on the wrong search primitive or need a consistent decision tree for codebase exploration.470installs49Cli Referencecli-reference is a complete Claude Code command-line reference skill with allowed-tools limited to Read. It documents core commands including interactive `claude`, one-shot `claude "query"`, and headless SDK mode `claude -p "query"`, plus flags for output formats, system prompts, and proper agent spawning. Developers invoke it when asking what CLI flags exist, how headless mode works, how to run Claude in CI/CD, or how to configure output format options. The skill keeps automation accurate by surfacing official usage patterns instead of guessed flags. Use cli-reference whenever terminal or pipeline scripts need reliable Claude Code invocation without leaving the shell or breaking continuous deployment jobs.469installs50Math Routermath-router is a high-priority, non-user-invocable router for the continuous-claude-v3 math cognitive stack. Instead of loading individual math skill documentation, an agent runs uv run python scripts/cc_math/math_router.py route "<user's math request>" to receive the exact downstream CLI command. Triggers include math, calculate, compute, solve, integrate, derivative, plot, convert, and prove, and the readme mandates using this router first for any math request. A developer reaches for math-router when wiring agents that must deterministically dispatch calculus, plotting, unit conversion, or proof tasks without guessing command strings.469installs51Skill Upgraderskill-upgrader is a meta-skill from continuous-claude-v3 that upgrades any SKILL.md to the Decision Theory v5 Hybrid format using decision theory and modal logic. It runs four parallel Ragie-backed agents and expects indexed Ragie partitions for decision-theory texts (LaValle Planning Algorithms, Sutton and Barto RL) and modal-logic references (Blackburn Modal Logic, Huth and Ryan Logic in CS). Developers reach for skill-upgrader when asked to 'upgrade this skill to v5', formalize a skill with decision theory, or add MDP structure to an existing skill. Allowed tools include Bash, Read, Write, Edit, Task, Glob, and Grep for rewriting skill files in place.469installs52Buildbuild is a user-invocable workflow orchestrator from parcadei/continuous-claude-v3 invoked as `/build <mode> [options] [description]`. It chains existing skills in sequence—greenfield runs discovery through plan, validate, implement, commit, and PR; brownfield adds onboard and research before planning; TDD routes through test-driven-development; refactor chains impact analysis, plan, TDD, and implement. When called without arguments, build runs an AskUserQuestion flow across workflow selection, project context, and requirements clarity to infer the right configuration. The orchestrator passes handoffs between skills and pauses for human approval at phase boundaries rather than executing a single atomic task. With 456 installs on skills.sh, build is the entry point for structured feature delivery inside continuous-claude-v3 workspaces where ad-hoc prompting would skip validation or onboarding steps.467installs53Skill Developerskill-developer is a parcadei/continuous-claude-v3 meta-skill for creating and managing Claude Code skills, including skills that wrap MCP pipelines. It documents the required .claude/skills/<skill-name>/ layout with SKILL.md, optional scripts/, and templates/ folders, plus YAML frontmatter conventions for name, description, and allowed-tools such as Bash, Read, Write, and Edit. Developers reach for skill-developer when prompts like "create a skill for X", "turn this script into a skill", or "how do I create a skill?" appear during agent extension work. The skill walks agents through SKILL.md format, supporting file structure, and packaging patterns so new capabilities install consistently across Claude Code sessions. Catalog metadata lists 440 installs on Skillselion. skill-developer fits continuous-claude workflows where durable agent tooling must ship as versioned skill folders rather than ephemeral chat instructions. Agents use it to convert bash scripts, reference docs, and MCP tool chains into invocable skills teammates can share.467installs54Complete Skillcomplete-skill: A skill for development. This provides functionality for development workflows.466installs55Idempotent Redundancyidempotent-redundancy is a Code Review & Quality skill from parcadei/continuous-claude-v3 (user-invocable: false) that agents apply when adding redundant paths such as fallbacks and repair hooks. The skill mandates idempotent operations: use _is_merge for Braintrust updates, check values before writing in fallbacks, atomic write/rename for files, and reconciliation steps safe to run repeatedly. It explicitly forbids unconditional writes in fallback paths, competing writers, and repair actions that trigger more repairs. Developers reach for idempotent-redundancy when agents add belt-and-suspenders logic that must not cause loops, churn, or data corruption on repeated execution.466installs56Morph Searchmorph-search is a continuous-claude-v3 skill for fast AI-powered codebase search using WarpGrep. README states it is 20x faster than traditional grep for finding patterns, function names, and variables across large repositories. Commands run through uv run python -m runtime.harness scripts/mcp/morph_search.py with --search and --path flags, supporting plain text and regex queries such as def.*login. The skill also supports programmatic file edits via the same harness. Allowed tools are Bash and Read. Developers reach for morph-search when agents must scan monorepos quickly or locate symbols before refactors without slow recursive grep.466installs57Shapely Computeshapely-compute is a Python-focused agent skill for computational geometry using the Shapely library. The skill covers creating points, lines, and polygons, running boolean operations such as intersection, union, and difference, evaluating spatial predicates like contains and intersects, and computing area, length, distance, centroid, and convex hull. Developers also get guidance on geometry transformations including translate, rotate, scale, and buffer, plus validating and repairing invalid geometries. Trigger phrases include geometry, polygon, intersection, WKT, and distance between points. Reach for shapely-compute when an agent must generate correct Shapely code for geospatial features, spatial joins, or map-overlay logic instead of guessing GEOS-backed APIs.466installs58Skill Developmentskill-development is a meta-skill from parcadei/continuous-claude-v3 that standardizes how developers create, version, and expand Claude agent skills. It prescribes SKILL.md structure with a clear When to Use section, copy-paste bash commands, and references to scripts/ for MCP operations. Developers keep each SKILL.md under 200 lines, avoid duplicating content across skills, and register every skill with a corresponding trigger in skill-rules.json. MCP wrapper skills use minimal allowed-tools such as Bash and Read. Reach for skill-development when adding or refactoring skills in a continuous-claude workflow so agents load consistent, triggerable capabilities.466installs59Tldr Overviewtldr-overview is a codebase orientation skill built around the TLDR stack. It runs `tldr tree` for a filtered file tree by extension across Python, TypeScript, Go, and Rust, `tldr structure` to list functions, classes, and imports per file with a default cap of 50 symbols, and `tldr calls` to surface cross-file call-graph entry points. Developers invoke it via `/overview`, `/tldr-overview`, or prompts like "what's in this codebase" when starting on a new repo. The workflow prioritizes token-efficient summaries so agents grasp layout, symbols, and architecture before making edits. Use tldr-overview at the start of onboarding, refactors, or bug hunts where blind file grepping wastes context window.466installs60Onboardonboard is a Claude Code skill from parcadei/continuous-claude-v3 that analyzes brownfield repositories and seeds the project's continuity system before feature work begins. Invoke /onboard or ask to analyze a project; the skill spawns a dedicated onboard subagent via the Task tool with subagent_type onboard so exploration runs in an isolated context window instead of flooding the main session with file dumps. The agent verifies thoughts/ledgers prerequisites, explores structure with rp-cli or bash fallbacks, detects languages from package.json, pyproject.toml, Cargo.toml, or go.mod, asks goal questions via AskUserQuestion, and writes a YAML handoff under thoughts/shared/handoffs/<project>/ plus a CONTINUITY_CLAUDE-<session>.md ledger capturing Goal, Constraints, State, Working Set, and Codebase Summary. Developers reach for onboard when joining an unfamiliar existing codebase after cloning but before implementation, especially within continuous-claude-v3 hook-driven context management where ledgers load automatically on session start. For greenfield work, the skill points to /create_plan instead.465installs61Search Routersearch-router is an AI & Agent Building skill from parcadei/continuous-claude-v3 (user-invocable: false) that implements a decision tree for codebase search. Code exploration queries for symbols, call chains, and data flow default to TLDR Search via tldr search, cited for 95% token savings over Grep. Structural AST pattern queries route to AST-grep, while other query types follow the embedded decision tree. Developers reach for search-router when agents waste tokens on broad Grep scans, need efficient symbol lookup like spawn_agent or DataPoller, or must choose between TLDR Search and AST-grep for structural versus exploratory code queries.465installs62Agentica Claude Proxyagentica-claude-proxy is a continuous-claude-v3 skill for developing and debugging Agentica-Claude proxy integration. Architecture routes Agentica agents through S_M_BASE_URL at localhost:2345 to a Claude proxy at localhost:8080, then claude -p into Claude CLI with tools. The skill covers setup, permission errors in file operations, agent hallucination debugging, and REPL response format requirements including --allowedTools configuration. Allowed tools are Read and Bash per the skill manifest. Developers reach for agentica-claude-proxy when building custom Agentica agents that must invoke Claude Code tools through a local proxy instead of direct API calls.464installs63Commitcommit is a skill from the parcadei/continuous-claude-v3 repository intended for development tasks that require creating Git commits within a continuous agent workflow. The published metadata is minimal—description states to use commit for development tasks—but the skill slug and repo context position it as a Git commit helper alongside other continuous-claude orchestration skills. Developers reach for commit when an agent should stage and record focused changes rather than leaving uncommitted work across a session. Because the bundled readme is empty, treat commit as a thin workflow stub and pair it with onboard or new-branch-and-pr skills for fuller context.464installs64Morph ApplyMorph Apply is a skill in parcadei/continuous-claude-v3 for fast file editing via the Morph Apply API, allowed to use Bash and Read. It processes edits at 10,500 tokens/sec with 98% accuracy and supports batch changes using language-appropriate // ... existing code ... markers to anchor insertions in large files. Developers reach for Morph Apply when the target change is known but reading the full file would consume too many tokens, or when multiple edits must land in one operation. The pattern edits files without a full read-first workflow, optimizing agent throughput on large repositories.464installs65Qlty Checkqlty-check is a parcadei continuous-claude-v3 skill that wraps the qlty CLI for universal code quality checks across 70+ linters and 40+ languages. Agents invoke harness scripts to lint changed files with optional auto-fix, format code, or calculate complexity and duplication metrics before commit or handoff. Commands support checking only diffs, scanning all files, or running format-only passes. Developers reach for qlty-check when they want a single quality tool covering many languages instead of configuring separate ESLint, Prettier, and language-specific linters manually.464installs66Researchresearch is a non-user-invocable skill from parcadei/continuous-claude-v3 that conducts comprehensive codebase research by spawning parallel Task sub-agents and synthesizing findings. It strictly documents what exists—where code lives, how it works, and how components interact—without suggesting improvements, root cause analysis, or refactoring unless explicitly requested. The workflow reads directly mentioned files fully, decomposes the query with TodoWrite, dispatches specialized agents like scout for exploration, thoughts-locator and thoughts-analyzer for historical context, and optionally web-search-researcher or Linear agents when asked. Live codebase findings take priority over thoughts directory history. With 455 installs on skills.sh, research produces technical maps with file paths and line numbers for brownfield onboarding inside continuous-claude-v3, complementing external research-external workflows that target library docs outside the repository.464installs67Braintrust Analyzebraintrust-analyze is a continuous-claude-v3 agent skill for structured evaluation of Claude agent outputs inside Braintrust. It compares responses against golden datasets and custom scoring functions to quantify regressions before deployment. Catalog metadata on skills.sh lists 435 installs and rank 56 for this skill slug. Engineering teams reach for braintrust-analyze when agent prompts, tools, or routing logic change and subjective spot checks are insufficient. The skill fits ship-phase testing for LLM agents where repeatable eval harnesses must run in CI or pre-release workflows.463installs68Fixfix is a Debugging skill from parcadei/continuous-claude-v3 that acts as a meta-skill workflow orchestrator for bug investigation and resolution. Invoked as /fix with scope and description arguments, it guides agents through a question flow when arguments are missing, then chains specialized skills for debugging, implementation, testing, and committing based on issue scope. Allowed tools include Bash, Read, Grep, Write, Edit, and Task. Developers reach for fix when they want a single entry point for defect triage instead of manually selecting debug, patch, test, and commit skills for each bug report.463installs69Loogle Searchloogle-search is a Mathlib search skill from parcadei/continuous-claude-v3 that finds Lean lemmas by type signature pattern instead of by name. Developers run loogle-search with quoted patterns such as "Nontrivial _ ↔ _" or function-type shapes like "(?a → ?b) → List ?a → List ?b", optionally passing --json for structured output. A companion loogle-server command keeps the index in memory for faster repeat queries during proof sessions. Reach for loogle-search when doing type-directed proof search, exploring lemmas available for a type, or pairing unknown type shapes with existing Mathlib entries.463installs70Repopromptrepoprompt is a skill from parcadei/continuous-claude-v3 that directs agents to the RepoPrompt CLI for token-efficient codebase exploration with Bash and Read tools. It uses `structure` for signature-only codemaps instead of full file content, `read --start-line --limit` for line-range slices, and `search --context-lines` for contextual code matches. Developers reach for repoprompt when large repositories would exhaust context windows through naive file reads and agents need tree views, code signatures, or targeted slices to build task context before editing.463installs71Mcp Chainingmcp-chaining is a continuous-claude-v3 skill describing an end-to-end research-to-implement MCP pipeline. It chains 5 MCP tools across servers—including nia documentation search—with graceful degradation when a server or credential is unavailable. The skill covers tool naming conventions, environment variable debugging, and when to compose multi-tool calls versus single-server usage. Developers reach for mcp-chaining when designing agent pipelines that hand context between MCP servers or debugging chained MCP failures in Bash-backed workflows.462installs72Pint Computepint-compute is a skill from parcadei/continuous-claude-v3 that acts as cognitive prosthetics for unit-aware computation using the Pint Python library. Allowed tools are Bash and Read. It covers converting meters to feet, kilograms to pounds, velocity-times-time distance checks, dimensional compatibility validation such as force equals mass times acceleration, and simplifying compound units to base or named units. Developers reach for pint-compute when agents might silently mix units in scientific, engineering, or data pipeline code and need explicit Pint commands instead of hand-rolled conversion factors.462installs73Wiringwiring is a parcadei/continuous-claude-v3 Wiring Verification skill (user-invocable: false) that ensures infrastructure components are actually invoked in the execution path before agents mark work complete. It enforces a four-step wiring check: confirm an entry point exists, trace the call graph from trigger to execution, verify an end-to-end integration test exercises the path, and confirm no built component remains unreachable dead code. Developers reach for wiring when middleware, hooks, background workers, or plugin loaders risk shipping without a traced invocation chain. The skill states dead code is worse than no code because it creates maintenance burden and false confidence. Catalog metadata lists 440 installs. wiring fits continuous-claude agent workflows where infrastructure PRs need explicit reachability proof instead of file-existence checks. Agents apply it during code review and pre-merge verification when modules claim to be wired but lack demonstrated execution paths or integration coverage.462installs74Migratemigrate is an agent skill that updates existing Claude Code and Continuous Claude v3 projects to the current recommended structure and conventions. It scans your skill repository, rewrites deprecated patterns, updates MCP server configurations, and ensures compatibility with the latest agent tooling standards. Designed for solo builders maintaining multiple skills, it prevents version drift and reduces manual refactoring time when new Claude capabilities are released. The skill performs intelligent transformations while keeping your custom business logic intact.461installs75Qlty During Developmentqlty-during-development is a Code Review & Quality skill from parcadei/continuous-claude-v3 (user-invocable: false) that integrates the QLTY CLI into the code-writing workflow. Agents run qlty check after completing new files or substantial edits, fix reported errors, then run qlty fmt for formatting— including targeted checks like qlty check src/sdk/providers.ts and auto-fix with qlty check --fix. The skill specifies when not to run checks to avoid noise on trivial edits. Developers reach for qlty-during-development when agents write code incrementally and need lint and format gates embedded in the development loop rather than only at CI time.461installs76Reference Sdkreference-sdk is a continuous-claude-v3 skill that gives Claude persistent, version-controlled access to official SDK reference documentation through btca ask without leaving the IDE. Developers invoke it when implementing SDK features, debugging provider-specific issues, or comparing how libraries like Vercel AI SDK or Anthropic SDK solve streaming, tool calling, and similar patterns. Example commands include btca ask -r vercel-ai for streamObject patterns and btca ask -r anthropic for tool-calling behavior. The skill is not user-invocable directly and fires during SDK integration tasks.461installs77Tldr Deeptldr-deep: A skill for development. This provides functionality for development workflows.461installs78Observe Before Editingobserve-before-editing is a non-user-invocable skill from parcadei/continuous-claude-v3 that enforces an evidence-first debugging pattern: check directories with `ls`, verify expected files under `.claude/cache/`, tail logs for errors, and rerun failing commands manually before touching source code. The core principle is that outputs do not lie while code assumptions often do. It explicitly warns against editing based on what should happen, assuming hooks did not run without checking artifacts, and confusing global versus project paths. Developers reach for observe-before-editing when agents jump to code changes without confirming what the system actually produced.460installs79Agentica Promptsagentica-prompts is a Claude Code skill from parcadei/continuous-claude-v3 for writing prompts that Agentica agents follow consistently instead of drifting on ambiguous instructions. The skill documents an orchestration pattern—research to .claude/cache/agents/research/, plan via RP-CLI to plan/, validate against best practices, then implement with TDD—that preserves context across steps. It cites that standard natural language prompts fail about 35% of the time due to LLM instruction ambiguity. Developers reach for agentica-prompts when orchestrating multi-agent coding workflows, hardening Agentica REPL harness prompts, or cutting hallucinations during research-plan-implement cycles.459installs80No Polling Agentsno-polling-agents is a parcadei continuous-claude-v3 skill that instructs agents how to launch parallel background workers without wasteful polling loops. Background agents write to status files on completion while the parent continues other work, checking results only when needed or when the user asks. The skill explicitly forbids sleep-and-cat polling patterns that burn tokens and block progress. Developers reach for no-polling-agents when running multiple background agents on complex tasks and wanting Claude to stay productive instead of repeatedly checking status files in tight loops.459installs81No Task Outputno-task-output is a parcadei/continuous-claude-v3 agent skill marked user-invocable false that enforces a strict rule: never use the TaskOutput tool. TaskOutput reads full background agent transcripts into the main context window, often exceeding 70k tokens and triggering mid-conversation compaction that defeats agent context isolation. The correct pattern runs Task with run_in_background=false so the subagent returns only a summary synchronously. Developers and agent configurations reach for no-task-output when wiring Continuous-Claude multi-agent workflows where background TaskOutput polling would flood parent sessions and erase carefully isolated subagent work.459installs82Releaserelease is a continuous-claude-v3 /release workflow that prepares production deployments through a fixed five-stage pipeline: aegis security audit, atlas E2E tests, review-agent code review, herald changelog generation, and scribe documentation updates. Developers invoke release when cutting a version, shipping to production, or validating readiness before deploy. The skill chains specialized sub-skills in sequence so security, testing, review, and release notes are completed before launch. release fits teams using continuous-claude-v3 who want a repeatable pre-deploy checklist instead of ad-hoc release steps.459installs83Explicit Identityexplicit-identity is a non-user-invocable Claude Code skill teaching the Explicit Identity Across Boundaries pattern. It instructs agents never to rely on "latest" or "current" identifiers when crossing process or async boundaries because most-recent lookups are race conditions. Developers pass `--session-id $ID` when spawning processes, store IDs in state files for later correlation, use full UUIDs instead of partial matches, and keep different ID types separate rather than collapsing concepts. The skill lists anti-patterns such as querying for the most recent session at execution time or assuming context survives after await or spawn. Use explicit-identity when building Continuous Claude-style multi-agent handoff pipelines where session, task, and process IDs must remain stable.458installs84Implement Plan Microimplement_plan_micro is a continuous-claude-v3 skill at version 3.0 that implements technical plans stored under thoughts/shared/plans with built-in verification gates. The formal specification fuses five modal logics—Justification Logic, Inferential Erotetic Logic, Temporal Epistemic Logic, Standard Deontic Logic, and Dynamic Epistemic Logic—to sequence phases, justify handoffs, and verify obligations before advancing. The skill is not user-invocable directly and is designed to keep Claude changes incremental without losing task context or scope. Developers reach for implement_plan_micro when a written plan exists and needs disciplined, evidence-backed execution.458installs85Parallel Agent Contractsparallel-agent-contracts is an orchestration skill from parcadei/continuous-claude-v3 for launching multiple Claude agents on shared TypeScript codebases without type duplication. Every agent prompt must include a verification step running npx tsc --noEmit and a grep-before-create rule that searches src/ for existing interface or type aliases before defining new ones. Developers reach for parallel-agent-contracts when splitting implementation across parallel agents and seeing repeated types, import conflicts, or type errors after concurrent edits. The skill is user-invocable false and encodes copy-paste markdown blocks agents embed directly into worker prompts.458installs86Resume Handoffresume-handoff is a Claude Code skill in parcadei/continuous-claude-v3 for continuing multi-step agent work after interruptions without restarting research or planning from scratch. The skill fits the continuous-claude orchestration model where staged outputs land under .claude/cache/agents/ paths and later sessions must pick up validated plans or partial implementations. Developers reach for resume-handoff when a long Agentica or Claude Code session ends mid-workflow, a new agent needs prior context, or handoff between specialized skills must preserve artifacts from research, RP-CLI planning, and TDD implementation steps.458installs87Tldr Routertldr-router is a parcadei/continuous-claude-v3 smart router that picks the right tldr command for a developer question. It maps file and function discovery to tldr tree and tldr structure, call relationship queries to tldr context and tldr calls, and complexity checks to tldr cfg. Example invocations include tldr tree with --ext filters, tldr structure src/ --lang python for class overview, tldr context with --depth for call chains, and tldr cfg for cyclomatic complexity of a function. Developers and coding agents reach for tldr-router at the start of repo exploration or architecture triage when manual grep would be slower than layered tldr commands.458installs88Async Repl Protocolasync-repl-protocol is a Claude Code skill from parcadei/continuous-claude-v3 for correct usage of Agentica's async REPL testing harness. The skill requires await on Future-returning tools like view_file and ask_memory, and mandates a single Python code block per response because only the first block executes—split blocks leave later statements unreachable. Developers reach for async-repl-protocol when Agentica REPL tests silently skip logic, async file reads return coroutine objects, or multi-block responses fail to run follow-up computations during harness-driven agent validation.457installs89Search Hierarchysearch-hierarchy is a continuous-claude-v3 skill that picks the most token-efficient search tool for each codebase query type. Structural pattern queries like def foo, class Bar, import X, or @decorator go to AST-grep with roughly 50 tokens of output. Semantic conceptual questions route to LEANN at about 100 tokens when path-only results suffice. Literal identifier lookups use Grep, and full-context understanding falls back to Read at 1500+ tokens as a last resort. Developers reach for search-hierarchy when agents burn context on naive full-file reads.457installs90TourTour is a Claude Code onboarding skill from parcadei/continuous-claude-v3 that activates on prompts like “what can you do?”, “help me get started”, and “show me around”. It returns a warm, practical overview of code editing, debugging, refactoring, and specialized agent capabilities so developers understand available tools before diving into tasks. The skill uses a fixed response template covering development, research, and workflow features rather than executing commands itself. Reach for Tour when spinning up a new Claude-powered workspace, evaluating a fresh skill bundle, or onboarding teammates who need a concise map of what the agent can handle.457installs91Validate Agentvalidate-agent is a Claude Code validation agent spawned to review an implementation plan before coding begins. It receives plan content, the plan file path, and a handoff directory, then researches external sources to confirm framework, library, and architecture choices match 2024-2025 best practices with the current year set to 2025. The agent outputs a validation handoff document summarizing whether proposed tech is sound, outdated, or risky. Developers use validate-agent after drafting a multi-step plan and before spawning implementation tasks, especially when the plan picks new libraries, auth patterns, or infra tools. The skill prevents agents from executing plans built on deprecated stacks or mismatched patterns.457installs92Environment Triageenvironment-triage is a Claude Code skill from parcadei/continuous-claude-v3 for debugging Python dependency issues caused by interpreter mismatches rather than missing packages. The skill runs uv run python --version, inspects .python-version pins that control uv's interpreter, verifies installs with uv pip show, and confirms imports via uv run python -c. A common fix bumps .python-version to 3.12+ when optional deps require newer Python than a 3.11 pin. Developers reach for environment-triage when uv sync behaves unexpectedly, imports fail despite pip reporting success, or system Python disagrees with the uv-selected virtual environment.456installs93Agentica Infrastructureagentica-infrastructure is a read-only reference skill in parcadei/continuous-claude-v3 for the Agentica multi-agent coordination framework. It catalogs 11 pattern classes—including Swarm, Pipeline, Jury, GeneratorCritic, MapReduce, Blackboard, and EventDriven—with constructor signatures and key methods, plus six core components such as CoordinationDB, tracked_spawn, HandoffAtom, BlackboardCache, MemoryService, and create_claude_scope. Five primitives cover Consensus voting modes, Aggregator strategies, HandoffState, build_premise, and gather_fail_fast parallel execution. Developers reach for agentica-infrastructure when implementing or debugging Agentica workflows, inspecting the coordination database schema, or composing custom patterns from scripts/agentica_patterns with exact API_SPEC.md details.455installs94Agentica Serveragentica-server is an internal reference skill in parcadei/continuous-claude-v3 for running Agentica SDK with a local Claude proxy so Python agents call Claude CLI as their LLM backend. The architecture chains Agentica SDK through ClientSessionManager to agentica-server on port 2345, then to claude_proxy.py on port 8080, and finally to claude -p. Environment variables INFERENCE_ENDPOINT_URL and S_M_BASE_URL point to different endpoints—the SDK talks to the session manager while the server forwards inference to the proxy. Startup requires three terminals in order: uv run python scripts/agentica/claude_proxy.py --port 8080, INFERENCE_ENDPOINT_URL=http://localhost:8080/v1/chat/completions uv run agentica-server --port 2345, then S_M_BASE_URL=http://localhost:2345 on the agent script. Developers reach for agentica-server when bootstrapping Agentica, debugging connection failures, or fixing agent tool-access and hallucination issues across the proxy chain.455installs95Llm Tuning Patternsllm-tuning-patterns is a configuration skill from parcadei/continuous-claude-v3 that documents evidence-based LLM settings drawn from APOLLO parity analysis and Godel-Prover research. It prescribes concrete values such as max_tokens 4096, temperature 0.6, and top_p 0.95 for formal reasoning, plus task-specific tables for other workloads. Developers reach for llm-tuning-patterns when agent outputs are too terse, too random, or inconsistent across proof planning, tactic exploration, and implementation prompts. The skill is user-invocable false, so agents load it automatically when tuning generation behavior rather than when browsing docs manually.455installs96Nia Docsnia-docs is a Claude Code skill in parcadei/continuous-claude-v3 that searches library documentation and runnable code examples through a Python harness at scripts/mcp/nia_docs.py. The index spans 3000+ packages across npm, PyPI, Crates, and Go registries, supporting semantic search inside a named package or grep-style pattern lookup when you need exact API signatures. Typical commands run via uv run python -m runtime.harness with --package, --registry, and --query flags—for example querying FastAPI for dependency injection or React on npm for hooks patterns. Developers reach for nia-docs when implementing unfamiliar APIs, comparing framework patterns, or avoiding stale training-data guesses during feature work. The skill allows Bash and Read tools and fits agent workflows that already use uv and the continuous-claude-v3 runtime harness for MCP-style doc retrieval.455installs97Tdd Migratetdd-migrate is a TDD migration orchestration skill from parcadei/continuous-claude-v3 that delegates implementation to subagents while the main session stays lean. Developers invoke it with `/tdd-migrate <source_path> <target_path> --pattern <reference> --items "item1,item2"` to analyze existing code, follow a reference pattern, and produce tested replacements in a target directory. Allowed tools include Task, TodoWrite, Write, Read, and Bash, covering ports like Python-to-TypeScript, adapter batches, and architectural rewrites. Reach for tdd-migrate when similar items must land with tests first and manual copy-paste would flood context or skip coverage.455installs98Tdd Migration Pipelinetdd-migration-pipeline is an orchestrator-only workflow from parcadei/continuous-claude-v3 for migrating or rewriting codebases with test-driven guarantees. The orchestrator never reads files, writes code, or validates directly—it instructs delegated agents and passes paths, not file contents, keeping context growth at zero. Allowed tools are Task, TodoWrite, Read, and Bash. Use it when moving between languages or frameworks, rewriting systems under behavioral contracts, or running large refactors where subagents execute TDD cycles. Core principle: zero orchestrator execution; all implementation and validation happens in delegated workers piped scoped context.455installs99Tldr Statstldr-stats is a diagnostic skill in the parcadei/continuous-claude-v3 stack that executes python3 $CLAUDE_PROJECT_DIR/.claude/scripts/tldr_stats.py and returns a formatted dashboard the agent must paste into chat. The output breaks down dollars spent, input and output tokens, cached reuse, TLDR before/after compression, file-read compression ratios, cache hit rates, active model, hook activity, and a history sparkline across recent sessions. Cost estimates reference published Claude pricing tiers such as Opus $15/1M, Sonnet $3/1M, and Haiku $0.25/1M tokens. Developers reach for tldr-stats when validating whether TLDR hooks are firing, comparing savings before and after enabling compression, or debugging unexpectedly high session spend during long agent runs.455installs100Motmot is a continuous-claude-v3 system health check skill that audits skills, agents, hooks, and the memory system inside a Claude Code workspace. Invoked as /mot with optional scopes like skills, agents, hooks, or memory, mot can run a full audit, a --quick P0-only pass, or --fix to auto-repair simple issues. The skills audit counts SKILL.md files under .claude/skills and reports findings per category. Developers reach for mot when agent tooling drifts, hooks break, or memory configuration needs a structured diagnostic pass.454installs101Agentica Sdkagentica-sdk is a continuous-claude-v3 reference skill for Agentica SDK v0.3.1 that shows how to build Python agents with the @agentic decorator, spawn(), state persistence, tool use, and MCP integration. Allowed tools include Bash, Read, Write, and Edit so agents can scaffold and debug agentic code in place. The skill covers single agentic functions, multi-agent orchestration, and MCP-connected toolchains when adding agent capabilities to existing Python projects. Developers reach for agentica-sdk when implementing new Python agents or debugging agent behavior with the Agentica framework.453installs102Implement Taskimplement_task is a non-user-invocable implementation agent skill in the Continuous Claude v3 stack. When spawned, it receives five inputs: a continuity ledger of session state, the full implementation plan, the specific task to implement, an optional previous task handoff, and a handoff directory path. The agent works with fresh context, completes the assigned task, and writes a handoff document before returning so the next spawned agent can continue. Developers use implement_task as the execution unit after plan validation, breaking large builds into isolated tasks that avoid context window exhaustion. Each cycle produces code changes plus a handoff file capturing what was done and what the following task needs.453installs103System Overviewsystem-overview is a continuous-claude-v3 meta-skill workflow orchestrator for bug investigation and resolution that chains specialized skills based on issue scope. Invoked as /fix with scope, options, and a description, system-overview guides developers through a question flow when arguments are partial and routes work to debug, implement, test, and commit stages. Allowed tools include Bash, Read, Grep, Write, Edit, and Task for end-to-end fix delivery. Developers reach for system-overview when an issue needs structured triage instead of ad-hoc patching.452installs104Agentica Spawnagentica-spawn is a continuous-claude-v3 skill that materializes Agentica multi-agent patterns after agentica-orchestrator collects a pattern choice. It is user-invocable false and runs only once a pattern is selected. Swarm spins parallel perspectives—security, performance, architecture—for research and exploration with MERGE aggregation. Hierarchical assigns coordinator and specialist roles such as planner, implementer, and reviewer for coordinated builds. Generator/Critic loops generation and critique for up to three refinement rounds. Jury convenes five jurors with majority consensus for high-stakes boolean validation. Spawned agents receive SWARM_ID, AGENT_ROLE, and PATTERN_TYPE environment variables for traceability. Developers reach for agentica-spawn when complex tasks benefit from parallel agents, structured handoffs, iterative refinement, or jury-style verification rather than a single monolithic prompt. The skill outputs pattern-specific execution results from async Python Agentica APIs integrated into Claude Code workflows.451installs105Graceful Degradationgraceful-degradation is a Claude Code skill from parcadei/continuous-claude-v3 that codifies resilient integration behavior when optional services are down. The pattern checks service availability before expensive work, caches health results for the session (for example a 60s TTL), and surfaces messages that name the missing service, list degraded features, and explain how to re-enable the dependency. Developers reach for graceful-degradation when building agent hooks, CLI tools, or API layers that call non-critical providers such as search, embeddings, or analytics and must not hard-fail the whole workflow. The skill is user-invocable false, so agents apply it automatically during integration and error-handling tasks rather than as a manual slash command.450installs106Index At Creationindex-at-creation is a Claude Code skill from parcadei/continuous-claude-v3 that prevents stale retrieval by indexing artifacts when they are created instead of at session end or on a schedule. The pattern hooks indexing to the same event that writes the artifact—for example a PostToolUse Write hook right after handoff creation—and uses a `--file` flag for fast single-file indexing rather than deferred batch passes. Developers reach for index-at-creation when agent memory, handoff files, or search indexes must be available to the next tool call in the same session. The skill explicitly warns against SessionEnd batching, cron jobs, or assuming data will appear soon enough for time-sensitive downstream logic.450installs107Tddtdd is a Test-Driven Development agent skill in parcadei/continuous-claude-v3 that guides coding agents through plan, write-tests, implement, and validate cycles instead of bulk test dumps. The workflow enforces vertical tracer bullets—one failing test, minimal code to pass, then refactor—and rejects horizontal slicing where every test is drafted before any implementation. Philosophy sections stress watching tests fail, testing behavior through public APIs, and avoiding implementation-coupled mocks that break on harmless refactors. Companion references cover tests.md, mocking.md, interface-design.md, deep-modules.md, and refactoring.md for deeper patterns agents can load on demand. Developers reach for tdd when implementing features test-first, fixing bugs with regression coverage, or when agents need a repeatable RED→GREEN loop across services and libraries. Trigger phrases include implement using TDD, build test-first, and red-green-refactor. The skill fits backend services, CLI tools, and SaaS features where observable behavior matters more than internal structure, and where planning checklists confirm interface changes before the first assertion is written.450installs108Router First Architecturerouter-first-architecture is a parcadei/continuous-claude-v3 skill enforcing router-first dispatch for agent workflows. Domain routers such as math-router provide deterministic mapping from user intent to exact CLI commands; agents call the router first and bypass only on edge cases when the router returns command null. The pattern uses coActivate entries in skill-rules.json so domain skills activate alongside their router, keeps trigger keywords broader than routing patterns, and trusts router confidence scores before falling back. Developers reach for router-first-architecture when building multi-skill agent systems that need predictable tool selection instead of ad hoc per-tool invocation.447installs109Math Model Selectormath-model-selector is a Claude Code skill for ai & agent building. It helps solo builders move faster with AI-assisted coding.69installs110Math Intuition Buildermath-intuition-builder is a Claude Code skill for ai & agent building. It helps solo builders move faster with AI-assisted coding.61installs111Rudin Real Complex Analysisrudin-real-complex-analysis is a Claude Code skill for ai & agent building. It helps solo builders move faster with AI-assisted coding.55installs112Leann Searchleann-search is a Claude Code skill for ai & agent building. It helps solo builders move faster with AI-assisted coding.54installs113Math Progress Monitormath-progress-monitor is a Claude Code skill for ai & agent building. It helps solo builders move faster with AI-assisted coding.54installs114Analytic FunctionsA decision-tree skill for solving analytic-function problems in complex analysis, wiring sympy differentiation/series and z3 proofs. A developer uses it when they want Claude to verify holomorphy or expand power series with symbolic tools.1installs115Banach SpacesA decision-tree skill for Banach-space problems in functional analysis, wiring z3 proofs for completeness and the core theorems. A developer uses it when they want Claude to reason about bounded operators and completeness with symbolic tools.1installs116Boundary Value ProblemsA decision-tree skill for two-point and Sturm-Liouville boundary-value problems, wiring scipy.integrate.solve_bvp and finite-difference linear solves. A developer uses it when they want Claude to classify and solve BVPs with numerical tools.1installs117Categories FunctorsA decision-tree skill for verifying category axioms and functor properties, writing Lean 4 proofs for associativity and composition preservation. A developer uses it when they want Claude to reason about covariant, contravariant, and forgetful functors.1installs118Channel CapacityA decision-tree skill for computing channel capacity by maximizing mutual information over input distributions. A developer uses it when they want Claude to model channels like the binary symmetric channel and compute capacity.1installs119CompactnessA decision-tree skill for testing and applying compactness in topology, wiring z3 and sympy for boundedness and limit checks. A developer uses it when they want Claude to verify compactness or use it to prove max/min attainment.1installs120ConnectednessA decision-tree skill for proving connectedness in topology, wiring z3 for no-separation proofs and sympy to verify paths. A developer uses it when they want Claude to reason about path-connectedness and connected components.1installs121Constrained OptimizationA decision-tree skill for constrained optimization with equality and inequality constraints, wiring sympy Lagrangian solves and z3 KKT checks. A developer uses it when they want Claude to apply Lagrange multipliers or KKT conditions.1installs122ContinuityA decision-tree skill for verifying continuity in real analysis using sympy limit computation and one-sided checks. A developer uses it when they want Claude to test continuity at a point or across piecewise functions.1installs123Contour IntegralsA decision-tree skill for evaluating contour integrals in complex analysis, choosing semicircular, unit-circle, or keyhole contours. A developer uses it when they want Claude to set up contours and apply Jordan's lemma to real integrals.1installs124ConvergenceA decision-tree skill for testing sequence and series convergence with ratio, root, and comparison tests. A developer uses it when they want Claude to classify series and compute sums with sympy.1installs125Convex OptimizationA decision-tree skill for convex optimization, verifying Hessian PSD and picking solvers like linprog, SLSQP, or CVXPY. A developer uses it when they want Claude to classify a convex problem and apply KKT conditions.1installs126EigenvaluesA decision-tree skill for finding eigenvalues via the characteristic polynomial det(A - lambda I). A developer uses it when they want Claude to compute eigenvalues symbolically with sympy.1installs127EntropyA decision-tree skill for computing Shannon entropy and reasoning about its uniform-distribution maximum and deterministic minimum. A developer uses it when they want Claude to compute discrete entropy with scipy.1installs128FieldsA decision-tree skill for verifying whether a structure is a field by checking additive/multiplicative groups and distributivity. A developer uses it when they want Claude to prove field axioms with z3.1installs129First Order OdesA decision-tree skill for classifying and solving first-order ODEs across linear, separable, exact, and Bernoulli types. A developer uses it when they want Claude to identify an ODE form and pick the right technique.1installs130Gradient MethodsA decision-tree skill for gradient-descent optimization covering update rules, step sizes, and convergence rates. A developer uses it when they want Claude to reason about gradient methods and their convergence.1installs131Graph AlgorithmsA decision-tree skill for graph problems, selecting traversals and shortest-path algorithms by use case. A developer uses it when they want Claude to pick BFS, DFS, or a shortest-path algorithm.1installs132GroupsA decision-tree skill for verifying group axioms under an operation. A developer uses it when they want Claude to check whether a set forms a group.1installs133Hilbert SpacesA decision-tree skill for Hilbert-space problems, using orthogonal decomposition into a subspace and its complement. A developer uses it when they want Claude to reason about projections and orthogonality with sympy.1installs134Integration TheoryA decision-tree skill for integration in measure theory, covering simple-function integrals and the monotone convergence theorem. A developer uses it when they want Claude to reason about Lebesgue-style integration.1installs135InterpolationA decision-tree skill for interpolation problems, choosing methods based on data spacing and smoothness. A developer uses it when they want Claude to select an interpolation approach for a dataset.1installs136Lebesgue MeasureA decision-tree skill for Lebesgue measure, covering outer-measure infimum construction and the Caratheodory measurability criterion. A developer uses it when they want Claude to reason about measurability.1installs137LimitsA decision-tree skill for computing limits, starting with direct substitution and resolving indeterminate forms. A developer uses it when they want Claude to evaluate limits step by step.1installs138Limits ColimitsA decision-tree skill for categorical limits and colimits, identifying the diagram type behind each construction. A developer uses it when they want Claude to reason about products, equalizers, and pullbacks.1installs139MatricesA decision-tree skill for matrix problems, classifying matrix type and running basic operations with sympy. A developer uses it when they want Claude to work with matrices symbolically.1installs140Modular ArithmeticA decision-tree skill for modular arithmetic, computing gcd, Bezout coefficients, and modular inverses. A developer uses it when they want Claude to solve congruences and find inverses mod n.1installs141Natural TransformationsA decision-tree skill for natural transformations, verifying naturality-square commutativity between functors. A developer uses it when they want Claude to prove naturality conditions in Lean 4.1installs142Numerical IntegrationA decision-tree skill for numerical integration, classifying definite, improper, and multidimensional integrals before choosing a quadrature method. A developer uses it when they want Claude to numerically evaluate an integral.1installs143Open SetsA decision-tree skill for open sets and continuity in topology, checking preimage-of-open and coordinate-function conditions. A developer uses it when they want Claude to verify continuity in metric and general spaces.1installs144Operator TheoryA decision-tree skill for operator theory, verifying boundedness and computing operator norms as suprema. A developer uses it when they want Claude to reason about bounded linear operators.1installs145Predicate LogicA decision-tree skill for predicate logic, analyzing quantifier scope and free/bound variables. A developer uses it when they want Claude to prove first-order statements with z3.1installs146Prime NumbersA decision-tree skill for prime numbers, choosing among trial division, Miller-Rabin, and AKS primality tests plus factorization. A developer uses it when they want Claude to test primality or factor integers.1installs147Proof TheoryA decision-tree skill for proof theory, choosing direct, contradiction, cases, or induction strategies. A developer uses it when they want Claude to structure a mathematical proof.1installs148Propositional LogicA decision-tree skill for propositional logic, classifying tautologies and contingencies and checking satisfiability. A developer uses it when they want Claude to analyze formulas with z3 or truth tables.1installs149ResiduesA decision-tree skill for computing residues at simple and order-n poles using limit and derivative formulas. A developer uses it when they want Claude to compute residues with sympy.1installs150RingsA decision-tree skill for rings, verifying additive-group, associative-multiplication, and distributive axioms. A developer uses it when they want Claude to check whether a structure is a ring.1installs151Root FindingA decision-tree skill for root finding, selecting methods based on bracketing and derivative availability. A developer uses it when they want Claude to pick a numerical root-finding algorithm.1installs152Second Order OdesA decision-tree skill for second-order ODEs, classifying constant-coefficient, variable-coefficient, and Cauchy-Euler forms. A developer uses it when they want Claude to solve second-order equations via characteristic roots.1installs153Sigma AlgebrasA decision-tree skill for sigma-algebras, verifying whole-space, complement, and countable-union closure axioms. A developer uses it when they want Claude to check sigma-algebra structure or generation.1installs154Source CodingProvides a decision tree and solver commands for source-coding problems in information theory, covering Shannon bounds, Huffman codes, the Kraft inequality and rate-distortion. A developer uses it when working through information-theory source-coding exercises with z3/sympy tooling.1installs155Vector SpacesGives a decision tree and sympy solver commands for vector-space problems in linear algebra, including subspace checks, linear independence, basis and change of basis. A developer uses it when solving linear-algebra vector-space exercises with sympy tooling.1installs