Coding standards, frameworks, refactoring, and code review (15.8K skills)
Find LLM workflows in a codebase and label them by the job they perform, so Caveman Cloud can separate spending by workflow. Present a labeling proposal for approval, apply focused code changes, and check an affected execution path.
Fix bugs and small behavior changes by tracing the cause and editing the smallest responsible part of the code. Preserve surrounding behavior and existing user changes, then run focused checks to confirm the fix and guard against recurrence.
Investigate unclear failures, intermittent behavior, and performance regressions before changing code. Separate symptoms from assumptions, trace how failures arise, and rank possible causes by evidence and ease of testing, then report the cause and supporting proof.
Evaluate Caveman optimization observations by selecting a specific code change with operator approval. Compare the original and changed versions on identical inputs, checking both task quality and resource usage before deciding whether to keep the change.
Plan and implement migrations for data, APIs, configuration, and dependencies while preserving existing data and compatibility. Define rollback steps, check old and new behavior, and handle retries and partial failures during staged transitions.
Locate relevant code in an unfamiliar repository or after a direct search fails. This read-only explorer returns a short list of file paths, verified line ranges, and relevance notes for another agent to use.
Restructure code through extraction, consolidation, or responsibility moves while preserving its behavior. Establish checks before editing, repeat them afterward, and keep intermediate versions buildable and testable without mixing in feature changes.
Choose the right engineering skills for a task and decide their order, from clarifying requirements to deployment. This guide also defines shared practices for stating assumptions, resolving uncertainty, keeping scope focused, and verifying completed work.
Turn clear requirements into small implementation tasks with acceptance criteria, verification steps, dependencies, and estimated scope. Produce a written plan and ordered task list, with checkpoints and opportunities for parallel work identified before coding begins.
Turn an unclear feature idea into a structured specification with goals, boundaries, and testable success criteria. Split broader requests into independent modules when needed, then move through planning, task breakdown, and implementation with human review.
Define project quality standards in CONSTRAINTS.md, connect measurable targets to checks, and inspect changes for weakened safeguards. It helps teams choose thresholds and catch skipped tests, suppressed warnings, unfinished code, or lowered standards during agent development.
Plan the retirement of old APIs, features, and systems, then move their users to replacements in stages. The skill also guides database schema changes through additive steps that keep old and new application code compatible during rollout.
Investigate failing tests, broken builds, and unexpected behavior through a structured debugging process. Reproduce the failure, narrow down its source, fix the root cause, and add a regression test that catches the same problem.
Find and fix slow page loads, API responses, and database queries using measurements. Compare results before and after each change, discard changes without clear gains, and add checks or monitoring to catch future slowdowns.
Check project dependency versions and consult the relevant official documentation before writing framework-specific code. Produce implementations with source links, identify deprecated APIs, and flag unverified approaches or conflicts between documentation and existing project patterns.
Implement larger changes as small, working pieces. Each piece goes through testing, verification, and a focused commit, with guidance on choosing boundaries, hiding unfinished features behind switches, and keeping changes easy to roll back.
Build responsive interfaces that follow an existing design system and support accessible interaction. Covers component structure, state management, keyboard controls, and loading, empty, and error states, with checks across screen sizes and assistive tools.
Make working code easier to read and maintain while preserving its behavior. The skill identifies tangled conditions, unclear names, duplication, and unnecessary abstractions, then guides small refactoring steps checked against existing tests and project conventions.
Challenge important design and implementation decisions with a separate reviewer that does not inherit the working session's context. Identify hidden assumptions and failure cases, then assess each finding against the artifact and its requirements.
Organize code changes into focused commits and manageable branches, prepare pull requests, and maintain release versions and changelogs. The skill also covers separate working directories for parallel work and checks before committing.
Design APIs and interfaces between modules with clear inputs, outputs, naming, and errors. The skill guides compatible extensions, input validation, and retry handling so callers can use interfaces consistently without accidentally repeating state-changing operations.
Review code changes before merging across correctness, readability, architecture, security, and performance. Get findings that distinguish required fixes from optional suggestions, with concrete ways to simplify code and checks on test coverage.
Investigate failed, stalled, slow, or incorrectly blocked Paperclip tasks. Trace the cause, reproduce the bug, implement a repair, test related behavior, and verify the actual workflow before delivering a pull request with passing checks.
Add a new execution tool or provider to native Paperclip Runner. Define requirements, investigate its communication protocol, implement the integration, package it, and verify complete tasks in the intended environment, including cancellation, recovery, and cleanup.