domain-modeling
Create and maintain a domain glossary with entities, relationships, and Protected Terms that must never be renamed.
Engineering
82 skills in this domain.
10-discovery
Discovery
3 skills
20-architecture
Architecture
7 skills
20-planning
Planning
5 skills
25-pragmatism
Pragmatism
7 skills
30-implementation
Implementation
12 skills
40-quality
Quality
10 skills
50-documentation
Documentation
4 skills
50-performance
Performance
5 skills
60-debugging
Debugging
3 skills
60-security
Security
4 skills
70-devops
DevOps
6 skills
80-collaboration
Collaboration
5 skills
80-docs
Docs
3 skills
90-maintenance
Maintenance
8 skills
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.
requirements-elicitation
Interview the user to extract goals, constraints, success metrics, and acceptance criteria before any code is written.
adr-management
Create, index, and maintain Architecture Decision Records (ADRs) using the Michael Nygard template.
api-contract-design
Design REST or gRPC API contracts (OpenAPI/Protobuf) before any implementation code is written. Contract-first development.
database-design
Schema design, normalization analysis, migration planning, and index strategy for relational and NoSQL databases.
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.
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.
system-design
High-level system architecture: component diagrams, data flow, scalability trade-offs, and technology selection.
dependency-analysis
Analyse project dependencies — build dependency graphs, detect circular references, assess upgrade risks, and plan version migrations.
estimation
Produce effort estimates with confidence intervals, calibrate against historical data, and communicate uncertainty clearly.
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.
risk-assessment
Identify project and technical risks, evaluate probability and impact, build risk matrices, and define mitigation strategies.
task-decomposition
Break complex tasks into ordered subtasks with dependency mapping, effort estimation, and parallel execution opportunities.
aparigraha-task
Master workflow for any change touching an existing project. Walks the Aparigraha gates end-to-end — onboarding, dependency awareness, style detection, reuse-first authoring, surgical diff, post-execution audit — by orchestrating the foundation `pragmatism` philosophy and the `25-pragmatism` category skills. Contains no implementation logic.
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.
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.
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.
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.
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.
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.
api-implementation
Implement API handlers/controllers based on an existing API contract (OpenAPI spec). Generates route handlers, validation, and error handling.
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.
data-access
Implement data access layers using the Repository pattern. Prevents N+1 queries, manages transactions, and optimizes reads.
error-handling
Standardize error types, logging formats, and error response structures across the project.
feature-shipping
Master workflow for shipping a feature end-to-end. Orchestrates PRD authoring, task decomposition, TDD implementation, code review, and the release pipeline as a single named sequence ending in an audit. Contains no implementation logic.
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.
refactoring-workflow
Master workflow for refactoring at four named depth levels — cosmetic, micro, meso, architectural — that compose as a ladder. Always runs chesterton-fence and style-conformance up front; always closes with a characterisation/test safety net, minimal-diff scope checks, and the auditor. Contains no implementation logic; orchestrates only existing category skills.
resilience-patterns
Graceful degradation when external dependencies fail. Circuit breaker state machine, retry with backoff, bulkhead isolation, fallback chains, and timeout management.
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.
tdd-workflow
Drive implementation through the Red-Green-Refactor cycle. Write failing tests first, implement minimal code to pass, then refactor.
code-review
Perform structured code reviews with checklists, PR feedback, defect categorization, and severity classification.
integration-testing
Test across component boundaries using real databases, HTTP clients, and message queues via Docker containers.
mutation-testing
Verify test suite quality by injecting faults (mutants) into the code and checking if tests catch them.
performance-review
Identify performance bottlenecks through complexity analysis, profiling review, caching strategy evaluation, and resource utilization assessment.
pr-review-flow
Master workflow for a thorough PR review. Orchestrates code review, security review, and performance review in parallel, then routes the findings into PR management for triage and merge decisioning. No implementation logic.
security-review
Perform security-focused code review covering OWASP Top 10, vulnerability scanning, secret detection, and input validation.
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.
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.
api-documentation
Generate, validate, and maintain API endpoint documentation including OpenAPI specs, request/response examples, and versioned API references.
changelog-generation
Generate changelogs from commit history using semantic versioning and conventional commits, including release notes and breaking change notices.
decision-records
Create, manage, and query Architectural Decision Records (ADRs) using the context/decision/consequences format to capture design rationale.
inline-documentation
Analyze, generate, and improve inline code documentation including JSDoc, docstrings, type annotations, and comment quality.
caching-strategy
Design and implement caching layers using Redis, Memcached, or in- memory caches with proper invalidation strategies.
db-tuning
Database performance tuning: index analysis, query plan optimization, connection pooling, and configuration tuning.
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.
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.
error-handling-debug
Debug and improve error handling strategies including exception hierarchies, retry logic, graceful degradation, and circuit breakers.
log-analysis
Parse, correlate, and analyze application logs to detect patterns, anomalies, and causal chains across distributed systems.
root-cause-analysis
Systematically trace symptoms back to their underlying cause using 5-whys, fault trees, bisection, and symptom-to-cause mapping.
auth-implementation
Implement authentication and authorization safely: JWT, OAuth2, RBAC, or API key strategies.
dependency-scanning
Scan project dependencies for known CVEs and license compliance issues. Works with npm, pip, go mod, Maven, NuGet.
secure-coding-review
Review code for OWASP Top 10 vulnerabilities, common security anti- patterns, and language-specific pitfalls.
threat-modeling
Identify threats using STRIDE methodology, assess risk, and prioritize mitigations for a system or component.
ci-pipeline
Generate CI/CD pipeline configurations for GitHub Actions, GitLab CI, or Azure Pipelines.
docker-containerization
Write optimized Dockerfiles with multi-stage builds, security best practices, and minimal image sizes.
kubernetes-helm
Generate Kubernetes manifests and Helm charts for deploying containerized applications to K8s clusters.
monitoring-setup
Design and configure observability stacks covering metrics, logs, traces, alerting, SLIs/SLOs, and dashboards.
release-pipeline
Master workflow for cutting a release. Orchestrates test strategy selection, changelog generation, and CI pipeline invocation as a single named sequence ending in an audit. Contains no implementation logic.
terraform-iac
Generate Infrastructure as Code using Terraform (or OpenTofu). Modules, state management, and environment separation.
git-workflow
Guide branching strategies, commit conventions, merge vs rebase decisions, and conflict resolution workflows for consistent version control practices.
knowledge-sharing
Establish documentation culture, wikis, runbooks, onboarding guides, and tribal knowledge capture to reduce bus factor and accelerate teams.
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.
pair-programming
Facilitate effective pair and mob programming sessions including role rotation, session structure, and knowledge transfer practices.
pr-management
Manage pull request lifecycle including templates, reviewer assignment, merge criteria, and stale PR handling for efficient code integration.
openapi-specs
Generate or update OpenAPI (Swagger) specifications from existing code, or validate code against existing specs.
readme-generation
Create comprehensive README files with installation instructions, usage examples, API reference, and contribution guidelines.
release-notes
Parse git history to generate changelogs and release notes following Conventional Commits and Keep a Changelog formats.
dependency-updates
Automate and manage dependency updates with semver-aware compatibility checks, breaking change detection, and lockfile management.
deprecation-management
Manage deprecation lifecycles including notices, sunset timelines, migration paths, and backward compatibility guarantees.
incident-response
Structured steps to triage, mitigate, and resolve production incidents. Includes severity classification and postmortem template.
incident-response-flow
Master workflow for production incidents. Orchestrates incident response triage, root-cause analysis, log analysis, and decision-record capture into a single named sequence ending in an audit. Contains no implementation logic.
legacy-upgrade
Plan and execute upgrades of major frameworks, languages, or runtime versions with minimal disruption.
migration-planning
Plan and coordinate version upgrades, data migrations, rollback strategies, and blue-green deployments for safe system transitions.
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.
tech-debt-tracking
Categorize, score, and prioritize technical debt with impact analysis, payoff estimation, and debt budget management.