@parcadei

hook-developer covers the complete input/output schema reference for claude code hooks, including 11 event types, registration patterns, type options (command/prompt), environment variables, exit code semantics, and testable code examples.

wiring verification ensures infrastructure components are actually invoked in execution paths, not orphaned as dead code. covers entry point registration, call graph tracing, integration testing, and detection strategies with concrete examples.

math-help maps five computational layers (sympy, z3, scratchpad, tutor, lean4) with concrete command examples and decision trees. covers symbolic algebra, constraint solving, reasoning verification, learning, and formal proofs.

tdd covers test-driven development workflow emphasizing red-green-refactor cycle with strict enforcement of failing tests before implementation. guides multi-agent planning, test writing, minimal code generation, and validation phases.

agentica-server covers local claude proxy setup, startup sequence, and debugging connection failures between sdk, server, and inference backend. includes health checks, common errors with fixes, and environment variable configuration.

security provides a two-phase audit workflow covering injection attacks, authentication flaws, data protection, misconfigurations, and dependency vulnerabilities. scopes range from full codebase to single files, with optional verification and owasp top 10 reporting.

release orchestrates a five-phase production workflow: security audit, e2e tests, human review, version bump, and documentation generation. supports major/minor/patch releases and hotfix paths with explicit blockers.

refactor orchestrates a five-phase code improvement workflow (analyze, plan, implement, review, validate) using sequential agents with built-in review gates and test verification to minimize regression risk.

math routes computation requests to specialized backends (sympy, z3, pint) based on intent, covering symbolic algebra, constraint solving, unit conversion, and topic explanations across 13 mathematical domains.

completion-check verifies that built infrastructure is actually integrated and executing within the system, not orphaned as dead code. focuses on tracing execution paths, confirming hook registration, and validating end-to-end functionality before marking work done.

mcp-chaining documents a 5-tool research-to-implement pipeline with environment variable fixes, graceful degradation patterns, and a reference for tool naming across nia, ast-grep, morph, qlty, and git servers.

workflow-router classifies user intent into four goal categories (research, plan, build, fix) and routes to specialist agents with configurable resource allocation. includes pre-execution confirmation and special-case handling for debug workflows.

modular-code provides concrete heuristics for right-sizing python files and splitting strategies, targeting codebases that exceed 500-2000 line thresholds. covers package structure, natural split points, and refactoring workflows.

search-router routes code queries to the most token-efficient tool based on query type, prioritizing tldr search for symbols and call chains, ast-grep for structural patterns, and grep only as a last resort for literal matches.

research-external guides users through structured external research workflows across docs, web, and apis, with branching question flows that map to focus modes (library, best-practices, general) and configurable depth and output formats.

explicit-identity enforces passing full identifiers through async and process boundaries to prevent race conditions. covers session tracking, span correlation, and ID type separation across distributed execution.

tldr-deep performs structured 5-layer analysis of functions via ast extraction, call graphs, control flow, data flow, and program slicing. designed for debugging and understanding complex code paths.

research-agent gathers external documentation and best practices using three mcp tools (nia, perplexity, firecrawl), synthesizes findings into structured handoff documents, and explicitly handles partial failures across sources.

help provides interactive workspace discovery routing users to relevant skills, workflows, agents, and tools based on their stated goal. covers codebase exploration, bug fixing, feature building, formal verification, and configuration.

fix orchestrates multi-phase bug resolution workflows across four scopes (bug, hook, deps, pr-comments), routing through specialized agents for investigation, diagnosis, implementation, testing, and commit with mandatory human checkpoints and premortem risk assessment.

orchestrates three-phase testing (diagnostics, parallel unit/integration, sequential e2e) with type-checking pre-flight and scope flexibility for feature-level or full-suite validation.

recall-reasoning queries artifact indexes and git reasoning files to surface past decisions, successful approaches, and failure patterns. helps avoid repeating mistakes and follow proven patterns from prior work.

pint-compute wraps the pint library for unit conversion, dimensional analysis, and unit-aware arithmetic. covers parsing, converting, calculating with units, and simplifying compound units into base or named forms.

compound-learnings harvests patterns from session caches and systematically converts them into rules, skills, hooks, or agent updates via frequency analysis and a categorization decision tree.

agentica-claude-proxy covers integration of agentica agents with claude code cli via a proxy server, with explicit guidance on tool permissions, sse streaming, repl format, and hallucination prevention.

agent-context-isolation establishes patterns for isolating subagent work from main conversation context via file-based coordination and background tasks, reducing token overhead from full transcript retrieval.

onboard analyzes existing codebases to extract tech stack and project context, generating a yaml handoff ledger for persistent session state across agent invocations.

parallel-agent-contracts enforces type deduplication across concurrent code generation agents via explicit ownership mapping, pre-creation grep checks, and mandatory typescript verification gates.

reference-sdk provides guidance on checking external SDK implementations via btca ask to learn patterns for streaming, tool calling, and validation. three preconfigured resources (vercel-ai, anthropic-sdk, zod) plus extensible resource system.

hooks documents a pattern for intercepting claude agent lifecycle events via shell and typescript, with event types and registration mechanics but sparse guidance on real-world implementation constraints.

sub-agents provides templates and cli patterns for spawning isolated claude instances with custom prompts and tool restrictions, useful for task specialization and agent chaining workflows.

async-repl-protocol establishes conventions for writing code blocks in agentica's async repl harness, covering await syntax, single-block execution, and basic failure recovery patterns.

agentica-infrastructure documents 11 multi-agent coordination patterns and their apis, with constructor signatures and class methods. lacks procedural depth, edge case handling, and trigger specificity for practical deployment.

skill-upgrader orchestrates four parallel agents querying ragie partitions to convert arbitrary skills into decision theory v5 hybrid format. relies on external ragie infrastructure and assumes indexed textbooks. execution model is theoretical rather than concrete.

