fdiblen

@fdiblen source repo

67 skills
0 followers
6 hours ago last updated

▌
Rseng CI CD · fdiblen bundle
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.

0
installs
▌
Rseng Fair Ml · fdiblen bundle
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.)

0
installs
▌
Rseng Honesty · fdiblen bundle
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.

0
installs
▌
Rseng Testing · fdiblen bundle
Covers how to test research software: choosing test types and levels (unit, integration, system, regression, property-based, golden-master), test frameworks and coverage, TDD, validating analysis code against reference cases, and taming CI testing matrices across compilers, platforms and dependency versions. Use when the user asks how to write tests, set up pytest/testthat/JUnit, decide what to test, raise or interpret code coverage, do test-driven development, or when a CI matrix is exploding. Also use PROACTIVELY when new result-bearing code is written without tests, and before declaring any deliverable complete - the shipped entry point must be run and verified working, not only the test suite. For CI pipeline setup see rseng-ci-cd; for review-time test scrutiny see rseng-code-review.

0
installs
▌
Rseng Trainer · fdiblen bundle
Covers teaching research software skills while working: turning everyday coding moments into short, learner-centered lessons using Carpentries/CodeRefinery-style pedagogy (objective-led episodes, formative checks, error normalization), and routing learners to canonical training materials. Use when a teachable moment appears during a task (offer a one-line lesson, never lecture), when the user asks to learn a topic, requests an explanation or tutorial, wants training material recommendations, is preparing to teach others, or when a developed project should ship a build story (docs/BUILD-STORY.md) explaining its design, technology and process choices for new developers. For onboarding cohorts see rseng-contributor-onboarding.

0
installs
▌
Rseng Security · fdiblen bundle
Covers securing research software and its supply chain: secrets and sensitive-file hygiene (env files, keys, credentials and the never-commit file catalog) with leak response, dependency vulnerability scanning and pinning, OpenSSF Scorecard and Best Practices badge, SLSA provenance levels, SBOMs, signed releases and repository hardening. Use PROACTIVELY when setting up CI or releases, when an API key, password, credential or token is committed or appears in code or history, when the user asks how secure their project or dependencies are, or mentions Scorecard, SLSA, SBOM, CVEs or secret scanning. For the agent itself see rseng-agent-security; for GDPR and personal-data obligations see rseng-regulatory-compliance; for sensitive-data storage practice see rseng-data-management.

0
installs
▌
Rseng Archiving · fdiblen bundle
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.)

0
installs
▌
Rseng Debugging · fdiblen bundle
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.

0
installs
▌
Rseng Discovery · fdiblen bundle
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.)

0
installs
▌
Rseng Fairguard · fdiblen bundle
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.)

0
installs
▌
Rseng Licensing · fdiblen bundle
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.)

0
installs
▌
Rseng Notebooks · fdiblen bundle
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.

0
installs
▌
Rseng Workflows · fdiblen bundle
Covers building, choosing, discovering, describing, and sharing computational workflows with workflow management systems - when to move off ad-hoc scripts onto a WMS, how to make workflows FAIR, and where to find or register them. Use when the user asks how to automate a multi-step data pipeline, mentions Snakemake, Nextflow, CWL, WDL, Galaxy, Apache Airflow, Parsl, nf-core, or WorkflowHub, wants to pick a workflow engine, package a workflow with RO-Crate metadata, or make an analysis pipeline reproducible and reusable.

0
installs
▌
Rseng Provenance · fdiblen bundle
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.

0
installs
▌
Rseng Code Review · fdiblen bundle
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.

0
installs
▌
Rseng Legacy Code · fdiblen bundle
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.)

0
installs
▌
Rseng Code Quality · fdiblen bundle
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.

0
installs
▌
Rseng Storytelling · fdiblen bundle
Covers telling the story of research data, software and projects to broad audiences: narrative structure for data stories, turning milestones into human-centered stories, and citizen-science engagement - recruiting contributors, closing the feedback loop with data stories, honest narrative that never oversells. Use when the user wants to explain a project, dataset or tool to non-specialists, mentions storytelling, outreach, public engagement or citizen science, or needs project stories for websites, funders or volunteers. (Research-facing outputs - software papers, talks, announcements: rseng-science-communication; in-repo docs: rseng-documentation.)

