fdiblen
UserResearch Software Engineering skills for AI coding agents
Categories
Indexed Skills (46)
rseng-agent-security
Covers operating AI coding agents securely: auditing whether the agent runs sandboxed, permission and dangerous-command configuration, containerized environments, secrets kept out of context, network egress and token privileges, prompt-injection risk, and the privacy of agent use itself. Use PROACTIVELY when permission gating is broadly disabled (skip-permissions modes), when secrets are visible to the agent's shell, or when the agent processes untrusted code, issues or web content; when a project holds personal or confidential data while a cloud agent is active (what leaves the machine, retention, training use), or when the user asks how to run coding agents safely or privately. (Supply-chain security: rseng-security; disclosing agent contributions: rseng-ai-declaration.)
rseng-ai-declaration
Covers declaring AI involvement with the AI Declaration Format (https://ai-declaration.org): creating and maintaining an aidecl.yaml that records which AI tools and agents were used, what each contributed, when and how much, plus the README disclosure footnote, JSON/JSON-LD export and CI validation. Machine-readable disclosure is the practice; this format is one implementation. Use PROACTIVELY when an AI assistant or agent creates or modifies a project's content - generate aidecl.yaml if missing, update it after AI-assisted changes. Also use when the user asks about AI transparency, provenance, disclosure or EU AI Act disclosure, wants to state that NO AI was used, or mentions aidecl. For concealment requests see rseng-honesty; for the human review duty see rseng-human-verification.
rseng-archiving
Covers long-term archiving of research software and data: Software Heritage save requests and SWHID persistent identifiers, Zenodo deposits with versioned DOIs and forge integration, choosing domain and institutional repositories, deciding what to archive (code, data, environments, documentation) and when, and archiving at project retirement. Use when the user wants software or data preserved beyond the life of a forge account, grant or lab, mentions Software Heritage, SWHIDs, Zenodo deposits or archiving, retires or hands over a project, prepares artifacts that must stay resolvable for a paper, or when funder policy requires long-term preservation. (Cutting the release itself is rseng-publishing-releasing; day-to-day data storage and repository choice is rseng-data-management.)
rseng-big-data-processing
Covers processing research data that outgrows one machine's memory: out-of-core and chunked computation, Dask for scaling the scientific Python stack, Spark for distributed tabular pipelines, lazy evaluation, partitioning strategies, idempotent and restartable batch jobs, and knowing when NOT to distribute. Use when datasets no longer fit in memory, when the user mentions Dask, Spark, out-of-core or larger-than-memory data, when a pandas/NumPy workflow hits memory limits, or when designing batch pipelines over many files. (Cluster job submission and job arrays are rseng-hpc-computing; pipeline orchestration engines are rseng-workflows; profile first with rseng-performance-profiling.)
rseng-ci-cd
Covers continuous integration and delivery for research software: CI/CD concepts, automating builds and tests with GitHub Actions and GitLab CI/CD, and wiring an organization's GitLab CI infrastructure to a GitHub-hosted project. Use when the user asks to set up CI, write a pipeline or workflow file (.github/workflows, .gitlab-ci.yml), add automated builds/tests on push or pull request, publish a package or deploy docs when a tag or release is cut, cache dependencies to speed up CI runs, choose between GitHub Actions and GitLab CI, use self-hosted or GPU runners, mirror a repo, or report external CI status back to GitHub. For what to test and shrinking a test matrix see rseng-testing; for linter and pre-commit policy see rseng-code-quality.
rseng-citation-hygiene
Covers verifying that every citation is real, correct and current: checking references in manuscripts, READMEs, references files and code metadata against Crossref and OpenAlex, screening cited DOIs against the Retraction Watch database, catching fabricated or mis-attributed citations (a documented AI failure mode), and keeping bibliographies and CITATION.cff files resolvable. Use PROACTIVELY before any bibliography, reference list or citation metadata is finalized or published, whenever the agent itself has produced citations, and when the user asks to check references, mentions broken DOIs, retracted papers or citation verification, or prepares a manuscript, README or software paper with references. (Making your own software citable is rseng-citation-metadata.)
rseng-citation-metadata
Covers making research software citable and contributors credited: writing CITATION.cff, describing software with CodeMeta (codemeta.json), minting DOIs and ORCIDs, and tracking contributors of every kind. Use when the user asks how to make software citable, add CITATION.cff or codemeta.json, obtain a DOI, ensure contributors get credit, or mentions CFF, CodeMeta, ORCID, CRediT or persistent identifiers. Use PROACTIVELY when generated code draws on a publication, website or existing code (credit it at the code site and in the references), at release preparation, and when citation files are edited. (Verifying references you cite: rseng-citation-hygiene; versioning schemes and the DOI-minting release: rseng-publishing-releasing.)
rseng-code-quality
Covers writing readable research code and structuring software projects: naming, formatting, style guides, linters and formatters, pre-commit hooks, modular design, and a conventional directory layout with top-level metadata files. Use when the user asks how to make code readable or clean, pick or enforce a style guide, set up linting/formatting or pre-commit, name variables and functions, organise a repo, or decide where files and data go. For generating a new project from a maintained template see rseng-project-scaffolding; for quantitative complexity and duplication measurement see rseng-software-metrics; for architecture-level structure see rseng-software-design.
rseng-code-review
Covers reviewing existing code and whole projects, not just new diffs: structured codebase audits that produce ranked findings and then implement the agreed improvements, recurring project reviews after major tasks and milestones, review scoping by risk and tier, and turning review findings into tracked work and lessons. Use PROACTIVELY after major tasks and milestones, and when the user asks for a code review, codebase audit or health check of existing code, wants improvements suggested and applied, mentions reviewing the project after a milestone or before a release or submission, or when inherited or long-unreviewed code needs a structured pass. For diff-time pre-review of new work see rseng-pair-programming; for PR-time review process and rules see rseng-version-control-review.
rseng-community-governance
Covers building and governing a community around research software: CONTRIBUTING guides, codes of conduct, governance models and decision-making, contributor recognition policy, issue and discussion hygiene, and handing over or sharing maintainership. Use when a project wants external contributors, when the user asks for a CONTRIBUTING.md, code of conduct or governance document, when maintainer burnout or bus-factor risks come up, or when a project is moving from single-author to team or community ownership. The contributor funnel and good-first-issue curation live in rseng-contributor-onboarding; health measurement in rseng-community-metrics; support operations in rseng-user-support.
rseng-community-metrics
Covers measuring community health with CHAOSS-style metrics: contributor growth and retention, bus factor, first-response and review latency, the casual-to-regular contributor conversion funnel, and organizational diversity - computed from forge data, interpreted against project stage, and turned into community actions rather than vanity dashboards. Use when the user asks how healthy their community is, wants contributor or responsiveness statistics, mentions CHAOSS or community metrics, prepares a sustainability report or grant renewal needing community evidence, or when community trends (rising latency, shrinking contributor base) should be checked rather than felt.
rseng-contributor-onboarding
Covers turning users into contributors and contributors into regulars: curating genuinely good first issues, onboarding paths and checklists generated from the repository, first-PR shepherding, mentorship and buddy structures, and measuring where the contribution funnel leaks. Use when a project wants contributors but gets none, when first-time contributors do not return, when the user asks for good-first-issue curation, onboarding documentation or mentorship structure, or when a team member or student is joining a research software project.
rseng-data-management-plans
Covers data management plans (DMPs) for research projects: what funders require, drafting a DMP from the project's actual data reality (types, volumes, storage, sharing, preservation, responsibilities, costs), machine-actionable DMPs (RDA common standard, Data Stewardship Wizard, DMPonline funder templates), and keeping the plan synchronized with practice. Use when a proposal or project needs a DMP, when the user mentions data management plans, maDMPs, DS-Wizard or DMPonline, when funder or institutional data policy applies, or when the existing DMP has drifted from what the project actually does with its data. (Day-to-day data practice is rseng-data-management; the software management plan twin is rseng-management-planning.)
rseng-debugging
Covers systematic debugging of research software: hypothesis-driven diagnosis instead of guess-and-change, building minimal reproducers, bisecting across commits, data and parameters, debugging scientific failure modes (wrong numbers rather than crashes, nondeterminism, scale-dependent bugs), debugger and print-discipline mechanics, and turning every fix into a regression test. Use when the user reports a bug, a crash, wrong or changed results, a heisenbug or an it-works-on-my-machine discrepancy, when a pipeline fails at scale but not in tests, or when the user is stuck guessing instead of diagnosing. For preventing silent wrong-result bugs see rseng-defensive-coding; for judging whether numerical differences matter see rseng-numerical-accuracy.
rseng-defensive-coding
Covers defenses against silently wrong research results: validating data at boundaries (schemas, assertions, sanity checks), explicit physical units and quantities in code (pint/astropy-style), disciplined randomness (explicit seeded generators, parallel streams), and fail-loud handling of NaN and missing data. Use PROACTIVELY when code ingests external or instrument data, when values carry physical units, when randomness enters simulations or sampling, or when NaN or missing-data handling is implicit; also when the user mentions data validation, unit errors, seeds or silent bugs, or reviews analysis code whose failure would be invisible. For floating-point behavior and tolerances see rseng-numerical-accuracy; for diagnosing an existing bug see rseng-debugging.
rseng-discovery
Covers discovering the research landscape around a topic or project: finding relevant publications (OpenAlex, arXiv, Zenodo, JOSS, Semantic Scholar, Google Scholar) and finding related software - libraries, packages, tools, platforms and competitor or alternative projects - across software registries, archives, package indexes, public forges and curated awesome lists. Use when the user asks what exists on a topic, wants related work, prior art, alternatives or competitors surveyed, needs a state-of-the-field picture for a paper or proposal, or is about to build something whose neighbors are unknown. (RSD-based reuse suggestions with bundled snapshots are rseng-software-reuse; adoption vetting is rseng-dependency-management; verifying found references is rseng-citation-hygiene.)
rseng-documentation
Covers how to document research software at every level: writing a README, code-level docs (comments, docstrings, API and CLI help), project docs (INSTALL, CONTRIBUTING, LICENSE, CITATION, changelog), publishing hosted documentation with Read the Docs, and capturing a Research Software Story. Use when the user asks how to write or improve a README, decide what documentation their project needs, add docstrings or inline comments, document an API or CLI, set up Sphinx/MkDocs/Doxygen, host docs on Read the Docs, structure a docs site, or write the narrative context and history behind a project. For outward-facing papers, talks and announcements see rseng-science-communication; for public and citizen-science narrative see rseng-storytelling.
rseng-fact-checking
Covers verifying facts and sources at the content level: checking that a cited source actually contains and supports the claim it is cited for (claim-source alignment), assessing source trustworthiness (peer-review status, venue reputation, predatory-publishing signals, primary vs secondary), and flagging fabricated or misattributed support. Use PROACTIVELY whenever the agent itself asserts checkable facts or attaches sources to claims, and when the user asks to fact-check a document, verify that references support their claims, or assess whether a source is trustworthy. (rseng-citation-hygiene verifies references exist and are unretracted; rseng-research-integrity checks a document's own numbers.)
rseng-fair-ml
Covers applying FAIR principles to machine learning artifacts: making models findable and reusable with model cards and rich repository metadata, documenting datasets with Croissant and datasheet-style records, licensing models and weights, linking the model-data-code-paper cluster with persistent identifiers, and the RDA FAIR4ML metadata direction. Use when a project trains, fine-tunes, publishes or reuses ML models or ML-ready datasets, when the user mentions model cards, Croissant, datasheets, FAIR4ML or model licensing, when a model heads to a hub or archive, or when evaluating whether a third-party model is documented well enough to build on. (General software FAIR is rseng-fair-software; automated repository scoring is rseng-fairguard.)
rseng-fair-software
Covers how to apply the FAIR principles - findable, accessible, interoperable, reusable - to research software, and how to assess a project's FAIRness. Use when the user asks how to make software FAIR, wants help with findability, discoverability, or software reuse, mentions metadata, persistent identifiers, DOIs, registries, or software citation in a FAIR context, or asks to run a FAIR self-assessment or checklist on a repository. (Automated FAIR4RS scoring, compliance levels and CI gates with the FAIRGuard tool are rseng-fairguard; FAIR for ML models and datasets is rseng-fair-ml; finding existing software to reuse is rseng-software-reuse.)
rseng-fairguard
Covers assessing research software against the 17 FAIR4RS principles with FAIRGuard (https://www.fairguard.org): compliance scores and levels (bronze to platinum), assessment profiles, quality gates for CI, .fairguard.yml configuration, per-indicator skips, and acting on findings. Use PROACTIVELY on research software projects - at repo intake, before releases, after adding publication metadata - and act on its findings. Also use when the user asks to check FAIR compliance, wants a FAIR score, report or badge level, wants a FAIR quality gate in CI, or mentions fairguard, FAIR4RS or .fairguard.yml. (FAIR concepts, principles and hand-guided improvement are rseng-fair-software; ML artifacts are rseng-fair-ml.)
rseng-gpu-computing
Covers GPU and accelerator programming for research software: choosing a programming model (CUDA, HIP, SYCL, OpenACC, OpenMP offloading), GPU libraries, language bindings such as CuPy, PyCUDA and CUDA.jl, portability layers like Kokkos and Raja, source-to-source translation, kernel profiling and auto-tuning. Use when the user wants to port research code to GPUs, pick between CUDA and portable alternatives, call GPU code from Python or Julia, tune or profile kernels, or mentions HIP, SYCL, OpenACC, Kokkos or Kernel Tuner.
rseng-green-computing
Covers the environmental footprint of research computing: measuring and reporting energy use and carbon emissions of computations (CodeCarbon), reducing them through efficient code, right-sized hardware and carbon-aware scheduling (CATS), the GREENER principles and the Software Carbon Intensity metric. Use when the user asks about the carbon or energy cost of their computations, wants to make workloads greener, mentions sustainability of computing, CodeCarbon, CATS or the Software Carbon Intensity metric. Use PROACTIVELY when planning large training runs, simulations or parameter sweeps - footprint measurement is worthless retrospectively. (Keeping the software project itself alive is rseng-maintenance-sustainability; making code faster is rseng-performance-profiling.)
rseng-honesty
Covers responding when concealment or misrepresentation is requested: hiding AI usage, making work appear different from reality, backdating or disguising provenance, inflating results or removing traces of how something was made. The skill calls for honesty with concrete reasons and offers honest alternatives that usually satisfy the underlying need. Use PROACTIVELY whenever a request aims to make records, history, authorship or results tell a story different from what happened - including hiding AI assistance, "make it look like", disguising generated content as manual work, or presenting untested claims as verified. Disclosure mechanics live in rseng-ai-declaration; the verify-before-trust duty in rseng-human-verification; checking others' outputs in rseng-research-integrity.
rseng-hpc-computing
Covers working effectively on high-performance computing clusters: writing and debugging SLURM job scripts, choosing and requesting resources honestly, running containers with Apptainer, using module systems and EESSI software stacks, MPI basics, checkpointing, and scaling from laptop to cluster reproducibly. Use when the user mentions a cluster, supercomputer, SLURM, sbatch, MPI, Apptainer or Singularity, module load, job arrays or walltime, or when a compute workload has outgrown a single machine. (Larger-than-memory data processing with Dask or Spark is rseng-big-data-processing; measuring scaling before requesting allocations is rseng-performance-profiling.)
rseng-human-verification
Covers the human's side of AI-assisted research software: strongly urging the user to review generated code and verify results before relying on them, teaching how to review AI-written code effectively (where to look first, what to run, what to spot-check against known answers), and recording review status honestly. Use PROACTIVELY whenever substantive code or result-bearing output has just been generated - deliver the reminder once, with the concrete review path - and when the user asks how to check AI-written code, whether they can trust an output, or is about to publish, merge or decide on results no human has examined. Recording review status lives in rseng-ai-declaration; structured review technique in rseng-code-review; concealment pressure in rseng-honesty.
rseng-language-guides
Covers language-specific research software practice: per-language conventions for Python, R, JavaScript/TypeScript, C/C++, Fortran, Rust and Bash - setup, development environments, style standards, packaging, testing, quality assurance, optimization, logging, documentation and dependency management. Use when the user asks which tools or conventions to use FOR A SPECIFIC LANGUAGE in research software (e.g. Python packaging, R style, C++ QA, Fortran tooling, Rust starting points, shell scripting practice), or wants a language-by-language comparison.
rseng-legacy-code
Covers working safely with inherited research code: characterization tests before any change, incremental modernization of untested scripts, recovering intent from code without documentation, and deciding between refactor, rewrite and retire. Use PROACTIVELY when asked to change code that has no tests, and when the user inherits a codebase from a departed researcher, mentions legacy or untested code they are afraid to touch, or wants to change code that has no tests. (Migrating off commercial platforms like MATLAB, IDL or SAS to open alternatives is rseng-open-source-migration; this skill supplies the characterization-test safety net it builds on.)
rseng-lessons-learned
Covers capturing and reusing what a project learns: a lessons-learned record fed from debugging sessions, code review findings, failed and successful research approaches, incidents and near-misses; blameless postmortems for the big ones; retrospectives on a cadence; and routing each lesson into the artifact that prevents its repetition (test, doc, checklist, onboarding note). Use PROACTIVELY when a nontrivial bug is fixed, a review uncovers a recurring pattern, an approach is abandoned, or an incident is resolved - and when the user asks to record a lesson, run a retrospective or postmortem, wants a LESSONS or NOTES file, or asks why the same mistake keeps happening.
rseng-licensing
Covers how to license research software: copyright and public-domain basics, choosing between permissive, copyleft, and Creative Commons licenses, basic compatibility with dependency licenses, and adding a LICENSE file or per-file SPDX/REUSE metadata. Use when the user asks which open source license to pick, how to add a LICENSE file, what MIT vs GPL vs Apache means, whether two licenses are compatible, how to license documentation or data alongside code, or mentions REUSE, SPDX, CC0, or public domain. Also use PROACTIVELY when a repository has no LICENSE file - an unlicensed repository legally blocks all reuse. (Full dependency-tree audits, SPDX expressions, dual licensing and CI license enforcement are rseng-license-compliance.)
rseng-maintenance-sustainability
Covers keeping research software alive and responsible over time: ongoing maintenance practice, tracking and paying down technical debt, reducing the bus factor, and deprecating or archiving honestly. Use when the user asks how to maintain or sustain a project, stop it rotting, schedule CI to catch breakage from external change, track or pay down tech debt, plan maintenance funding or shared ownership, or retire or deprecate software. (Energy and carbon footprint of computing is rseng-green-computing; dependency updating and auditing detail is rseng-dependency-management; archiving mechanics are rseng-archiving.)
rseng-management-planning
Covers planning research software work: writing and maintaining a Software Management Plan (SMP), and choosing programming languages, tools, and infrastructures for a project. Use when the user wants to write or review an SMP, plan how software will be developed, maintained, shared, and preserved, needs the software sections of a proposal or funder template, wants to decide which language or framework to start a project in (Python, C++, R, Julia, Rust, Fortran, JavaScript), pick a project template or boilerplate, or weigh reuse, sustainability, and funder requirements at the start of a project. (Data management plans, maDMPs, DS-Wizard and DMPonline are rseng-data-management-plans; interactive new-project setup is rseng-project-kickoff; week-to-week task tracking is rseng-project-tracking.)
rseng-notebooks
Covers engineering discipline for computational notebooks: execution-order and hidden-state pitfalls, restart-and-run-all hygiene, keeping notebooks in version control with jupytext, testing notebooks with nbval-style execution checks, parameterizing and batch-running them with papermill, refactoring mature notebook code into importable modules, and deciding what belongs in a notebook versus a package. Use PROACTIVELY when a project contains .ipynb files, when the user works in Jupyter or similar notebooks, mentions notebook reproducibility, testing, version control or parameterization, when a notebook has grown into the de-facto pipeline, or when notebook results must become citable, reviewable artifacts.
rseng-numerical-accuracy
Covers floating-point correctness in research code: why 0.1 + 0.2 != 0.3, choosing absolute vs relative tolerances in tests, accumulation error and safe summation, precision choices (float32 vs float64), catastrophic cancellation, NaN and infinity handling, and cross-platform or cross-library result drift. Use PROACTIVELY when floating-point comparisons fail mysteriously, when writing numerical tests or choosing tolerances, when results differ across machines, compilers, BLAS builds or library versions, or when precision or numerical stability questions arise in analysis or simulation code.
rseng-open-science-practices
Covers the researcher-facing open science workflow: setting up OSF projects that link materials, data, code and registrations, preregistering studies and analysis plans, depositing preprints and linking them to published versions, participating in open peer review, and choosing openness levels honestly. Use when the user mentions open science, OSF, preregistration, registered reports or preprints, wants their research process (not just the software) open, asks where to preregister or preprint, or when a project's openness claims should become verifiable practice.
rseng-open-source-migration
Covers migrating research code from commercial, license-bound platforms to open source alternatives: MATLAB to Octave or Python/NumPy, IDL to Python, SAS/SPSS/Stata to R or pandas, Mathematica to SymPy/Julia, and the platform-specific pitfalls (indexing, copy semantics, toolbox equivalents, numerical parity). Use when the user wants to leave MATLAB, IDL, SAS, SPSS, Stata, Mathematica, LabVIEW or another proprietary platform, asks for an open or free alternative to commercial scientific software, can no longer afford or access a license, or needs collaborators without licenses to run the code. (The characterization-test safety net and general inherited-code discipline are rseng-legacy-code.)
rseng-pair-programming
Covers the agent as an effective pair programmer and pull-request review buddy for research software: driver-navigator collaboration with think-aloud reasoning, ping-pong test-driven pairing, keeping the human in charge of scientific decisions, pre-review of pull requests before human reviewers see them, and constructive review-comment craft. Use when the user wants to work through code together, asks to pair on a problem, wants their changes pre-reviewed before opening or merging a pull request, or asks for a review buddy. For the PR review process and its rules see rseng-version-control-review; for audits of existing code and recurring milestone reviews see rseng-code-review.
rseng-performance-profiling
Covers making research code faster with evidence: profiling before optimizing (py-spy and language-native profilers), interpreting hotspots, choosing optimizations by measured payoff, benchmark regression tracking with airspeed velocity (asv), and scaling measurements. Use when the user says their code is slow, asks to optimize or speed something up, wants benchmarks or performance regression tests, or before recommending rewrites, parallelism or GPUs on performance grounds.
rseng-project-kickoff
Covers starting a new research software project with a short kickoff interview: asking the user the few questions whose answers actually change decisions (goal, software tier, stack, data sensitivity, openness, collaboration, compute, deadlines, and how much the agent may decide alone), then deriving tier-appropriate defaults, setting the project up, and making proactive decisions afterwards while keeping the user informed. Use PROACTIVELY when a new project is starting in an empty or fresh directory, and when the user asks to kick off, bootstrap or set up a new research software project or wants the agent to interview them about it. (Drafting SMPs is rseng-management-planning; steady-state operation after setup is rseng-project-tracking.)
rseng-project-scaffolding
Covers starting research software projects from maintained templates and keeping them in sync: choosing a generator (Copier, cookiecutter), scaffolding a Python package, retrofitting template structure, pulling template upgrades into generated projects, and picking a pyproject build backend. Use when the user starts a new research software codebase, asks for a template or boilerplate, wants a src/ layout or pyproject.toml scaffold, mentions copier or cookiecutter, or chooses between setuptools, hatchling, poetry or PDM. For hand-rolled layout see rseng-code-quality; for the management side see rseng-project-kickoff.
rseng-project-tracking
Covers the operational side of running a research software project: turning plans into tracked, prioritized tasks (issues, milestones, boards), planning cadence around research deadlines, ranged estimates and timeboxed spikes for uncertain work, and disciplined bookkeeping - decision logs, status records, meeting notes and two-altitude project logs. Use when work is untracked or lives in heads and inboxes, when the user asks how to organize tasks, backlogs, milestones or boards, wants a status report or decision log, mentions issue triage or prioritization, or when a project has more than one person or month of work. (Strategic planning and SMPs: rseng-management-planning; new-project setup: rseng-project-kickoff; retrospectives: rseng-lessons-learned.)
rseng-provenance
Covers capturing and packaging the provenance of software and data: which inputs, code versions, parameters, environments and agents produced each result, recorded run by run; the W3C PROV model for describing it, RO-Crate for packaging research objects with their provenance, embedding provenance in file metadata, and data-flow lineage across pipelines. Use when the user asks where a result came from or whether it can be traced, wants provenance capture, lineage or an RO-Crate, or mentions PROV, research objects or audit trails; use PROACTIVELY when a pipeline produces results whose origins must be reconstructable long after the run.
rseng-publishing-releasing
Covers the release lifecycle of research software: preparing and cutting versioned releases with changelogs, versioning schemes, release automation and minting a DOI per release. Use when the user asks how to tag a v1.0.0 release, write release notes or a changelog, pick a versioning scheme (SemVer or CalVer), automate releases, or mint a release DOI. (Channel craft for PyPI/CRAN/conda and registries is rseng-software-publishing; long-term preservation is rseng-archiving.)
rseng-quality-framework
The entry point and router for this pack: explains the research software quality framework - community-standard quality dimensions, measurable indicators and the three-tier model (analysis code, prototype tools, infrastructure) - and routes to the right companion rseng-* skill. Use PROACTIVELY at the start of any research software task to classify the software's tier and select which practices apply, and whenever the user asks what research software quality means, mentions quality dimensions, indicators or the three-tier model, wants a quality assessment or improvement plan for research software, or is unsure which quality practice to start with.
rseng-reproducibility
Covers end-to-end computational reproducibility: making a project's results regenerable with one command, determinism and seed discipline, research compendium structure, replication packages for papers, Binder-launchable repositories, artifact evaluation and reproducibility badges. Use PROACTIVELY when the user wants results others can reproduce, prepares a replication package or artifact submission, mentions reproducibility, research compendia, Binder or badges, asks why results differ between runs or machines, or is about to publish results whose regeneration path is untested. (Pinning environments: rseng-reproducible-environments; pipeline automation: rseng-workflows; run-level lineage: rseng-provenance.)
rseng-reproducible-environments
Covers making research software environments reproducible: pinning a language version and its dependencies in a per-project virtual environment, choosing a package/environment manager, and packaging code and its full stack into a container. Use when the user asks how to set up venv/conda/poetry/uv/renv, lock or pin dependencies, share a runnable environment, escape "dependency hell" or "works on my machine", write a Dockerfile, build an Apptainer/Singularity image for HPC, or decide between a virtual environment and a container. For regenerating a project's results end to end see rseng-reproducibility; for environments of multi-step pipelines see rseng-workflows.
Bio shown is the top-scored skill's repo description as a fallback — real GitHub bios land in a future update.