dotfiles

Expert knowledge of FoBiS.py (Fortran Building System for poor men) — an automatic Fortran build tool that resolves module dependency hierarchies without manual makefiles. Use this skill whenever the user asks about: writing or editing a fobos file; running any fobis subcommand (build, clean, fetch, install, rule, doctests, scaffold, check, test, coverage, tree, introspect, run, cache, commit); Fortran project build configuration; diagnosing FoBiS build errors; adding GitHub dependencies to a Fortran project; the --json output flag; multi-mode builds; templates; variables and varsets; library builds (static/shared); MPI/OpenMP/coarray/OpenMP-offload builds; feature flags and conditional compilation; build profiles; the build cache; external-library auto-detection and pkg-config (.pc) generation; multi-target builds; convention-based source auto-discovery; the lock file and semver dependency constraints; the first-class test runner and coverage reports; LLM-assisted commit messages; the cflags-heritage feature

Consult Stefano's compiled OKF knowledge bundles at ~/llm-wiki (the "second brain"). TRIGGER whenever a question falls in an existing bundle's domain — currently div-free-amr; numerical divergence constraints (∇·B=0, incompressibility), constrained transport and flux-CT, projection/divergence-cleaning, eight-wave, staggered vs collocated grids, discrete divergence/curl operators, SBP, mimetic/compatible/structure-preserving discretizations, DEC, block-structured AMR refinement interfaces, prolongation/restriction commutation. Also trigger on explicit mentions: "llm-wiki", "second brain", "check the wiki", "what does the wiki say". Use for CONSULTATION from any directory; ingestion/compilation work happens in ~/llm-wiki under its own CLAUDE.md.

Write and review technical developer blog posts as version-controlled markdown. Use this skill when the user wants to draft, write, or review a blog post / dev write-up / release note / tutorial about their code — typically HPC, Fortran, Python, or scientific-computing work. Orchestrates a draft pass and two verification agents: blog-code-checker (verifies every code block, command, and API claim against the real repos under ~/fortran and ~/python) and blog-prose-reviewer (strips AI tells and enforces technical voice). Output is a single markdown file under ./posts/ with minimal YAML frontmatter. Trigger on "/blog", "write a blog post", "draft a post about <repo/feature>", or "review this post". Do NOT trigger for academic manuscripts — use scientific-writing for those.

Operator workflow for post-processing a RAW shoot in darktable with Claude as the operator. Use when the user wants to develop/process/batch their RAW photos (NEF/CR2/ARW), cull a shoot, apply a consistent look across a series, control edit values (exposure etc.) from the prompt, or run darktable-cli batches. Drives the four-stage pipeline (ingest/diagnose -> cull -> look -> export) and the edit-and-look QA loop. References the darktable-raw skill for module specifics. Architecture: the user builds a base LOOK once in the GUI; Claude captures it as a reference XMP and then controls precise per-module values from the prompt by patching the XMP (dt-xmp-patch.py), applying it headlessly via darktable-cli's positional-xmp arg.

Knowledge base from the darktable 4.6 user manual. Use when developing RAW photos (NEF/CR2/etc.) in darktable, driving darktable-cli for headless/batch export, reasoning about the scene-referred pixelpipe, modules (exposure, filmic rgb, color calibration, highlight reconstruction, tone equalizer), masking/blending, styles & XMP sidecars, or color management. Version-matched to darktable 4.6.

Convert files and office documents to Markdown. Supports PDF, DOCX, PPTX, XLSX, images (with OCR), audio (with transcription), HTML, CSV, JSON, XML, ZIP, YouTube URLs, EPubs and more.

Generate or edit images using AI models (FLUX, Nano Banana 2). Use for general-purpose image generation including photos, illustrations, artwork, visual assets, concept art, and any image that is not a technical diagram or schematic. For flowcharts, circuits, pathways, and technical diagrams, use the scientific-schematics skill instead.

Router and disambiguation map for the HPC skill fleet — decides WHICH high-performance-computing skill to consult when a query plausibly matches several. Use ONLY for cross-cutting routing/navigation: when the user asks which HPC skill covers a topic, says 'what HPC skills do I have', wants the map/relationships between them, or poses a parallel/numerical/HPC question that genuinely spans the reference-vs-applied-vs-theory boundary and the right skill is ambiguous (e.g. 'CG solver not converging' = theory vs PETSc API; 'optimize my CUDA kernel' = design playbook vs CUDA reference; an MPI question that could be the standard vs the C++/Python practical layer). SKIP this skill when the query already names one technology unambiguously — a pure MPI-semantics question goes straight to mpi-5.0, a C++23-standard question to iso-cpp-2023, a Numba-CUDA-Python question to python-hpc — those route directly without this router. This is a thin navigation layer over twelve HPC skills, not a knowledge base itself.

