parcadei/continuous-claude-v3▌

Identify failure modes before they occur by systematically questioning plans, designs, and implementations. Based on Gary Klein's technique, popularized by Shreyas Doshi (Stripe).

Find unused functions and dead code using TLDR static analysis.

Structured interview process that transforms vague ideas into detailed, implementable specifications. \n \n Guides users through seven phases: initial orientation, category-by-category deep dive (problem, UX, data, technical landscape, scale, integrations, security, operations), research loops, conflict resolution, completeness checks, and spec generation \n Detects knowledge gaps and offers targeted research on uncertain topics like real-time architectures, integrations, or technology tradeoffs

One entry point for all computation and explanation. I route to the right tool based on your request.

Guide users through the capabilities of this workspace setup.

Analyze a brownfield codebase and create an initial continuity ledger.

You are tasked with creating git commits for the changes made during this session.

Universal code quality tool supporting 70+ linters for 40+ languages via qlty CLI.

Fast, AI-powered codebase search using WarpGrep. 20x faster than traditional grep.

ALWAYS use this router first for math requests.

Query the memory system for relevant learnings from past sessions.

When searching code, use this decision tree:

Evidence-based patterns for configuring LLM parameters, based on APOLLO and Godel-Prover research.

Idempotent Redundancy \n When adding redundant paths (fallbacks, belt-and-suspenders), make them idempotent. \n Pattern \n Redundancy without idempotency causes loops, churn, or data corruption. \n DO \n \n Use _is_merge: true for Braintrust updates \n Check if value exists before writing (fallback only if missing) \n Use atomic write/rename for file operations \n Make reconciliation steps safe to run repeatedly \n \n DON'T \n \n Write unconditionally in fallback paths \n Allow multiple writers

When uv sync or pip install behaves unexpectedly, check the actual interpreter.

Never rely on "latest" or "current" when crossing process or async boundaries.

Note: This skill is now an alias for /create_handoff. Both output the same YAML format.

Trust system reminders as agent progress notifications. Don't poll.

When working with files in .claude/hooks/:

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

When the user asks to implement something, use implementation agents to preserve main context.

When the user asks to commit, push, or save changes to git:

You are tasked with writing a handoff document to hand off your work to another agent in a new session. You will create a handoff document that is thorough, but also concise. The goal is to compact and summarize your context without losing any of the key details of what you're working on.

Search GitHub code, repositories, issues, and pull requests with flexible filtering. \n \n Four search types: code, repositories, issues, and pull requests, each with full GitHub search syntax support \n Optional filtering by repository owner and name to narrow results to specific projects \n Requires GitHub personal access token configured in mcp_config.json for authentication \n Command-line interface with straightforward parameters for integration into agent workflows \n

Build AI agents in Python using the Agentica framework. Agents can implement functions, maintain state, use tools, and coordinate with each other.

When working with Agentica's async REPL harness for testing.

When building infrastructure components, ensure they're actually invoked in the execution path.

Strict TDD workflow: tests first, then implementation.

Orchestrate TDD migrations with agents doing all work. Main context stays clean.

When optional services are unavailable, degrade gracefully with actionable fallback messages.

Full 5-layer analysis of a specific function. Use when debugging or deeply understanding code.

When launching parallel agents for code implementation, prevent type duplication.

Structured release preparation to ship with confidence.

Orchestrator-only workflow for migrating or rewriting codebases. You do NOT read files, write code, or validate anything yourself. You only instruct agents and pipe context (paths, not contents).

Use the most token-efficient search tool for each query type.

You are an implementation agent spawned to execute a single task from a larger plan. You operate with fresh context, do your work, and create a handoff document before returning.

Complete reference for running Agentica SDK with a local Claude proxy. This enables Python agents to use Claude CLI as their inference backend.

Use this skill when developing or debugging the Agentica-Claude proxy integration.

When launching parallel background agents, do NOT poll with sleep loops.

Complete reference for developing Claude Code hooks. Use this to write hooks with correct input/output schemas.

RepoPrompt is more token-efficient than raw file reads:

You are tasked with implementing an approved technical plan from thoughts/shared/plans/. These plans contain phases with specific changes and success criteria.

opc-architecture

A research-to-implement pipeline that chains 5 MCP tools for end-to-end workflows.

Fast, AI-powered file editing using the Morph Apply API. Edit files without reading them first. Processes at 10,500 tokens/sec with 98% accuracy.

