parcadei

Understand how Continuous Claude stores session memories, runs automatic actions at key events, and passes work between sessions. The skill explains the setup, relevant files, recall commands, and available database options.

• Understanding what persists between sessions
• Checking automatic actions at session events
• Finding commands for handing off work

Run a staged testing workflow that checks type errors first, executes unit and integration tests in parallel, and runs end-to-end tests only after they pass. Receive pass and fail counts with details about failures.

• Running the full test suite before a release or merge
• Testing a specific feature
• Running a quick unit-test check

Explore code through structured summaries of functions, calls, branches, and variable usage. Use the tldr commands to locate relevant files, trace change impacts, find affected tests, and identify potentially unused code before inspecting the implementation.

• Understanding an unfamiliar codebase
• Tracing callers and the impact of a change
• Investigating bugs across multiple files

Analyze a specific function through five views: structure, function calls, execution paths, data flow, and line dependencies. Use the findings to investigate bugs, review complex logic, or understand dependencies before refactoring.

• Investigating execution paths in a faulty function
• Checking dependencies before refactoring
• Reviewing functions with complex branching

Use btca ask to inspect reference SDKs, libraries for connecting to services, when building features or debugging provider-specific issues. Compare streaming, tool calling, structured output, and validation approaches in Vercel AI SDK, Anthropic SDK, and Zod.

• Inspect similar features before implementation
• Investigate provider-specific bugs
• Compare SDK implementations across providers

Edit large code files through the Morph Apply API without reading the entire file first. Provide a change description and a code snippet with placement markers to add error handling, insert logging, or apply several related changes together.

• Editing large files without reading their full contents
• Applying several related changes to one file
• Adding error handling or debug logging

Search a codebase with WarpGrep to find functions, variables, imports, and other text. Use regular expressions to match text patterns, limit searches to a directory, or replace the contents of a specified file.

• Finding authentication code
• Locating functions with regular expressions
• Checking imports in a source directory

Find library documentation and code examples through Nia. Search within a package by meaning or regular expression, or search across indexed sources, with options to select a package registry and limit the number of results.

• Look up FastAPI dependency injection examples
• Find React useEffect cleanup patterns
• Search for usage examples of a specific function

Keep lengthy agent transcripts out of the main conversation by using synchronous Task calls that return summaries. This skill sets a specific execution rule intended to preserve separate agent contexts and avoid triggering conversation compaction.

• Receiving a summary after an agent finishes its task
• Reviewing workflows that retrieve results with TaskOutput
• Keeping full agent transcripts out of the main conversation

Investigate bugs by checking generated files, directories, logs, and the actual output of a failing command before editing code. The workflow also checks project and global paths to help distinguish missing output from looking in the wrong location.

• Checking whether a hook actually ran
• Investigating missing generated files
• Comparing project and global cache locations

Get oriented in an existing codebase by identifying its technologies, important files, and architecture. The skill gathers your goals and creates a YAML handoff record with priorities and suggested next actions.

• Getting started in an existing project
• Understanding technologies and important files
• Recording goals and initial priorities

Understand how OPC coordinates multiple Claude Code processes through event hooks, skills, scripts, files, and a database. It explains child-agent startup, process tracking, output storage, and completion reporting, helping readers follow the system's architecture.

• Understanding the components of OPC
• Tracing how child agents start and finish
• Locating hook settings and agent output files

Coordinate parallel coding agents by specifying where shared types are defined and requiring reuse of existing definitions. Prompt templates add searches before creating types and TypeScript checks before completion to catch conflicting definitions and type errors.

• Sharing type rules across parallel coding agents
• Checking for existing types before adding new ones
• Specifying where shared types should be imported from

Coordinate parallel agents running in the background while keeping lengthy results out of the main conversation. Track completion through shared status files, store detailed findings separately, and organize work into batches of up to 15 agents.

• Running multiple independent tasks in parallel batches
• Tracking completion in a shared status file
• Saving research findings separately for each agent

Use Perplexity to find web sources, get cited research summaries, explore complex decisions, or investigate a topic in depth. Separate modes support quick questions, ranked search results, combined answers, and comprehensive research.

• Find recent sources on a topic
• Combine multiple sources into a cited answer
• Compare options for a complex decision

Use Pint to convert measurements, calculate with units, and check whether units describe compatible physical quantities. It also breaks quantities into values and units, simplifies compound units, and returns calculation results as JSON.

• Converting measurements between unit systems
• Calculating with mixed units
• Checking the dimensional consistency of formulas

Review plans, designs, or code by imagining how they could fail. Checks potential risks against surrounding context and existing safeguards, separates verified threats from false alarms, and helps decide whether to mitigate or accept them.

• Checking a plan for risks before implementation
• Reviewing risks in a pull request
• Finding gaps in dependency handling and rollback plans

Integrate QLTY code checks into development after new files, substantial edits, and before commits. It provides commands for checking selected files, applying automatic fixes, and formatting code, with guidance on when to run them.

• Check code after creating a new file
• Inspect changed files before committing
• Apply automatic fixes and format code

Search previous work records to recover useful decisions, successful approaches, and failed attempts. Find context in handoffs, plans, and build or test histories, then use those findings when tackling similar tasks or recurring errors.

• Recall how a similar task was handled
• Recover the reasons behind past decisions
• Find fixes for previously encountered errors

Refactor existing code through analysis, planning, implementation, review, and testing. Use small, verifiable changes to extract modules, reorganize code, or improve architecture while preserving existing behavior and checking for regressions.

• Extracting shared logic into a separate module
• Reorganizing code while preserving behavior
• Improving architecture in stages

Investigate an unfamiliar codebase and create a handoff document covering its structure, technologies, implementation patterns, and contribution rules. Findings include source file references, issue and pull request templates, testing requirements, and practical points to check before contributing.

• Understanding an unfamiliar codebase before making changes
• Checking issue and pull request requirements before contributing
• Finding existing implementations and naming conventions to follow

Explore code with RepoPrompt CLI using directory trees, function signatures, targeted searches, and selected line ranges. Assemble relevant context for AI tasks, automatically select related files, and save repeatable command workflows while limiting how much code is read.

• Exploring code structure through function signatures
• Reading only relevant matches and line ranges
• Automatically selecting files related to a task

Researches library documentation, implementation practices, and specific web pages using Nia, Perplexity, and Firecrawl through MCP tools. Produces a handoff document with findings, available code examples, recommendations, pitfalls, and source links for another agent.

• Research library APIs before planning a feature
• Compare recommended implementation practices
• Collect content from a specific documentation page

Research library usage, recommended approaches, and general topics using external documentation and web sources. Choose a brief or thorough investigation, then organize examples, pitfalls, comparisons, and source links into a research document or implementation handoff.

• Researching library APIs and usage examples
• Comparing tools and implementation approaches
• Compiling a topic report with source links