Practitioner knowledge base for high-performance computing in C++ — the full toolchain, language idioms, parallel programming models, and HPC ecosystem. Use when building or optimizing C++ HPC software: the toolchain (Linux/cluster, git, CMake/Spack, compiler flags, SLURM); modern C++ for performance (RAII, smart pointers, move semantics, auto, constexpr, const-correctness, the STL containers/algorithms/iterators); shared-memory parallelism (parallel-STL execution policies, std::thread/atomic, OpenMP fork-join/clauses/tasks/offload); distributed-memory MPI (point-to-point, collectives, derived datatypes, communicators, RMA, scaling, halo exchange, and MPL the modern header-only type-safe C++ MPI binding); GPU programming (CUDA thread hierarchy, coalescing, shared-memory tiling, occupancy); performance portability with Kokkos (Views, execution/memory spaces, layouts, parallel_for/reduce); HPC hardware (memory hierarchy, cache, SIMD, NUMA, roofline, accelerators); parallel I/O (HDF5, NetCDF, VTK, MPI-IO); debug

Practitioner knowledge base for the practical workflow tooling of HPC clusters — the command-line skills around writing, building, debugging, profiling, and running scientific code at scale. Use when working on a cluster or HPC project's toolchain: Unix shell for HPC (pipes, grep/sed/awk, ssh/rsync, tmux, environment modules); build automation with Make (targets, rules, automatic variables, pattern rules, parallel make); the CMake build system (out-of-source builds, find_package, target-based commands, build types); git version control with HPC discipline (gitignore, LFS, reproducibility tagging); debugging with GDB (breakpoints, watchpoints, backtrace, core dumps); memory and parallel debugging (Valgrind, AddressSanitizer/ThreadSanitizer, MPI debugging, DDT/TotalView); profiling and benchmarking (gprof, perf, PAPI hardware counters, TAU parallel profiling/tracing); and SLURM batch job management (sbatch/squeue/scancel, #SBATCH directives, job arrays, dependencies, login vs compute nodes). Covers the cluster

