Catalog on processkit

Process Skills

Mon, 01 Jan 0001 00:00:00 +0000

Skills for managing project workflows, team coordination, and operational processes. Most process-primitive skills have an accompanying MCP server that enforces schema validation and state-machine rules.

workitem-management

Creates, transitions, and queries WorkItems — the task-tracking primitive in processkit. Use when managing backlog items, updating work item state, or querying items by status, owner, or priority.

Triggers: When the user asks to create a ticket, update a work item, query the backlog, or track progress on a task. Tools: create_workitem, transition_workitem, query_workitems, get_workitem, link_workitems Layers: Layer 2 (depends on event-log, actor-profile)

Language Skills

Mon, 01 Jan 0001 00:00:00 +0000

Language-specific conventions, patterns, and best practices.

python-best-practices

Python conventions and patterns – typing, testing, project layout, tooling. Use when writing or reviewing Python code.

Triggers: When the user is working with Python code and asks about conventions, project structure, typing, testing, or says “how should I structure this Python project?”. Tools: None References: None

Key capabilities:

Project layout: src/ layout with pyproject.toml, use uv for dependency management
Type hints on all public function signatures with from __future__ import annotations
Testing with pytest: fixtures, parametrize, test naming test_<function>_<scenario>_<expected>
Code style: ruff format and ruff check, prefer dataclasses/Pydantic over dicts, pathlib over os.path
Error handling: raise specific exceptions, custom exception classes, never bare except:

Example usage

User asks to set up a new Python project. The agent creates pyproject.toml with project metadata and dependencies, src/ layout, tests/ directory, ruff config, and basic __init__.py.

Infrastructure Skills

Mon, 01 Jan 0001 00:00:00 +0000

Skills for containers, orchestration, networking, system administration, and CI/CD.

dockerfile-review

Dockerfile best practices review – layer optimization, caching, security, image size. Use when writing or reviewing Dockerfiles.

Triggers: When the user asks to review a Dockerfile, optimize an image, or says “why is my image so big?”, “is this Dockerfile correct?”, or “help me with Docker”. Tools: None References: None

Key capabilities:

Layer optimization: combine related RUN commands, order from least to most frequently changing
Caching: copy dependency manifests first, install, then copy source
Security: don’t run as root, never COPY secrets, pin base images with digest, remove package caches
Size reduction: slim/alpine base images, multi-stage builds, --no-install-recommends
Correctness: use COPY over ADD, set WORKDIR instead of cd, exec form for CMD/ENTRYPOINT

Example usage

User says “Review my Dockerfile.” The agent reads it and identifies that dependency installation and source copy are in the same layer (cache-busting), apt lists aren’t cleaned up, and the container runs as root. Provides specific fixes for each issue.

Architecture Skills

Mon, 01 Jan 0001 00:00:00 +0000

Skills for software architecture, design patterns, and system design.

software-architecture

Analyzes codebases for architectural patterns and quality. Use when designing systems, creating ADRs, reviewing structure, or generating architecture diagrams.

Triggers: Designing systems, creating ADRs, reviewing code structure, generating C4 diagrams, applying SOLID/DRY/KISS principles Tools: None References: patterns.md

Key capabilities:

Analyze existing architecture by mapping module organization, dependency directions, and identifying violations (circular deps, layer skipping, leaky abstractions)
Suggest architecture patterns matched to project type (layered, hexagonal, modular monolith, microservices, pipe-and-filter, event-driven)
Create Architecture Decision Records (ADRs) with context, decision, and consequences
Review code for architectural violations: god modules, tight coupling, missing boundaries
Generate C4 diagrams (System Context, Container, Component) using Mermaid syntax

Example usage

“Review this project’s architecture” – Maps the dependency graph, identifies that controllers directly import database models (layer violation), suggests introducing a service layer with repository traits, and provides a C4 Level 3 component diagram of the proposed structure.

Design & Visual Skills

Mon, 01 Jan 0001 00:00:00 +0000

Skills for frontend development, visual design, and creative production.

excalidraw

Generates Excalidraw diagrams programmatically as JSON. Use when creating architecture diagrams, flowcharts, or hand-drawn-style visuals for documentation.

Triggers: Creating architecture diagrams, flowcharts, system diagrams, or hand-drawn-style visuals for documentation Tools: None References: json-schema.md

Key capabilities:

Generate Excalidraw JSON files with proper structure (elements, appState, version 2 format)
Create element types: rectangles, ellipses, diamonds, lines, arrows, text, with configurable styles
Bind text labels to shapes for labeled diagrams
Follow layout guidelines: grid alignment (multiples of 20), consistent spacing, readable font sizes
Apply a semantic color palette (primary, secondary, success, warning, danger, neutral)
Produce architecture diagrams, flowcharts, and sequence-style diagrams
Embed in documentation as .excalidraw, SVG, or PNG