0
installs
▌
Rseng User Support · fdiblen bundle
Covers running user support as an operation for research software: triaging and answering support requests, converting recurring questions into documentation and FAQ entries, office hours and support channels, forum gardening, and feeding support signals into the roadmap. Use when support questions arrive faster than they are answered, when the same question keeps being answered by hand, when the user asks how to organize support, office hours or a helpdesk for their software, or when support load is invisible to planning.

0
installs
▌
Rseng Documentation · fdiblen bundle
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.

0
installs
▌
Rseng Fact Checking · fdiblen bundle
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.)

0
installs
▌
Rseng Fair Software · fdiblen bundle
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.)

0
installs
▌
Rseng Gpu Computing · fdiblen bundle
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.

0
installs
▌
Rseng Hpc Computing · fdiblen bundle
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.)

0
installs
▌
Rseng Agent Security · fdiblen bundle
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.)

0
installs
▌
Rseng AI Declaration · fdiblen bundle
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.

0
installs
▌
Rseng Software Reuse · fdiblen bundle
Covers discovering and reusing existing research software instead of rebuilding it, using Research Software Directory (RSD) instances such as research-software-directory.org and helmholtz.software. Use PROACTIVELY when a research project is about to implement functionality that likely already exists - data readers, converters, solvers, analysis tools, domain libraries - and when the user asks whether a tool already exists, wants to find research software for a domain, or mentions the RSD. Ships bundled catalog snapshots (data/*.json) for offline candidate suggestions. (Broad prior-art surveys across publications and all sources: rseng-discovery; vetting a chosen candidate: rseng-dependency-management.)

0
installs
▌
Rseng Data Management · fdiblen bundle
Covers research data management around software: organizing and documenting datasets (layout, data dictionaries), keeping data out of git while versioning it properly (DVC, git-annex, DataLad), FAIR data and metadata standards, depositing data with DOIs in repositories such as Zenodo, licensing data, and handling sensitive or personal data. Use PROACTIVELY when a project reads or produces datasets, when the user asks where to put data, how to version or share large files, how to document a dataset, which data license or repository to use, or when data files are about to be committed to a code repository. (Format engineering - HDF5, NetCDF, Parquet, chunking - is rseng-scientific-file-formats; funder data management plans are rseng-data-management-plans.)

0
installs
▌
Rseng Green Computing · fdiblen bundle
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.)

0
installs
▌
Rseng Language Guides · fdiblen bundle
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.

0
installs
▌
Rseng Lessons Learned · fdiblen bundle
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.

0
installs
▌
Rseng Project Kickoff · fdiblen bundle
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.)

0
installs
▌
Rseng Reproducibility · fdiblen bundle
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.)

0
installs
▌
Rseng Software Design · fdiblen bundle
Covers designing research software: modularity and separation of concerns, interfaces and coupling, growing from script to package, the rule of three and the reuse ladder, architecture styles for research systems (pipeline, layered, plugin, services), quality-attribute trade-offs, visual design documentation (C4, Mermaid, PlantUML diagrams-as-code) and architecture decision records. Use when starting non-trivial research software, when a script has grown past easy understanding, when the user asks how to structure or architect code, wants an architecture, API or data-flow diagram, or mentions modularity, coupling, design patterns or refactoring toward structure. For file layout and style see rseng-code-quality; for restructuring inherited code see rseng-legacy-code.

0
installs
▌
Rseng Citation Hygiene · fdiblen bundle
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.)

0
installs
▌
Rseng Defensive Coding · fdiblen bundle
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.

0
installs
▌
Rseng Pair Programming · fdiblen bundle
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.

0
installs
▌
Rseng Project Tracking · fdiblen bundle
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.)

0
installs
▌
Rseng Software Metrics · fdiblen bundle
Covers measuring code health quantitatively: cyclomatic complexity, code duplication, coupling and cohesion, code churn, maintainability index, size conventions and documentation coverage - running radon, lizard, jscpd, interrogate and SonarQube-class tools, interpreting numbers against community conventions and the software's tier, wiring metric gates into CI, and avoiding metric gaming. Use when the user asks how healthy, complex or maintainable their code is, wants metrics or duplication measured, mentions cyclomatic complexity, churn, coupling or maintainability index, or when a quality assessment (rseng-quality-framework) needs the quantitative half. For style and linting see rseng-code-quality; for runtime performance measurement see rseng-performance-profiling.

0
installs
▌
Rseng UX Accessibility · fdiblen bundle
Covers user experience and accessibility for research software: UX disciplines, accessibility practice, Design Thinking, scoping a Minimum Viable Product versus a Minimum Loveable Product, Nielsen's usability heuristics, and prototyping with tools like Figma and Miro. Also covers WCAG conformance for web-facing tools, accessibility testing, CLI usability guidelines and inclusive defaults. Use PROACTIVELY when creating or reshaping a user-facing interface (CLI, GUI, web), and when the user designs a research tool's interface (web, GUI or CLI), asks how to make research software usable or accessible, plans user testing or prototyping, or mentions usability heuristics, WCAG, UX or a11y in a research software context.

0
installs
▌
Rseng Citation Metadata · fdiblen bundle
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.)

0
installs
▌
Rseng Community Metrics · fdiblen bundle
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.

0
installs
▌
Rseng Quality Framework · fdiblen bundle
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.

0
installs
▌
Rseng Human Verification · fdiblen bundle
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.

0
installs
▌
Rseng License Compliance · fdiblen bundle
Covers license compliance engineering: auditing the full dependency tree's licenses, compatibility analysis (permissive vs weak vs strong copyleft, GPL interactions, combining and linking), dual and multi-licensing, SPDX expressions and REUSE-compliant repositories, attribution and NOTICE obligations, and license policy in CI. Use when the user asks whether dependencies' licenses are compatible, wants a license audit, considers dual licensing or relicensing, must satisfy GPL/LGPL obligations, mentions SPDX, REUSE, NOTICE files or license scanners, or needs a license recommendation under real constraints. (License basics and first-time license choice: rseng-licensing.)

0
installs
▌
Rseng Numerical Accuracy · fdiblen bundle
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.

0
installs
▌
Rseng Research Integrity · fdiblen bundle
Covers integrity checks on research outputs before submission or release: statcheck/GRIM-style consistency of reported statistics, agreement between manuscript numbers and pipeline outputs, retraction screening of cited work, sanity checks on tables and figures against the data, and an auditable pre-submission checklist. Use PROACTIVELY before manuscript submission or release of result-bearing reports, when reported numbers are transcribed from analysis outputs, and when the user asks to check a paper's numbers, mentions statcheck, GRIM or integrity checks, or suspects a mismatch between code outputs and text. (Reference existence and retractions: rseng-citation-hygiene; claim-source support: rseng-fact-checking; concealment requests: rseng-honesty.)

0
installs
▌
Rseng Big Data Processing · fdiblen bundle
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.)

0
installs
▌
Rseng Management Planning · fdiblen bundle
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.)

0
installs
▌
Rseng Project Scaffolding · fdiblen bundle
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.

0
installs
▌
Rseng Software Publishing · fdiblen bundle
Covers publishing research software through its distribution channels: packaging for and releasing on package indexes (PyPI, conda-forge, CRAN and ecosystem equivalents), registering in research software registries, submitting to software journals (JOSS-style), and choosing the channel mix for a project's audience. Use when the user wants their software installable by others, asks how to publish on PyPI, CRAN or conda-forge, wants the software listed where researchers search, or when a mature project is only obtainable by cloning its repository. (Cutting versioned releases and DOIs: rseng-publishing-releasing; the JOSS review process: rseng-software-peer-review; preservation: rseng-archiving.)

0
installs
▌
Rseng Community Governance · fdiblen bundle
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.

0
installs
▌
Rseng Publishing Releasing · fdiblen bundle
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.)

0
installs
▌
Rseng Software Peer Review · fdiblen bundle
Covers community peer review of research software: preparing a package for JOSS, pyOpenSci or rOpenSci submission, self-checking against their review criteria before submitting, writing the paper or statement of need, responding to reviews, and acting as a reviewer or CODECHECK-style codechecker who executes the artifact. Use when the user mentions JOSS, pyOpenSci, rOpenSci or CODECHECK, wants to submit software for peer review or publication, asks whether their package is review-ready, or is reviewing someone else's research software for one of these venues. (PR-level code review is rseng-version-control-review; overall publication channel strategy is rseng-software-publishing.)

0
installs
▌
Rseng Data Management Plans · fdiblen bundle
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.)

0
installs
▌
Rseng Dependency Management · fdiblen bundle
Covers the full lifecycle of third-party dependencies: vetting a library before adoption on every axis that matters - suitability, license, trust and vulnerabilities including the transitive tree, documentation, maintenance and version currency - then keeping dependencies current with lockfiles and automated updates, and replacing them when they rot. Use PROACTIVELY whenever a new dependency is about to be added, when dependencies are outdated or unpinned, when the user asks whether a library is safe or well chosen, mentions dependabot/renovate, transitive dependencies or version pinning, or when an audit is due. (Finding candidates: rseng-software-reuse; deep license analysis: rseng-license-compliance; lockfile mechanics: rseng-reproducible-environments.)

0
installs
▌
Rseng Open Source Migration · fdiblen bundle
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.)

0
installs
▌
Rseng Performance Profiling · fdiblen bundle
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.

0
installs
▌
Rseng Regulatory Compliance · fdiblen bundle
Covers checking research code and data against data-protection and AI regulation: GDPR obligations in code (personal data discovery, minimization, pseudonymization vs anonymization, retention, data-subject rights, DPIA triggers), the EU AI Act (risk tiers, research carve-out, transparency duties), and similar regimes. Use PROACTIVELY when person-level or sensitive data is evident in the project, and when a project processes personal or sensitive data, trains or ships AI/ML systems, when the user asks about GDPR, the AI Act, DPIAs, consent or anonymization, or before publishing datasets or models derived from people. (Secrets hygiene and protective controls: rseng-security; sensitive-data stewardship: rseng-data-management; AI-use disclosure: rseng-ai-declaration.)

0
installs
▌
Rseng Science Communication · fdiblen bundle
Covers communicating research software outward to research audiences: supporting the user's software papers (JOSS/SoftwareX-style) with outlines, gathered material and structure - never writing a submission-ready manuscript - plus release announcements, lay summaries of what the software does, talk and poster outlines, blog posts, and making a package findable to its intended users. Use when the user wants to announce, present, promote or explain their research software, asks for help with a software paper, talk abstract or release post, or when a mature package has no visibility beyond its authors. In-repo docs live in rseng-documentation; public and citizen-science narrative in rseng-storytelling; venue mechanics and review preparation in rseng-software-peer-review.

0
installs
▌
Rseng Contributor Onboarding · fdiblen bundle
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.

0
installs
▌
Rseng Open Science Practices · fdiblen bundle
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.

0
installs
▌
Rseng Version Control Review · fdiblen bundle
Covers using version control effectively for research software and the PR-time review process: choosing a VCS, branching and commit practice, authorship and signatures in commit metadata (author/committer identity, Co-authored-by trailers, signed commits and tags, .mailmap), collaboration on GitHub/GitLab, and constructive checklist-driven pull-request reviews. Use when the user asks how to set up git, design a branching strategy, write commit messages, record who authored or co-authored a change, sign commits or tags, handle large binary files, open or review a pull/merge request, or wire linters and CI into review. (Audits of existing code and milestone reviews: rseng-code-review; pre-reviewing your own draft: rseng-pair-programming.)

0
installs
▌
Rseng Scientific File Formats · fdiblen bundle
Covers choosing and handling scientific data formats in code: HDF5 and NetCDF for array data, CF conventions and standard metadata, Parquet for tabular data, domain standards (NeXus and similar), self-describing files, chunking and compression choices, and migrating away from fragile formats like pickles and ad-hoc binaries. Use when the user chooses a file format for research data, reads or writes HDF5/NetCDF/Parquet/zarr-style stores, asks about chunking, compression or metadata embedding, or ships data in CSV, pickle, MAT or homegrown binary formats that deserve scrutiny. (The surrounding data practice - versioning, deposit, licensing, documentation - is rseng-data-management.)

0
installs
▌
Rseng Scientific Visualization · fdiblen bundle
Covers visualization of scientific data beyond publication figures: 3D and volumetric rendering with ParaView and VTK, scripted and reproducible visualization pipelines, state files and Python trace for repeatability, in-situ visualization of running simulations, web-delivered interactive 3D (trame-style apps), and choosing honest colormaps and representations for spatial data. Use when the user works with 3D, volumetric, mesh or simulation output data, mentions ParaView, VTK or interactive 3D viewers, needs a visualization others can regenerate, or wants to inspect large simulation results.

0
installs
▌
Rseng Reproducible Environments · fdiblen bundle
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.

0
installs
▌
Rseng Maintenance Sustainability · fdiblen bundle
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.)

0
installs

67 published skills