adr-management
When you need to record why a decision was made — creates and manages Architecture Decision Records.
#category
73 skills tagged category · scope axis.
api-contract-design
When frontend and backend need to agree before coding — designs REST/gRPC APIs with OpenAPI spec.
api-documentation
When consumers need to know how to call your API — endpoint docs, OpenAPI specs, request/response examples.
api-implementation
When the API contract is ready and needs code behind it — implements handlers/controllers with validation.
auth-implementation
When you need auth that won't become a breach headline — implements JWT, OAuth2, or RBAC safely.
brownfield-onboarding
First-touch protocol for a new project — read README/AGENTS.md/ADRs, find build/test/CI commands, hot zones, entry points, and test layout; emit an onboarding cheat-sheet other Aparigraha skills consume.
caching-strategy
When the same expensive query runs hundreds of times — implements caching patterns with proper invalidation.
changelog-generation
When users need to know what changed and why — conventional commits parsing, semantic versioning, release notes.
chesterton-fence
Before deleting or refactoring code that looks unused or weird, reconstruct why it exists from history, tests, comments, and call-graph; produce a memo plus an edge-case checklist that gates the change.
ci-pipeline
When you need CI that catches failures before they hit main — generates GitHub Actions/GitLab CI with artifact gating.
cleanup
When the codebase has accumulated cruft — removes noise, enforces formatting, safely renames identifiers.
code-generation
When you have a spec and need idiomatic code — generates from specs with language convention enforcement.
code-review
When a PR needs more than a thumbs-up — review checklists, defect categories, severity classification.
data-access
When your API is fast but your database calls aren't — repository pattern, query optimization, N+1 prevention.
database-design
When data modeling decisions will outlast the code — schema design, normalization, migration planning, indexing.
db-tuning
When queries are the bottleneck — index analysis, query plan optimization, connection pooling.
decision-records
When future-you needs to know why past-you chose this — ADR authoring with context, decision, consequences.
dependency-analysis
When you're not sure what depends on what — builds dependency graphs, detects cycles, audits for staleness and CVEs.
dependency-scanning
When your supply chain is only as strong as its weakest dep — checks for CVEs and license compliance.
dependency-updates
When dependencies drift and Dependabot floods you with PRs — automated updates with semver and lockfile discipline.
dependency-utility-scout
Mine the project's declared dependencies and produce a per-capability inventory of utilities the team already imports — advisory, never auto-rewrites.
deprecation-management
When old APIs need to die without breaking consumers — sunset timelines, migration paths, impact analysis.
docker-containerization
When your Docker image is bloated and slow to build — generates optimized multi-stage Dockerfiles.
domain-modeling
When the team uses different words for the same thing — creates a domain glossary, entity map, and Protected Terms.
error-handling
When every module handles errors differently — standardizes error types, logging, and response formats.
error-handling-debug
When errors cascade instead of being contained — exception hierarchies, retry strategies, graceful degradation.
estimation
When "how long will this take?" needs a real answer — PERT estimation, relative sizing, confidence intervals.
git-workflow
When the team needs git discipline without git fights — branching strategies, commit conventions, conflict resolution.
incident-response
When production is down and the clock is ticking — triage, mitigate, and resolve outages with postmortem.
inline-documentation
When code needs to explain itself to future readers — JSDoc/docstrings, comment quality, self-documenting patterns.
integration-testing
When unit tests pass but the system doesn't work — tests across component boundaries with Docker containers.
knowledge-sharing
When tribal knowledge walks out the door with departing teammates — wikis, runbooks, onboarding guides.
kubernetes-helm
When you need reproducible K8s deployments — generates Helm charts and Kubernetes manifests.
legacy-upgrade
When the framework is 3 versions behind and nobody wants to touch it — plans major upgrades safely.
log-analysis
When the answer is buried in 10,000 log lines — parsing, pattern recognition, event correlation, anomaly detection.
migration-planning
When you need to move data without losing it — version upgrades, data migration, rollback strategies.
minimal-diff
Smallest correct change that solves the problem. No drive-by formatting or opportunistic refactors; diff-size caps, reversibility checks, and commit splitting when concerns are tangled.
monitoring-setup
When you need to know something is broken before users tell you — SLIs/SLOs, alerting, distributed tracing.
mutation-testing
When you suspect tests pass but don't actually catch bugs — verifies test quality by injecting faults.
openapi-specs
When your API docs are stale or missing — generates Swagger/OpenAPI YAML from code.
pair-programming
When two heads are better than one — driver/navigator roles, mob programming, knowledge transfer protocols.
performance-review
When the app is slow but you don't know where — bottleneck identification, complexity analysis, caching review.
pipeline-context
Pre-compute once, share via context object to all pipeline stages.
pr-management
When PRs linger or get rubber-stamped — templates, review assignments, merge criteria that work.
prd
When requirements exist but need structure — selects the right PRD format (lean, full, working-backwards, hypothesis) and produces a living document with versioning and lifecycle.
profiling-analysis
When something is slow and you need proof of where — analyzes logs/traces to find bottlenecks and hotspots.
progressive-execution
Fast approximate results (Phase 1) then slow enriched results (Phase 2).
readme-generation
When a new contributor clones the repo and has no idea where to start — creates READMEs with usage and install guides.
refactoring
When code needs restructuring but tests must stay green — safe refactoring with test-first verification.
refactoring-suite
When you need to restructure code without breaking behavior — complex refactors with strict test verification.
release-notes
When release day shouldn't mean manually writing changelog — parses git logs for changelogs and version bumps.
repo-maintenance
Adaptive cleanup framework — start simple, discover value, pivot toward greater good.
requirements-elicitation
When scope is fuzzy — interviews the user for goals, constraints, and success metrics before coding starts.
resilience-patterns
Circuit breaker, retry with backoff, bulkhead isolation, fallback chains, timeouts.
resource-awareness
Monitor constraints (memory, CPU, time, rate limits), adapt behavior gracefully.
reuse-first
Before writing any new utility, scan the codebase and declared dependencies for an equivalent. Reuse only after fit and edge-case validation.
risk-assessment
Before you ship something that keeps you up at night — identifies risks, scores probability/impact, plans mitigations.
root-cause-analysis
When the bug is a symptom, not the cause — 5-whys, fault trees, git bisection, symptom-to-cause mapping.
schema-driven-config
Single schema powers defaults, validation, storage, and UI generation.
scorer-pipeline
Composable evaluation — independent micro-scorers with shared context and explicit weights.
secure-coding-review
When code needs a security audit before shipping — scans for OWASP Top 10 vulnerabilities and anti-patterns.
security-review
When security can't be an afterthought — OWASP Top 10 scan, vulnerability detection, secret scanning.
style-conformance
Detect the project's existing conventions (naming, formatting, errors, logging, tests) and produce a house-style profile downstream skills consult — awareness, not enforcement.
system-design
When you need to see the big picture before building — component diagrams, data flow, trade-off analysis.
task-decomposition
When a task feels too big to start — breaks it into dependency-ordered subtasks with T-shirt sizing.
tdd-workflow
When you want tests to drive the design — Red-Green-Refactor cycle with coverage targets.
tech-debt-tracking
When tech debt is everywhere but you can only fix some — categorization, impact scoring, payoff prioritization.
terraform-iac
When infrastructure should be versioned like code — generates Terraform/OpenTofu IaC modules.
test-strategy
When you need a testing philosophy, not just tests — defines the pyramid, coverage targets, and conventions.
testing-strategy
When you're unsure what to test next — coverage analysis, test type selection, boundary condition identification.
threat-modeling
Before attackers find the holes — identifies STRIDE threats, assesses risk, plans mitigations.
two-pass-analysis
When you need metrics without false-failing the build — separates collection (Pass 1) from gating (Pass 2).
unit-testing
When a function needs proof it works — generates unit tests for Jest, JUnit, Go Test, PyTest.