Example usage

“Create an architecture diagram for a web app with React frontend, Node API, and PostgreSQL” – Generates Excalidraw JSON with three labeled rectangles arranged left-to-right, connected by arrows labeled “HTTP/REST” and “SQL”, using blue for frontend, green for API, yellow for database.

Data & Analytics Skills

Mon, 01 Jan 0001 00:00:00 +0000

Skills for data science, data engineering, and analytics workflows.

data-science

Data analysis workflow from import through modeling and communication. Covers tidy data, EDA, statistical reasoning, and visualization. Use when analyzing datasets, building statistical models, exploring data, or communicating findings.

Triggers: Analyzing datasets, exploring data, building statistical models, creating visualizations, cleaning messy data, communicating findings Tools: Bash(python:*) Bash(jupyter:*) Read Write References: tidy-data-principles.md, statistical-methods.md, visualization-guidelines.md

Key capabilities:

Import and clean data: inspect shape/dtypes/nulls, handle missing data explicitly, parse dates, validate assumptions
Reshape data to tidy form (one variable per column, one observation per row) using melt/pivot
Conduct exploratory data analysis: univariate distributions, bivariate relationships, outlier detection, groupby aggregations
Apply statistical reasoning: state the question first, check assumptions, report effect sizes alongside p-values, use confidence intervals
Perform feature selection: remove zero-variance features, handle multicollinearity, use domain knowledge then data-driven methods
Follow model selection workflow: start simple (baseline), add complexity only when justified, use cross-validation, document decisions
Visualize with best practices: titles, axis labels, colorblind-friendly palettes, annotations, publication-quality export
Communicate results: lead with findings, plain language, show uncertainty, include actionable “so what”

Example usage

“I have a CSV of customer transactions. Help me understand churn patterns.” – Loads the CSV, prints shape/dtypes/nulls, creates tidy time-series per customer, runs EDA with churn-rate distributions and cohort analysis, tests whether usage frequency differs between churned/retained groups (t-test with effect size), and produces annotated visualizations summarizing the key drivers.

AI & ML Skills

Mon, 01 Jan 0001 00:00:00 +0000

Skills for AI/ML development, RAG pipelines, prompt engineering, and model evaluation.

ai-fundamentals

Core ML/AI concepts including model types, training pipelines, evaluation metrics, and neural network architectures. Use when explaining AI concepts, choosing model approaches, designing ML solutions, or reviewing AI-related code.

Triggers: Explaining ML/AI concepts, choosing model architectures, designing training pipelines, selecting evaluation metrics, debugging model performance (overfitting, leakage, class imbalance) Tools: None References: ml-concepts.md, math-foundations.md

Key capabilities:

Classify problems by learning paradigm: supervised, unsupervised, reinforcement, self-supervised
Match model types to problems: linear models for baselines, tree-based (XGBoost/LightGBM) for tabular data, neural networks for unstructured data, probabilistic models for uncertainty
Design correct training pipelines: data prep, train/val/test split before preprocessing, feature engineering, training, hyperparameter tuning, regularization, final evaluation
Select evaluation metrics by task: F1/AUC-ROC for classification, RMSE/MAE for regression, NDCG/MAP for ranking, BLEU/ROUGE for generation
Understand neural network architectures: MLP, CNN, RNN/LSTM, Transformer, GAN, VAE, diffusion models
Explain modern LLM concepts: attention, tokenization, pre-training + fine-tuning, RLHF, prompting strategies, scaling laws
Identify common pitfalls: data leakage, overfitting, underfitting, class imbalance, distribution shift, metric mismatch

Example usage

“Choose an approach for tabular customer churn prediction” – With 50K labeled rows of structured data, recommends gradient-boosted trees (XGBoost/LightGBM) with stratified k-fold cross-validation for the imbalanced target. Reports F1 and AUC-ROC. Baselines with logistic regression first, only considers neural approaches if tree models plateau.

API & Integration Skills

Mon, 01 Jan 0001 00:00:00 +0000

Skills for API design, protocol patterns, and system integration.

api-design

REST API design including resource naming, HTTP methods, status codes, pagination, versioning, and OpenAPI specs. Use when designing APIs, reviewing API contracts, or writing OpenAPI/Swagger documentation.

Triggers: Designing a new REST API or extending an existing one, reviewing API contracts, writing OpenAPI/Swagger docs, choosing pagination or versioning strategies, defining error response formats. Tools: Bash Read Write References: rest-conventions.md, openapi-patterns.md

Key capabilities:

Security Skills

Mon, 01 Jan 0001 00:00:00 +0000

Skills for application security, authentication, and threat analysis.

dependency-audit

Audits project dependencies for vulnerabilities and outdated packages. Use when checking security posture or planning dependency updates.