Practitioner knowledge base for the numerical and algorithmic theory of high-performance scientific computing — the science beneath the parallel-programming mechanics. Use when reasoning about numerical correctness, algorithm design, or performance modeling: floating-point arithmetic and round-off error (machine epsilon, catastrophic cancellation, non-associativity, Kahan summation); conditioning vs stability (condition number, backward stability); ODE/PDE discretization (finite differences, stencils, explicit vs implicit Euler, stiffness, CFL condition, method of lines); numerical linear algebra (LU factorization, pivoting, sparse matrices, fill-in, reordering); iterative and Krylov solvers (Jacobi/Gauss-Seidel, CG, GMRES, preconditioning, multigrid); performance programming (the memory wall, cache blocking/tiling, the roofline model, arithmetic intensity); high-performance linear algebra (BLAS levels, gemm, block algorithms); combinatorial algorithms (parallel sorting networks, graph algorithms as sparse li

Practitioner knowledge base for performance engineering in Python across CPU and GPU. Use when profiling or optimizing Python performance: finding bottlenecks (cProfile, line_profiler, memory_profiler, Scalene, py-spy); choosing data structures and cutting RAM (list/dict/set complexity, __slots__, Bloom/trie); vectorizing with NumPy/NumExpr and lazy generators; compiling hot loops (Numba @njit, Cython, PyPy, the GIL, nogil/prange); concurrency (asyncio for I/O, multiprocessing/Joblib for CPU, Dask clusters, mpi4py for distributed-memory MPI); fast DataFrames (Pandas vectorization, Polars lazy/query-optimizer, Dask); writing CUDA kernels in Python (Numba-CUDA: cuda.grid, atomics, syncthreads, device functions); GPU kernel optimization (occupancy, coalescing, shared-memory tiling, bank conflicts, warp divergence); CUDA streams and multi-GPU (Dask-CUDA, JAX pmap); GPU array/DataFrame libraries (CuPy, RAPIDS cuDF/cuML); JAX (jit/grad/vmap/pmap, XLA, autodiff); GPU profiling/debugging (Nsight Systems/Compute, nvtx

Practitioner knowledge base for parallel, multithreaded, and GPU programming — the design methodology, performance laws, and cross-technology optimization playbook. Use when designing or optimizing parallel software: choosing a parallel decomposition (PCAM, geometric/pipeline/master-worker patterns); reasoning about speedup and scalability (Amdahl, Gustafson, roofline, arithmetic intensity); writing shared-memory code (C++ threads, mutexes, atomics, memory_order, condition variables, lock-free/CAS, false sharing, deadlock); distributed-memory message passing (MPI, domain decomposition, halo exchange, collectives); GPU programming (CUDA/OpenCL thread hierarchy, warps, coalescing, shared-memory tiling, occupancy, host-device transfer); directive-based parallelism (OpenMP fork-join, data-sharing clauses, reductions); OpenMP GPU offload in depth (target/teams/distribute, the map clause and target-data regions, declare target, unified shared memory, async multi-device offload, the Eightfold Path to performance); h

Authoritative knowledge base from the ISO/IEC 9899:2024 C standard (C23, working draft N3220). CONSULT THIS BEFORE ANSWERING — do not answer C-standard questions from memory; the standard's exact rules, constraints, undefined-behavior catalogue (Annex J), and C23 version deltas are easy to misremember. TRIGGER whenever a question concerns: what the C standard requires/permits/forbids; whether code is standard-conforming or has undefined/unspecified/implementation-defined behavior; any C23 feature (_BitInt, constexpr, typeof, auto type inference, nullptr, enum with fixed underlying type, [[attributes]], #embed, __VA_OPT__, _Generic, <stdbit.h>, <stdckdint.h>, decimal floats); integer promotion / usual arithmetic conversions / conversion rank; the C memory model (atomics, memory_order, data races); the floating-point model (Annex F / IEC 60559, <fenv.h>, fma, rounding); sequence points and evaluation order; the preprocessor; the standard library headers; or bounds-checking (Annex K _s functions). SKIP only for

Knowledge base from the "CUDA Programming Guide" (NVIDIA, Release 13.3). Use when writing/reading/debugging CUDA C++ or CUDA Python, applying CUDA frameworks for kernels, SIMT/tile programming, streams & graphs, unified memory, cooperative groups, async copies/TMA, multi-GPU, or referencing CUDA APIs, specifiers, intrinsics, and compute-capability specs.

Authoritative knowledge base from the ISO/IEC 1539-1:2023 Fortran standard (J3/23-007r1). CONSULT THIS BEFORE ANSWERING — do not answer Fortran-standard questions from memory; the standard's exact rules, constraints (Cxxx), and version deltas are easy to misremember. TRIGGER whenever a question concerns: what the Fortran standard requires/permits/forbids; whether code is standard-conforming; any modern-Fortran feature (conditional expressions, SIMPLE/PURE/ELEMENTAL, enum/enumeration types, TYPEOF/CLASSOF, DO CONCURRENT incl. REDUCE locality, coarrays/teams, C interoperability, IEEE arithmetic); a syntax rule (Rxxx) or constraint (Cxxx); a difference between Fortran versions (F2023/F2018/F2008/F2003/F95/F90); or whether a feature is deleted/obsolescent. SKIP only for pure build/tooling questions (use the fobis skill) or when the user explicitly wants compiler-specific (gfortran/nvfortran/ifx) behavior rather than the standard.

Authoritative knowledge base from the MPI: A Message-Passing Interface Standard, Version 5.0. CONSULT THIS BEFORE ANSWERING — do not answer MPI questions from memory; send-mode/completion semantics, collective and RMA synchronization rules, datatype matching, thread levels, and routine signatures are subtle, deadlock-prone, and version-sensitive. TRIGGER whenever a question concerns: writing/reading/debugging MPI code (any MPI_* / mpi_f08 routine); message passing, distributed-memory parallelism, or multi-node HPC communication; point-to-point (send/recv modes, nonblocking, partitioned); collectives (bcast/reduce/allreduce/alltoall/scan, nonblocking, neighborhood); derived datatypes; communicators/groups/topologies/Sessions; one-sided RMA (windows/put/get/accumulate, fence/lock); MPI-IO (file views, collective I/O); process init (MPI_Init/Init_thread/Sessions/spawn); thread support levels; the standard ABI; error handling; the omp+MPI or GPU+MPI hybrid model; or diagnosing deadlocks, buffer-reuse bugs, or MPI

Authoritative knowledge base from the OpenACC Application Programming Interface v3.4 specification. CONSULT THIS BEFORE ANSWERING — do not answer OpenACC questions from memory; directive/clause semantics, data-clause behavior, and async-queue ordering rules are easy to misremember and version-sensitive. TRIGGER whenever a question concerns: writing/reading/debugging any OpenACC directive (#pragma acc / !$acc); offloading C/C++/Fortran to GPU or multicore; gang/worker/vector parallelism or execution modes; data clauses (copy/copyin/copyout/create/present/no_create/deviceptr/attach) or data-region/reference-counter behavior; loop/collapse/tile/reduction/private mapping; async/wait queues; the routine directive; atomic/declare/update directives; the acc_* runtime API; environment variables (ACC_*); or diagnosing GPU offload, data-movement, or benchmark-timing problems. SKIP only when the user explicitly wants OpenMP-offload, CUDA, or a vendor-compiler-specific (nvhpc/gcc) behavior rather than the OpenACC standar

Authoritative knowledge base from the OpenMP API v6.0 specification (Nov 2024) + the Nov-2025 errata (corrections applied inline). CONSULT THIS BEFORE ANSWERING — do not answer OpenMP questions from memory; directive/clause semantics, data-sharing vs data-mapping rules, the flush memory model, schedule/tasking/offload behavior, and the runtime API are subtle and version-sensitive. TRIGGER whenever a question concerns: writing/reading/debugging any OpenMP directive (#pragma omp / !$omp); multithreading or GPU/device offload in C/C++/Fortran via OpenMP; data-sharing clauses (shared/private/firstprivate/lastprivate/reduction) or data-mapping (map/target); parallel/teams/simd/masked, worksharing (for/sections/single/distribute/schedule), tasking (task/taskloop/taskgraph/depend), synchronization (barrier/critical/atomic/ordered/flush), the device model (target/declare target), memory allocators/spaces, variant directives (metadirective/declare variant), the omp_* runtime API, OMP_* environment variables/ICVs, OMPT