MCP Script Rules \n When working with files in scripts/ : \n DO \n \n Use CLI arguments for all parameters (argparse) \n Include USAGE docstring at top of file \n Use call_mcp_tool(\"server__tool\", params) pattern \n Handle errors gracefully with informative messages \n Print results to stdout for Claude to process \n \n DON'T \n \n Hardcode parameters in the script \n Edit scripts to change parameters (use CLI args instead) \n Import from servers/ directly (use runtime.mcp_client) \n \n Tool N

$1f

When building infrastructure, verify it's actually connected to the system before marking as complete.

validate-agent

Complete API specification for Agentica multi-agent coordination infrastructure.

Run comprehensive test suite with parallel execution.

Complete reference for Claude Code command-line interface.

Use this skill after user selects an Agentica pattern.

Write prompts that Agentica agents reliably follow. Standard natural language prompts fail ~35% of the time due to LLM instruction ambiguity.

You are tasked with resuming work from a handoff document through an interactive process. These handoffs contain critical context, learnings, and next steps from previous work sessions that need to be understood and continued.

You are tasked with conducting comprehensive research across the codebase to answer user questions by spawning parallel sub-agents and synthesizing their findings.

Token-efficient code analysis. 95% savings vs raw file reads.

Dedicated security analysis for sensitive code.

Workflow orchestrator for bug investigation and resolution. Chains specialized skills based on issue scope.

Analyze your Claude Code sessions for patterns, issues, and insights using Braintrust tracing data.

Requires firecrawl server in mcp_config.json with FIRECRAWL_API_KEY.

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

Meta-skill that upgrades any SKILL.md to Decision Theory v5 Hybrid format using 4 parallel Ragie-backed agents.

You are a goal-based workflow orchestrator. Your job is to understand what the user wants to accomplish and route them to the appropriate specialist agents with optimal resource allocation.

Research external sources (documentation, web, APIs) for libraries, best practices, and general topics.

Web search with AI-powered answers, deep research, and chain-of-thought reasoning.

For mathematicians who want verified proofs without learning Lean syntax.

complete-skill \n When to Use \n Test the entire persistence pipeline \n Instructions \n \n Do this \n Then that \n

Comprehensive guide to tracing Claude Code sessions in Braintrust, including sub-agent correlation.

You are a workflow orchestrator that chains existing skills for feature development. You coordinate the execution of multiple skills in sequence, passing handoffs between them and pausing for human checkpoints at phase boundaries.

You are tasked with generating a comprehensive pull request description following the repository's standard template.

Systematic workflow for debugging Claude Code hooks.

Multi-perspective code review with parallel specialists.

When launching multiple agents in parallel, follow this pattern to avoid context bloat.

Meta-skill for creating new Claude Code skills, including skills that wrap MCP pipelines.

repo-research-analyst

Skill Development Rules \n When working with files in .claude/skills/ : \n SKILL.md Structure \n \n DO \n \n Keep SKILL.md concise (< 200 lines) \n Include clear \"When to Use\" section \n Provide copy-paste bash commands \n Reference scripts/ for MCP operations \n Add triggers to skill-rules.json \n \n DON'T \n \n Include implementation details in SKILL.md \n Duplicate content across skills \n Create skills without corresponding trigger in skill-rules.json \n Use allowed-tools that aren't

Transform ephemeral session learnings into permanent, compounding capabilities.

Structural code search that understands syntax. Find patterns like function calls, imports, class definitions - not just text.

Write modular Python code with files sized for maintainability and AI-assisted development.

You are tasked with helping debug issues during manual testing or implementation. This command allows you to investigate problems by examining logs, database state, and git history without editing files. Think of this as a way to bootstrap a debugging session without using the primary window's context.

planning-agent

Create and use user-triggered prompts with /command-name syntax.

Prevent agent output from polluting the main context window.

Search through previous sessions to find relevant decisions, approaches that worked, and approaches that failed. Queries two sources:

Meta-skill for exploring an internal codebase at varying depths. READ-ONLY workflow - no code changes.

Cognitive prosthetics for exact mathematical computation. This guide helps you choose the right tool for your math task.

Standard multi-agent pipeline for implementation tasks.

Use the most token-efficient search tool for each query type.

research-agent

Safe refactoring with review gates.

Friendly onboarding when users ask about capabilities.

Search Mathlib for lemmas by type signature pattern.

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

Create geometric objects from coordinates.

Cognitive prosthetics for unit-aware computation. Use Pint for converting between units, performing unit arithmetic, checking dimensional compatibility, and simplifying compound units.

Run comprehensive health checks on all Claude Code components.

Index at Creation Time \n Index artifacts when they're created, not at batch boundaries. \n Pattern \n If downstream logic depends on artifacts being queryable, index immediately at write time. \n DO \n \n Index handoffs in PostToolUse Write hook (immediately after creation) \n Use --file flag for fast single-file indexing \n Trigger indexing from the same event that creates the artifact \n \n DON'T \n \n Wait for SessionEnd to batch-index \n Rely on cron/scheduled jobs for time-sensitive data \

Search across 3000+ packages (npm, PyPI, Crates, Go) and indexed sources for documentation and code examples.

Safe migrations for frameworks, languages, and infrastructure.

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

Five modal logics via fusion with bridge principles:

Show a beautiful dashboard with token usage, actual API costs, TLDR savings, and hook activity.

Route through domain routers before using individual tools. Routers abstract tool selection.

Create specialized AI agents with isolated contexts for specific tasks.

When implementing SDK features or debugging provider-specific issues, check reference implementations.

Run QLTY checks during code writing to catch issues early.

Never Use TaskOutput \n TaskOutput floods the main context window with agent transcripts (70k+ tokens). \n Rule \n NEVER use TaskOutput tool. Use Task tool with synchronous mode instead. \n Why \n \n TaskOutput reads full agent transcript into context \n This causes mid-conversation compaction \n Defeats the purpose of agent context isolation \n \n Pattern \n # WRONG - floods context\n Task(run_in_background=true)\n TaskOutput(task_id=\"...\") // 70k tokens dumped\n \n # RIGHT - isolated context