Triggers: Checking dependencies, auditing security, updating packages, verifying dependency health before a release. Tools: None References: None

Key capabilities:

Multi-ecosystem audit tool selection (cargo audit, pip-audit, npm audit, govulncheck)
Severity-based triage: critical/high (fix immediately), medium (this sprint), low (when convenient)
Update strategy: one dependency at a time, full test suite after each, changelog review
Outdated package detection (cargo outdated, pip list –outdated, npm outdated)
Ongoing maintenance: monthly reviews, Dependabot/Renovate automation, pinned version documentation

Example usage

User asks “Are my dependencies secure?” The agent runs the appropriate audit tool for the project’s package manager, summarizes findings by severity, and recommends specific version bumps for vulnerable packages. Flags any dependencies with no maintained alternatives.

Observability Skills

Mon, 01 Jan 0001 00:00:00 +0000

Skills for logging, monitoring, tracing, and alerting in production systems.

logging-strategy

Structured logging strategy including log levels, correlation IDs, context propagation, and PII avoidance. Use when designing logging, reviewing log statements, or setting up log aggregation.

Triggers: Designing a logging approach, reviewing existing log statements, setting up log aggregation (ELK, Loki, CloudWatch), adding correlation IDs, deciding what to log and what to avoid. Tools: Bash Read Write References: structured-logging.md

Key capabilities:

Database Skills

Mon, 01 Jan 0001 00:00:00 +0000

Skills for SQL, data modeling, NoSQL patterns, and schema migrations.

sql-patterns

SQL query patterns, schema design, and optimization. Joins, CTEs, window functions, indexing, and anti-patterns. Use when writing SQL queries, designing schemas, optimizing database performance, or reviewing database code.

Triggers: Writing or optimizing SQL queries (joins, CTEs, window functions), designing or reviewing schemas, analyzing EXPLAIN plans, choosing indexing strategies, fixing slow queries, implementing pagination or analytical queries. Tools: Bash Read Write References: query-patterns.md, schema-design.md

Framework & SEO Skills

Mon, 01 Jan 0001 00:00:00 +0000

Skills for specific frameworks and search engine optimization.

reflex-python

Reflex Python web framework for building full-stack apps in pure Python. Components, state management, and deployment. Use when building Reflex apps, designing component hierarchies, or managing app state.

Triggers: When building web apps with Reflex, designing components, managing state, routing, or creating full-stack Python web applications. Tools: Bash(reflex:*) Bash(python:*) Read Write References: component-reference.md

Key capabilities:

App structure: initialization, entry points, page decorators, file-based routing, configuration
Component system: layout (box, flex, grid), display (text, heading, image), input (input, select, checkbox), feedback (alert, toast, spinner)
State management with rx.State classes, typed vars, event handlers, computed vars, and substates
Event handling: on_click, on_change, two-way binding, background tasks, event chaining
Styling with Radix UI design tokens, responsive props, light/dark themes
Routing with dynamic segments, programmatic navigation, on_load events, and 404 handling
Database integration via built-in SQLModel with automatic migrations
Deployment to Reflex Cloud or self-hosted via Docker

??? example “Example usage” Build a todo app: Defines a TodoState with a list of todos and input field, creates event handlers for add/delete/toggle, builds UI with rx.input, rx.button, and rx.foreach(TodoState.todos, render_todo) to render the list dynamically.

Performance Skills

Mon, 01 Jan 0001 00:00:00 +0000

Skills for performance analysis, optimization, and load testing.

performance-profiling

Performance analysis methodology and profiling techniques for CPU, memory, and I/O. Flame graphs, benchmarking, and regression detection. Use when optimizing performance, profiling bottlenecks, or reviewing performance-critical code.

Triggers: When identifying bottlenecks, profiling CPU/memory/I/O, interpreting flame graphs, setting up benchmarks, or optimizing slow code paths. Tools: Bash Read Write References: profiling-tools.md

Key capabilities:

Follow the full performance analysis cycle: Identify, Measure, Profile, Optimize, Verify
CPU profiling with sampling profilers and flame graph generation
Memory profiling to detect leaks, allocation pressure, and unbounded growth
I/O profiling for disk, network, and database bottlenecks (N+1 queries, connection pooling, slow queries)
Benchmarking with statistical significance and regression detection
Flame graph interpretation: reading X-axis (alphabetical, not time), Y-axis (stack depth), and differential flame graphs
Common optimization patterns: algorithmic improvements, batching, caching, pooling, lazy evaluation, data layout

??? example “Example usage” Slow API endpoint: Measures end-to-end latency, profiles the handler, discovers 80% of time spent in 47 sequential database queries (N+1 problem). Rewrites as a single JOIN query, reducing response time from 3 seconds to 120ms.