pkuppens
113 verified skills
architecture-quality
Documents quality tree and quality scenarios; maps to requirements (arc42 §10). Use when defining non-functional goals, scenarios, or acceptance of quality attributes.
development
architecture
Orchestrates architecture work across three modes. Use when starting a greenfield project, documenting existing code, or evolving architecture; routes to sub-skills (3.2–3.9) by mode.
development
architecture-glossary
Maintains glossary of business and technical terms (arc42 §12). Use when defining domain vocabulary or resolving terminology ambiguity.
data-ai
design-consult
Consults current design and architecture to place new code correctly within existing components, interfaces, and data flows. Use after architecture-consult, before implementation-construction; ensures single responsibility and correct layering.
development
design-component-boundaries
Defines module, package, and file boundaries so each unit has a single responsibility. Use when splitting a monolith, drawing C4 container boundaries, or stopping circular dependencies.
testing
design
Defines detailed design components, interfaces, and data flows. Use when working in lifecycle area 4.x per SKILL_TREE.
data-ai
design-interfaces
Specifies APIs, contracts, and schemas between components. Use when defining REST or RPC shapes, event payloads, or shared DTOs between modules.
development
governance
Tracks delivery progress, blameless learning after incidents, and decision evidence for compliance. Use when closing milestones, running retrospectives, or preparing audit trails.
development
governance-progress
Updates workflow state, milestone notes, and handoff context so the next person or agent can continue without rediscovery. Use when a slice finishes, a sprint ends, or ownership changes.
development
ideation-swot
Evaluates an idea using strengths, weaknesses, opportunities, and threats. Use when comparing a shortlist of options or deciding whether to invest in a proposal.
testing
issue-purpose-alignment
Ensures issue purpose is focused and aligned with project goals and quality attributes. Use when drafting or refining an issue; surfaces misalignment with arc42 goals or quality tree.
development
issue-out-of-scope
Defines out-of-scope for an issue to prevent gold-plating and scope creep. Use when drafting or refining an issue.
development
maintenance-debt
Plans and tracks technical debt work linked to architecture risks. Use when shortcuts accumulate, upgrades are deferred, or debt must be scheduled without blocking delivery forever.
data-ai
plan-dependencies
Identifies which tasks block others and surfaces the critical path. Use when parallelisation is possible but ordering mistakes would waste time.
testing
requirements-capture
Records functional and non-functional requirements from stakeholders or issue text. Use when starting a feature, migrating notes into structured requirements, or clarifying vague asks.
tools
requirements-goals
Extracts top quality goals and success criteria aligned with arc42 introduction and goals. Use when defining why the system exists and how stakeholders judge success.
development
test-write
Adds or updates automated tests at unit, integration, or end-to-end level. Use when implementing behaviour, fixing bugs, or locking a contract with tests.
testing
test-run
Executes the test suite locally or in CI and interprets failures. Use when validating a branch, debugging CI red builds, or checking coverage gates.
development
v-model-implementation-unit
Pairs implementation work with unit-level tests. Use when closing the bottom of the V for modules and pure logic. Third person.
testing
v-model-design-verification
Pairs detailed design with component and contract-level verification. Use when APIs, schemas, or module contracts need proving tests. Third person.
development
v-model-architecture-integration
Pairs architecture artefacts with integration and structural verification. Use when boundaries, deployment, or runtime scenarios must be proven in tests. Third person.
testing
v-model-retrofit
Applies V-model traceability to brownfield codebases via explicit retrofit issues or touch-driven updates during normal work. Use when the system was built without a closed V. Third person.
development
validation-detail
Refines validation steps with implementation-specific commands, URLs, and fixtures once code shape exists. Use when moving from high-level checks to an executable checklist before merge.
development
azure-devops-repos
Creates, reviews, and completes Azure Repos pull requests and branch policies via az repos CLI. Use when opening ADO PRs, setting required reviewers, or configuring build validation policies.
tools
azure-devops-work-items
Creates, queries, updates, and links Azure Boards work items via az boards CLI. Use when filing ADO work items, running WIQL queries, or setting area path, iteration, tags, and assignee.
tools
azure-devops-pipelines
Guides Azure Pipelines YAML structure, build validation on PRs, and staged deployment with environments and approvals. Use when authoring azure-pipelines.yml or configuring CI/CD on Azure DevOps.
development
azure-devops
Orchestrates Azure DevOps work item, repo, and pipeline workflows using az CLI. Use when working with Azure DevOps, Azure Repos, Azure Boards, Azure Pipelines, or az devops commands.
tools
integration
Orchestrates commit, PR, and merge; enforces conventional commits and issue linkage. Use when completing work ready for main; runs after quality-gate passes.
testing
issue-metadata
Adds tags, milestones, assignees (always the user who triggered the issue), and planning references. Use when finalising an issue for GitHub or project tracking.
data-ai
issue-gh-bulk-scratch
Creates an EPIC and many GitHub issues with gh, keeps local gitignored tmp body files named 1-1 with issue numbers, and self-assigns. Use when batch-filing a portfolio/roadmap set from scratch files or renumbering after creation.
tools
code-review
Structured pull-request review checklist (imports, module headers, domain-neutral compliance language, naming). Use after opening a PR or when reviewing merged changes for lessons learned.
development
quality-gate
Runs lint, format, type check, and security scan; enforces pre-commit hooks. Use before every commit and as the final step before opening a PR. Invokes sub-skills (lint, format, type, security) as needed.
development
agent-frameworks
Compares AI agent frameworks: LangChain/LangGraph, Semantic Kernel, AutoGen, CrewAI. Guides framework selection based on language, agent pattern, and deployment constraints. Use when choosing or evaluating an agent framework.
development
skill-creation
Authors AI agent skills for Cursor, Claude Code, and similar tools using SKILL.md structure and progressive disclosure. Use when creating, writing, or refactoring a skill; when the user mentions SKILL.md, skill frontmatter, or skill best practices; or when the user invokes slash commands that map here (includes create-skill).
tools
agent-types
Classifies AI agent patterns: chat completion, tool-using, ReAct, A2A protocol, subagents, and multi-agent orchestration. Use when choosing the right agent architecture for a task or comparing agent interaction patterns.
tools
architecture-decisions
Authors or updates Architecture Decision Records. Use when making or changing architecture decisions; produces arc42 §9 content and ADR files.
testing
architecture-document-existing
Infers and documents architecture from an existing codebase. Use when the codebase has no or minimal architecture docs; produces arc42-aligned documentation.
development
deployment
Orchestrates deployment to target environment; runs build and release checks. Use when deploying artefacts to staging or production.
development
branch-cleanup-after-pr
Sync local branches after a PR is merged. Checkout main, pull, fetch --prune, delete local branches that are merged or track gone remotes. Use when a PR was just merged (merge, squash, or rebase) or when local branch list is stale.
development
deployment-release
Releases validated artefacts to staging or production; runs smoke tests; triggers rollback on failure. Use when deploying a new version to an environment, updating infrastructure, or executing a release checklist.
testing
integration-commit
Commits staged changes with conventional commit message; references issue. Use after quality-gate passes, before opening PR.
testing
issue-acceptance-criteria
Defines acceptance criteria as a minimum baseline of done. Use when drafting or refining an issue; ensures criteria are testable and include copy-pastable validation steps.
testing
ideation
Generates and evaluates product or engineering ideas before formal requirements. Use when exploring options, comparing approaches, or checking for existing solutions to reuse.
testing
issue-work-down
Identifies work-down from other issues, existing code, and tests; scopes the issue. Use when drafting or refining an issue to avoid duplicate work and clarify boundaries.
development
mojo-syntax
Help to write Mojo code using current syntax and conventions. Always use this skill when writing any Mojo code, including when other Mojo-specific skills (e.g., mojo-gpu-fundamentals) also apply. Use when writing Mojo code, translating projects to Mojo, or otherwise generating Mojo. Use this skill to overcome misconceptions with how Mojo is written.
development
openclaw-security
Enforces OpenClaw security constraints and mandates security audit before every code-change PR. Use when working on OpenClaw projects, before opening a PR, or when configuring or hardening OpenClaw.
development
new-modular-project
Creates a new Mojo or MAX project. Use when wanting to start a new Mojo or MAX project, initializing the Pixi or UV environment to use Mojo or MAX, or when the user wants to begin a new Mojo or MAX project from scratch.
tools
operations-incident
Triages, mitigates, and communicates production incidents; produces a post-incident timeline. Use when a service is degraded or down, when an alert fires, or when preparing an incident report.
testing
validation
Drafts and executes validation steps; ensures acceptance criteria are met. Use when working in lifecycle area 8.x per SKILL_TREE.
tools
mojo-gpu-fundamentals
The basics of how to program GPUs using Mojo. Use this skill in addition to mojo-syntax when writing Mojo code that targets GPUs or other accelerators. Use targeting code to NVIDIA, AMD, Apple silicon GPUs, or others. Use this skill to overcome misconceptions about how Mojo GPU code is written.
development
operations-audit
Performs compliance, security, and performance audits of a service or codebase. Use when preparing for a security review, assessing technical debt, validating GDPR/HIPAA compliance posture, or running a performance baseline.
development
skill-benchmark
Evaluates skill effectiveness by comparing agent output on a task with and without skills activated. Use when validating that a skill improves output quality, when creating evidence for a skill PR, or when regression-testing skill changes.
testing
verification-before-completion
Requires evidence before claiming work is done or fixed. Use before commit/PR, before telling a user “it works”, or when closing a task.
data-ai
agent-context
Guides context management for AI agents: RAG pipelines, knowledge graphs, embeddings, conversation memory, and context window strategies. Use when adding external knowledge to agents or managing long conversations.
devops
architecture-crosscutting
Documents crosscutting concepts: dependency rules, layering, and architecture tests. Use when enforcing constraints or detecting architecture drift; produces arc42 §8 content.
testing
architecture-risks-debt
Documents risks, technical debt, and mitigation. Use when evolving architecture or addressing tech debt; produces arc42 §11 content.
documentation
v-model-mapping
Maps classic V-model stages to pkuppens SKILL_TREE skills 2–10. Use when explaining or applying V traceability alongside arc42 and Agile slices. Third person.
data-ai
v-model
Maps V-model traceability to the skill tree (requirements through tests). Use when pairing left-arm artefacts with right-arm verification, Agile mini-V per issue, brownfield retrofit, or compliance-style evidence. Third person.
testing
requirements-prioritise
Prioritises requirements using MoSCoW or value versus effort so the team can cut or defer safely. Use when the backlog exceeds capacity or MVP must be defined.
testing
plan-tasks
Breaks an issue into ordered tasks or subtasks with clear outcomes. Use when the issue is too large for one PR or when parallel work needs a split.
tools
operations-monitoring
Monitors production logs, metrics, and alerts; detects anomalies; surfaces health status. Use when reviewing production health, investigating a spike in errors or latency, setting up observability for a new service, or verifying post-deploy stability.
testing
operations
Monitors production; handles incidents; audits. Use when monitoring, responding to incidents, or performing audits. Sub-skills (13.1–13.3) available.
testing
issue-estimate
Adds T-shirt size (or equivalent) estimate to an issue. Use when drafting or refining an issue for planning and prioritisation.
tools
implementation-refactor
Restructures code without changing observable behaviour. Use when reducing duplication, improving names, or preparing for a feature while keeping tests green.
development
maintenance-cleanup
Branch cleanup, GitHub Actions runs, tmp/ hygiene after merge. Use when cleaning up after PR merge, deleting local branches, removing worktrees, or pruning stale workflow runs.
data-ai
implementation
Code construction, refactor, and deletion per SKILL_TREE §7. Use when implementing or changing behaviour; delegates to 7.1–7.3.
development
governance-audit-trail
Maintains a defensible record of decisions, approvals, and changes for reviewers or regulators. Use when evidence must link requirements to code, deployments, or access control.
development
code-quality-docs
Apply comment and documentation standards for Python code. Use when writing docstrings, adding comments, or marking technical debt (TODOs). Ensures explain-why-not-what and traceable debt.
development
deployment-build
Builds artefacts (container images, packages, bundles) and validates build pipeline output. Use when preparing a release, running docker build, uv build, or a CI build job, or when verifying artefact integrity before release.
development
validation-draft
Drafts validation steps, BDD scenarios, or test cases from issue acceptance criteria. Use before or during implementation to produce an executable checklist; supports TDD (run before coding) and post-implementation verification.
testing
architecture-building-blocks
Documents static decomposition: hierarchy and black-box/white-box view of building blocks. Use when defining structure for a new system; produces arc42 §5 content.
development
api-design
Enforce API design rules when adding or changing endpoints. Apply REST conventions, versioning, deduplication semantics, OpenAPI documentation.
development
implementation-delete
Removes dead code, unused modules, and obsolete flags safely. Use when shrinking the codebase, deleting a feature, or clearing experiment paths.
development
v-model-requirements-acceptance
Pairs requirements and issue acceptance criteria with acceptance-level validation. Use when closing the top of the V for a feature or release slice. Third person.
data-ai
code-quality-design
Apply complexity management, naming, and function design principles from Code Complete 2 and A Philosophy of Software Design. Use when designing modules, refactoring, or reviewing code for structural quality.
development
code-quality-testing
Apply testing efficiency and effectiveness principles. Use when writing tests, reviewing test suites, or improving test coverage. Emphasizes behavioral coverage and mutation-aware assertions.
development
architecture-consult
Consults current architecture docs, ADRs, and codebase to identify relevant components, modules, and files. Use before adding a feature, scoping a change, or placing new code; surfaces constraints and existing decisions.
development
architecture-runtime
Documents runtime behaviour: technical execution paths, component interactions, sequences (arc42 §6). Use when documenting flows or tracing execution.
testing
architecture-solution-strategy
Documents core ideas, fundamental decisions, and solution approaches for a new system. Use when starting a greenfield project; produces arc42 §4 content.
testing
brainstorm
Produces a broad set of candidate ideas from a problem or opportunity. Use when starting discovery, before narrowing scope, or when the team is stuck in a single solution.
data-ai
issue-check-duplicates
Checks open and recently closed GitHub issues to prevent duplication. Use when drafting a new issue or validating that an idea is not already tracked.
testing
create-validation
Create an implementation validation document for a feature or issue. Produces a step-by-step checklist with exact commands, URLs, and expected outcomes. Use after implementation planning or before PR creation to define how the feature can be verified end-to-end.
testing
design-data-model
Describes entities, relationships, and lifecycle rules for persistence and APIs. Use when adding tables, migrations, or shared DTOs that must stay consistent.
development
find-skills
Helps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist as an installable skill.
data-ai
git-worktrees
Explains git worktrees and Claude Code usage; guides removal and cleanup when a branch cannot be deleted because of an active worktree. Use when "cannot delete branch used by worktree", cleaning up .claude/worktrees/, or when the user asks about worktrees.
development
governance-post-mortem
Runs a blameless review after incidents or major misses to capture causes and follow-up work. Use when production broke, a release failed, or a project lesson should be institutionalized.
development
ideation-reuse-check
Searches for existing libraries, patterns, and internal code to reuse before designing from scratch. Use when a new feature might duplicate OSS, platform APIs, or another team module.
development
implementation-construction
Writes new code following Code Complete 2 construction principles: consistent naming, single responsibility, type hints, docstrings, and minimal surface area. Use when implementing a designed component or function; follows design-consult output.
development
mojo-python-interop
Aids in writing Mojo code that interoperates with Python using current syntax and conventions. Use this skill in addition to mojo-syntax when writing Mojo code that interacts with Python, calls Python libraries from Mojo, or exposes Mojo types/functions to Python. Also use when the user wants to build Python extension modules in Mojo, wrap Mojo structs for Python consumption, or convert between Python and Mojo types.
tools
requirements
Captures, refines, and validates requirements; aligns with goals and constraints. Use when working in lifecycle area 2.x per SKILL_TREE.
development
plan
Breaks work into tasks, estimates, dependencies, branch strategy. Ensures implementation plans include feature-branch workflow and completion through PR with CI validation. Use when creating implementation plans, decomposing issues, or in plan mode.
testing
plan-branch-strategy
Creates the feature branch for planned work. Use at planning time before any code edits, or when the feature-branch hook blocks an edit on main.
development
requirements-constraints
Documents regulations, organisational rules, and technical limits that bound the solution. Use when compliance, legacy systems, or fixed budgets block certain designs.
documentation
requirements-context-scope
Defines the system boundary, external actors, and interfaces in scope versus out of scope. Use when integrations are unclear or scope creep threatens the milestone.
tools
requirements-validate
Reviews requirements for clarity, testability, and consistency before design commits. Use when requirements look ambiguous, contradictory, or untestable.
testing
test-coverage
Analyses coverage gaps and adds tests where risk is high. Use when coverage drops on a PR or critical paths lack assertions.
testing
maintenance-bug-report
Captures reproduction steps, expected versus actual behaviour, and environment for a defect. Use when filing or enriching an issue from user feedback or an incident.
testing
run-validation
Execute an implementation validation file step by step. For each step, run the command or check the UI, compare to the expected outcome, check off passing steps, and document failures. When a step fails, attempt to diagnose and fix the issue, then update the validation with corrected steps or expectations. Use after implementation to verify a feature is complete.
testing
integration-pr
Opens PR; links to issue; fills description template. Use after commit and push, before merge.
tools
maintenance
Bug reporting, cleanup after merge, and technical debt tracking. Use when hygiene, defects, or debt scheduling are the primary concern.
data-ai
test
Writes and runs tests; increases coverage per SKILL_TREE §9. Use when automating checks or interpreting test failures.
testing
systematic-debugging
Investigates root cause before proposing fixes. Use when facing bugs, test failures, CI failures, unexpected behavior, or performance regressions.
development
agent-guardrails
Guides implementation of AI agent guardrails: input/output validation, PII filtering, cost control, safety policies, and audit logging. Use when securing agent pipelines or adding compliance and observability.
testing
agent-visual-dev
Guides visual and GUI-based AI agent development with n8n, Flowise, and LangFlow. Covers low-code orchestration, when to use visual tools vs code, and on-premises self-hosting. Use when evaluating or building agents with visual workflow tools.
tools
integration-merge
Merges PR; resolves conflicts; squashes if needed. Use after PR approval, before branch cleanup.
tools
fair-data-principles
Guides application of FAIR data principles (Findable, Accessible, Interoperable, Reusable) when designing APIs, data models, and integration patterns. Use when designing APIs, data models, metadata schemas, or integration patterns where findability, accessibility, interoperability, or reusability are quality goals.
development
ai-agent-development
Guides implementation of AI agents: agent types, context/RAG, guardrails, swappable LLM providers, on-premises deployment, framework selection, and visual development. Use when designing, building, or reviewing AI agent systems in Python or C#.
development
agent-on-premises
Guides on-premises deployment of AI agents: local model serving, data sovereignty, air-gapped environments, GPU provisioning, and infrastructure patterns. Use when agents must run locally without sending data to cloud APIs.
development
agent-llm-providers
Guides implementation of swappable LLM provider interfaces for AI agents. Covers open-source (Ollama, LlamaCPP) and closed-source (OpenAI, Gemini) backends via abstract base classes and factory patterns. Use when designing configurable or multi-provider agent systems.
development
issue-workflow
Orchestrates issue lifecycle from idea to closed. Use when creating, refining, or validating a GitHub issue; triggers sub-skills (5.1–5.9) as needed. New issues assign the trigger user for explicit ownership and review.
testing
issue-coding
Orchestrates the TDD coding inner loop for a validated issue on a feature branch. Use when acceptance criteria exist, plan/branch are done, and implementation begins; runs validation-draft first, then construction, test-run, and quality-gate as exit.
testing
software-engineering-process
Orchestrates the full software lifecycle from ideation through operations and governance. Use when starting ambiguous work and you must pick the right phase skills in order, or when explaining how skills chain from issue to production.
development
architecture-deployment
Documents deployment topology: infrastructure, containers, and mapping of software to infra (arc42 §7). Use when describing how the system is deployed or updating deployment docs.
devops