adr-management
Create, index, and maintain Architecture Decision Records (ADRs) using the Michael Nygard template.
#category
76 skills tagged category · scope axis.
api-contract-design
Design REST or gRPC API contracts (OpenAPI/Protobuf) before any implementation code is written. Contract-first development.
api-documentation
Generate, validate, and maintain API endpoint documentation including OpenAPI specs, request/response examples, and versioned API references.
api-implementation
Implement API handlers/controllers based on an existing API contract (OpenAPI spec). Generates route handlers, validation, and error handling.
auth-implementation
Implement authentication and authorization safely: JWT, OAuth2, RBAC, or API key strategies.
brownfield-onboarding
Structured first-touch protocol for understanding an existing codebase before contributing to it. Reads the README, ADRs, most-changed and most-recent files, dependency manifests, build/CI config, and test layout, and emits an onboarding cheat-sheet other Aparigraha skills (style-conformance, reuse-first, minimal-diff, chesterton-fence) consume on subsequent tasks.
caching-strategy
Design and implement caching layers using Redis, Memcached, or in- memory caches with proper invalidation strategies.
changelog-generation
Generate changelogs from commit history using semantic versioning and conventional commits, including release notes and breaking change notices.
chesterton-fence
Before deleting, refactoring, or "cleaning up" code that looks unused, redundant, or weird, investigate why it exists. Produces a why-it-exists memo plus an edge-case checklist that must be confirmed before any change to the existing code is committed. Implements the Chesterton's-Fence side of Validate-Before-Trust under Aparigraha.
ci-pipeline
Generate CI/CD pipeline configurations for GitHub Actions, GitLab CI, or Azure Pipelines.
cleanup
Remove noise, enforce formatting, and safely rename identifiers. A mixed-mode skill: cosmetic fixes run in Eco, renaming runs in Power.
code-generation
Generate production-ready code from specifications, templates, and domain models. Enforces language idioms, DRY principles, and project conventions.
code-review
Perform structured code reviews with checklists, PR feedback, defect categorization, and severity classification.
data-access
Implement data access layers using the Repository pattern. Prevents N+1 queries, manages transactions, and optimizes reads.
database-design
Schema design, normalization analysis, migration planning, and index strategy for relational and NoSQL databases.
db-tuning
Database performance tuning: index analysis, query plan optimization, connection pooling, and configuration tuning.
decision-records
Create, manage, and query Architectural Decision Records (ADRs) using the context/decision/consequences format to capture design rationale.
dependency-analysis
Analyse project dependencies — build dependency graphs, detect circular references, assess upgrade risks, and plan version migrations.
dependency-scanning
Scan project dependencies for known CVEs and license compliance issues. Works with npm, pip, go mod, Maven, NuGet.
dependency-updates
Automate and manage dependency updates with semver-aware compatibility checks, breaking change detection, and lockfile management.
dependency-utility-scout
Mine the project's declared dependencies (BOM, package.json, requirements.txt, Pipfile, go.mod, Cargo.toml, etc.) and produce a curated inventory of the utilities they expose, so reuse-first and other Aparigraha skills can decide quickly without rediscovering the graph each time. Consults; never auto-rewrites.
deprecation-management
Manage deprecation lifecycles including notices, sunset timelines, migration paths, and backward compatibility guarantees.
docker-containerization
Write optimized Dockerfiles with multi-stage builds, security best practices, and minimal image sizes.
domain-modeling
Create and maintain a domain glossary with entities, relationships, and Protected Terms that must never be renamed.
error-handling
Standardize error types, logging formats, and error response structures across the project.
error-handling-debug
Debug and improve error handling strategies including exception hierarchies, retry logic, graceful degradation, and circuit breakers.
estimation
Produce effort estimates with confidence intervals, calibrate against historical data, and communicate uncertainty clearly.
git-workflow
Guide branching strategies, commit conventions, merge vs rebase decisions, and conflict resolution workflows for consistent version control practices.
incident-response
Structured steps to triage, mitigate, and resolve production incidents. Includes severity classification and postmortem template.
inline-documentation
Analyze, generate, and improve inline code documentation including JSDoc, docstrings, type annotations, and comment quality.
integration-testing
Test across component boundaries using real databases, HTTP clients, and message queues via Docker containers.
knowledge-sharing
Establish documentation culture, wikis, runbooks, onboarding guides, and tribal knowledge capture to reduce bus factor and accelerate teams.
kubernetes-helm
Generate Kubernetes manifests and Helm charts for deploying containerized applications to K8s clusters.
legacy-upgrade
Plan and execute upgrades of major frameworks, languages, or runtime versions with minimal disruption.
log-analysis
Parse, correlate, and analyze application logs to detect patterns, anomalies, and causal chains across distributed systems.
migration-planning
Plan and coordinate version upgrades, data migrations, rollback strategies, and blue-green deployments for safe system transitions.
minimal-diff
Generate the smallest correct change that solves the stated problem. No drive-by formatting, no opportunistic renames, no "while I'm here" expansions. Implements the Surgical-Before-Sweeping gate of Aparigraha with diff-size guardrails, scope checks, and reversibility validation.
monitoring-setup
Design and configure observability stacks covering metrics, logs, traces, alerting, SLIs/SLOs, and dashboards.
mutation-testing
Verify test suite quality by injecting faults (mutants) into the code and checking if tests catch them.
naming-conventions
Name scripts, tools, and files so their name tells you when and how to use them. CLI tools you run are verb-noun; imported libraries are nouns; internal helpers start with an underscore. Apply when adding or renaming any script.
openapi-specs
Generate or update OpenAPI (Swagger) specifications from existing code, or validate code against existing specs.
pair-programming
Facilitate effective pair and mob programming sessions including role rotation, session structure, and knowledge transfer practices.
performance-review
Identify performance bottlenecks through complexity analysis, profiling review, caching strategy evaluation, and resource utilization assessment.
pipeline-context
Pre-compute expensive operations once and pass via shared context object to all pipeline stages. Eliminates O(n) recomputation in multi-stage processing.
plan-as-agreement
Writes the plan.md as a fit-for-purpose agreement between user and agent. Auto-selects one of 16 named plan formats (or a 2-3 format hybrid) based on task signals — top-level, file-by-file, exact-diff, pseudocode-first, component-tree, sequence-diagram, state-machine, trace-before-patch, stats-driven-cleanup, spike, api-contract, data-migration, benchmark, multi-pr-staged, security-patch, test-coverage. Composes task-decomposition, risk-assessment, estimation, root-cause-analysis when needed. Complements Claude Code, Cursor, and Cline plan-mode harnesses — doesn't replace them.
pr-management
Manage pull request lifecycle including templates, reviewer assignment, merge criteria, and stale PR handling for efficient code integration.
prd
Adaptive PRD authoring — selects the right format (lean 1-pager, full structured, working backwards, or hypothesis-driven), guides section-by-section completion, and manages document lifecycle with versioning, status transitions, and amendment logging.
profiling-analysis
Analyze application performance using profiling tools, traces, and logs to identify bottlenecks and hotspots.
progressive-execution
Return fast approximate results immediately (Phase 1), then enhance with slower enriched results (Phase 2). Phase 1 is standalone. Phase 2 is optional enhancement. If Phase 2 fails, Phase 1 stands.
readme-generation
Create comprehensive README files with installation instructions, usage examples, API reference, and contribution guidelines.
refactoring
Safely restructure code while preserving external behavior. Applies proven refactoring patterns with mandatory test verification.
refactoring-suite
Complex refactoring operations with strict test verification. Every refactor follows: Test → Refactor → Test → Revert-on-Fail.
release-notes
Parse git history to generate changelogs and release notes following Conventional Commits and Keep a Changelog formats.
repo-maintenance
Adaptive cleanup framework for repo-wide structural optimization. Embodies the principle: start simple, explore, discover value, pivot strategy toward the greater good. Deletion is the last resort. Cleanup is the example — adaptive direction-seeking is the lesson.
requirements-elicitation
Interview the user to extract goals, constraints, success metrics, and acceptance criteria before any code is written.
resilience-patterns
Graceful degradation when external dependencies fail. Circuit breaker state machine, retry with backoff, bulkhead isolation, fallback chains, and timeout management.
resource-awareness
Monitor memory, CPU, time, and rate-limit constraints. Adapt behavior gracefully — degrade, shed load, switch algorithms. Prevents runaway resource usage and cascading failures.
responsive-design
Make a web page work on every screen — phone to ultrawide — without text or media ever escaping its container. Invoke whenever building or changing any page/CSS that will be viewed on more than one screen size (i.e. always). Overflow and word-wrap bugs are treated as correctness bugs, not polish.
reuse-first
Before authoring any new utility, helper, wrapper, or abstraction, scan the project's existing source and declared dependencies for an equivalent. Reuse only after fit and edge-case validation; otherwise document why nothing fit and write fresh. Implements the Check-Before-Create and Validate-Before-Trust gates of Aparigraha.
risk-assessment
Identify project and technical risks, evaluate probability and impact, build risk matrices, and define mitigation strategies.
root-cause-analysis
Systematically trace symptoms back to their underlying cause using 5-whys, fault trees, bisection, and symptom-to-cause mapping.
schema-driven-config
Define configuration as a single schema that powers defaults, validation, storage, and optional UI generation. One entry per setting, zero duplication.
scorer-pipeline
Decompose complex evaluation into independent, composable micro-scorers with shared context and explicit weights. Universal pattern for any multi-factor ranking or assessment system.
secure-coding-review
Review code for OWASP Top 10 vulnerabilities, common security anti- patterns, and language-specific pitfalls.
security-review
Perform security-focused code review covering OWASP Top 10, vulnerability scanning, secret detection, and input validation.
style-conformance
Detect the project's existing coding conventions — naming, formatting, error handling, logging, test structure, comment style, module layout — and produce a "house style profile" that downstream skills consult when writing or modifying code. Awareness, not enforcement: the agent conforms within the scope of the change and surfaces deviations rather than auto-fixing them.
system-design
High-level system architecture: component diagrams, data flow, scalability trade-offs, and technology selection.
task-decomposition
Break complex tasks into ordered subtasks with dependency mapping, effort estimation, and parallel execution opportunities.
tdd-workflow
Drive implementation through the Red-Green-Refactor cycle. Write failing tests first, implement minimal code to pass, then refactor.
tech-debt-tracking
Categorize, score, and prioritize technical debt with impact analysis, payoff estimation, and debt budget management.
terraform-iac
Generate Infrastructure as Code using Terraform (or OpenTofu). Modules, state management, and environment separation.
test-strategy
Define the testing pyramid for a project: unit, integration, E2E. Set coverage targets and testing conventions.
testing-strategy
Define test pyramid structure, coverage analysis, test type selection, and boundary condition identification for comprehensive quality assurance.
threat-modeling
Identify threats using STRIDE methodology, assess risk, and prioritize mitigations for a system or component.
two-pass-analysis
Decouple metric collection from pass/fail gating. Pass 1 gathers raw data. Pass 2 applies thresholds. Enables trend analysis without blocking, while still enforcing standards.
unit-testing
Generate unit tests following AAA pattern (Arrange-Act-Assert). Supports Jest, JUnit, Go Test, PyTest, and more.