tldr-stats displays token usage, api costs, compression savings, and cache performance via a formatted dashboard. intended for monitoring tldr effectiveness and debugging hook/cache behavior within a session.

planning-agent accepts conversation context and codebase state, then generates structured implementation plans with handoffs, but lacks specificity on decision logic and failure handling.

index-at-creation prescribes immediate artifact indexing via posttooluse hooks rather than batch operations, targeting scenarios where downstream logic requires prompt queryability.

firecrawl-scrape extracts web page content via the firecrawl mcp server, supporting both direct url scraping and search-based discovery with configurable output formats.

describe-pr generates pull request descriptions by reading repository templates and populating them with pr metadata, but lacks specificity on how descriptions are actually composed and what template sections are supported.

git-commits documents when to invoke a /commit skill wrapper instead of raw git commands, focusing on attribution removal and reasoning capture for claude-assisted development.

dead-code wraps tldr static analysis to identify unused functions and unreachable code across projects, with configurable entry point filtering but minimal guidance on interpretation or handling results.

resume-handoff attempts to reconstruct work context from handoff documents and linked artifacts, but lacks concrete validation steps, decision logic, and failure handling required for reliable handoff resumption.

create-handoff guides writing context summaries for inter-session work transfer. incomplete procedure, minimal edge case handling, and vague guidance on document content structure itself.

nia-docs wraps semantic search across 3000+ packages in npm, pypi, crates, and go registries. lacks clear intent definition, decision logic, and failure handling.

opc-architecture documents the design of orchestrated parallel claude, a hook and skill system layered atop claude code for multi-agent coordination via subprocess spawning and postgresql state management.

tour provides a warm welcome explaining claude's capabilities across code, memory, research, and specialized agents. it activates on capability questions and offers a structured overview with actionable next steps.

background-agent-pings provides a pattern for launching background agents and reading their outputs via system reminders rather than polling. it covers basic workflow sequencing but lacks operational specifics.

no-task-output documents why TaskOutput tool inflates context window and recommends using Task with synchronous mode instead. prescriptive but lacks actionable procedure.

Store a learning, pattern, or decision in the memory system for future recall

Deep interview process to transform vague ideas into detailed specs. Works for technical and non-technical users.

Code quality checks, formatting, and metrics via qlty CLI

Braintrust tracing for Claude Code - hook architecture, sub-agent correlation, debugging

Debug issues by investigating logs, database state, and git history

Meta-skill for creating and managing Claude Code skills

Create or update continuity ledger for state preservation across clears

Build Python agents with Agentica SDK - @agentic decorator, spawn(), persistence, MCP integration

Comprehensive code review workflow - parallel specialized reviews → synthesis

MCP Script Rules

Systematic hook debugging workflow. Use when hooks aren't firing, producing wrong output, or behaving unexpectedly.

Use RepoPrompt CLI for token-efficient codebase exploration

Meta-skill for internal codebase exploration at varying depths (quick/deep/architecture)

Spawn Agentica multi-agent patterns

Fast file editing via Morph Apply API (10,500 tokens/sec, 98% accuracy)

Create git commits with user approval and no Claude attribution

implement_plan_micro — an installable skill for AI agents, published by parcadei/continuous-claude-v3.

Search Tool Hierarchy

Analyze Claude Code sessions via Braintrust

Fast codebase search via WarpGrep (20x faster than grep)

Get a token-efficient overview of any project using the TLDR stack

Orchestrator-only workflow for migrating/rewriting codebases with full TDD and agent delegation

Analyze repository structure, patterns, conventions, and documentation for understanding a new codebase

Identify failure modes before they occur using structured risk analysis

Environment Triage

Skill Development Rules

Computational geometry with Shapely - create geometries, boolean operations, measurements, predicates

Deterministic router for math cognitive stack - maps user intent to exact CLI commands

AST-based code search and refactoring via ast-grep MCP

Formal theorem proving with research, testing, and verification phases

Router-First Architecture

Agent Orchestration Rules

Workflow orchestrator that chains existing skills for feature development

Maps questions to the optimal tldr command. Use this to pick the right layer

TDD workflow for migrations - orchestrate agents, zero main context growth

Claude Code CLI commands, flags, headless mode, and automation patterns

Observe Before Editing

Graceful Degradation with Helpful Messages

Validation agent that validates plan tech choices against current best practices

implement_plan — an installable skill for AI agents, published by parcadei/continuous-claude-v3.

implement_task — an installable skill for AI agents, published by parcadei/continuous-claude-v3.

System health check (MOT) for skills, agents, hooks, and memory

AI-powered web search, research, and reasoning via Perplexity

Search Mathlib for lemmas by type signature pattern

Parallel Agent Orchestration

Show users how Continuous Claude works - the opinionated setup with hooks, memory, and coordination

Migration workflow - research → analyze → plan → implement → review

LLM Tuning Patterns

Idempotent Redundancy

Agentic Workflow Pattern

slash-commands — an installable skill for AI agents, published by parcadei/continuous-claude-v3.

Token-efficient code analysis via 5-layer stack (AST, Call Graph, CFG, DFG, PDG). 95% token savings.

A complete skill for E2E testing

Document codebase as-is with thoughts directory for historical context

qlty-during-development — an installable skill for AI agents, published by parcadei/continuous-claude-v3.

Search Tool Hierarchy

no-polling-agents — an installable skill for AI agents, published by parcadei/continuous-claude-v3.

Write reliable prompts for Agentica/REPL agents that avoid LLM instruction ambiguity

recall — an installable skill for AI agents, published by parcadei/continuous-claude-v3.

Search GitHub code, repositories, issues, and PRs via MCP