القائمة
Expert knowledge for GNU Guix package and service development. Use when creating or modifying Guix packages, system services, home services, or working with a Guix repository checkout. Handles package definitions, build systems, service types, configuration records, and development workflows.
التثبيت باستخدام Codex أو Claude انسخ هذا Prompt والصقه في Codex أو Claude أو مساعد آخر ليراجع صفحة Skill ويثبّتها لك.
استنادا إلى تصنيف SOC المهني
| name | guix |
| description | Expert knowledge for GNU Guix package and service development. Use when creating or modifying Guix packages, system services, home services, or working with a Guix repository checkout. Handles package definitions, build systems, service types, configuration records, and development workflows. |
This skill provides comprehensive guidance for working with GNU Guix, including package definitions, system and home services, and development workflows using a Guix repository checkout.
Every Guix package follows this basic structure:
(define-module (gnu packages category)
#:use-module (guix packages)
#:use-module (guix download)
#:use-module (guix git-download)
#:use-module (guix build-system gnu)
#:use-module ((guix licenses) #:prefix license:)
#:use-module (gnu packages base)
#:export (package-name))
(define-public package-name
(package
(name "package-name") ; lowercase, dash-separated
(version "1.0.0")
(source (origin ...)) ; where to get source
(build-system gnu-build-system) ; how to build it
(inputs (list pkg1 pkg2)) ; runtime dependencies
(native-inputs (list tool1)) ; build-time only tools
(propagated-inputs (list lib)) ; runtime deps for users
(arguments (list ...)) ; build system arguments
(synopsis "One-line description")
(description "Detailed description in Texinfo format")
(home-page "https://example.com")
(license license:gpl3+)))
Naming Convention:
(gnu packages CATEGORY) → gnu/packages/CATEGORY.scmRequired Imports:
(define-module (gnu packages mypackage)
#:use-module (guix packages)
#:use-module (guix download) ; for url-fetch
#:use-module (guix git-download) ; for git-fetch
#:use-module (guix build-system gnu) ; or other build system
#:use-module ((guix licenses) #:prefix license:)
#:use-module (gnu packages base) ; for common deps
#:export (mypackage))
URL Fetch (tarballs, releases):
(source (origin
(method url-fetch)
(uri (string-append "https://example.com/package-" version ".tar.gz"))
(sha256
(base32 "0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i"))
(patches (search-patches "package-fix-build.patch"))
(snippet
#~(begin
(use-modules (guix build utils))
(delete-file-recursively "bundled-lib")))))
Git Fetch (from repository):
(source (origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/example/repo")
(commit (string-append "v" version))))
(file-name (git-file-name name version))
(sha256
(base32 "..."))))
Getting Source Hashes
The command you use depends on how the source is fetched. These must match, or the build will fail with a hash mismatch.
url-fetch (tarballs, plain URLs):
# Download URL and print its hash
guix download https://example.com/package-1.0.tar.gz
# Hash a file already on disk
guix hash file.tar.gz
git-fetch (hashes a directory, not a file): A git-fetch source is
hashed over the checked-out tree with the .git directory removed. Tarball
hashes will not match — don't mix these up.
# Option A — clone the exact tag and let guix hash the tree
git clone --depth 1 --branch v1.2.3 https://github.com/example/repo /tmp/repo
guix hash -rx /tmp/repo
# -r recursive (nar-serialize the tree, which is what git-fetch expects)
# -x exclude VCS metadata (skips .git even if you forgot to remove it)
# Option B — the "let Guix tell you the hash" idiom (often the easiest)
# Put *any* valid base32 in the sha256 field (e.g. all zeros), then:
guix build -L modules my-package # or: ./pre-inst-env guix build my-package
# The build will fail with:
# sha256 hash mismatch for /gnu/store/...
# expected: 0000000000000000000000000000000000000000000000000000
# actual: <the real hash>
# Copy the "actual" value back into the sha256 field. This uses the exact
# same hasher that will later verify the source, so it's the canonical path.
Use Option A when you want the hash before running a build; Option B when you're already iterating on a build and a rebuild is cheap.
Three Types of Inputs:
inputs - Runtime dependencies (libraries, programs needed when running)
(inputs (list libffi glib ncurses))
native-inputs - Build-time tools (compilers, pkg-config, test frameworks)
(native-inputs (list pkg-config autoconf automake check))
propagated-inputs - Transitive dependencies (headers, libs in public APIs)
(propagated-inputs (list python-requests python-urllib3))
Using Specific Outputs:
(inputs (list `(,glib "bin"))) ; Use the "bin" output of glib
IMPORTANT: Modern style uses (list ...), old style uses quasiquote. Prefer list.
Modern Style (G-expressions - PREFERRED):
(arguments
(list
#:tests? #t ; Run tests (default #t)
#:parallel-build? #t ; Parallel build (default #t)
#:configure-flags #~(list
"--enable-foo"
(string-append "--with-bar=" #$some-input))
#:make-flags #~(list "VERBOSE=1")
#:phases
#~(modify-phases %standard-phases
(add-after 'unpack 'patch-sources
(lambda* (#:key inputs #:allow-other-keys)
(substitute* "Makefile"
(("/bin/sh") (search-input-file inputs "/bin/sh")))))
(delete 'configure)
(replace 'install
(lambda _
(install-file "binary" (string-append #$output "/bin")))))))
Old Style (still common):
(arguments
'(#:tests? #t
#:phases
(modify-phases %standard-phases
(add-after 'install 'fix-paths
(lambda* (#:key outputs #:allow-other-keys)
(let ((out (assoc-ref outputs "out")))
(substitute* (string-append out "/bin/script")
(("/bin/sh") (which "sh")))))))))
Most Common Build Systems:
gnu-build-system - Standard autotools (./configure && make && make install)python-build-system - Python packages with setup.pypyproject-build-system - Modern Python (PEP 517/518, poetry, flit, etc.)cmake-build-system - CMake-based projectsmeson-build-system - Meson build systemcargo-build-system - Rust packagesgo-build-system - Go packagesnode-build-system - Node.js/npm packagestrivial-build-system - Fully custom build processcopy-build-system - Just copy files to outputGNU Build System Phases (in order):
unpack → patch-source-shebangs → configure → build → check →
install → patch-shebangs → strip → validate-runpath → compress-documentation
Modifying Phases:
(modify-phases %standard-phases
(add-before 'configure 'set-environment
(lambda _ (setenv "CC" "gcc")))
(add-after 'install 'wrap-program
(lambda* (#:key outputs inputs #:allow-other-keys)
(wrap-program (string-append #$output "/bin/prog")
`("PATH" ":" prefix (,(string-append #$some-dep "/bin"))))))
(replace 'build
(lambda _ (invoke "make" "all")))
(delete 'check)) ; Skip tests
Python Build System (Modern) — pyproject-build-system:
(build-system pyproject-build-system)
(arguments
(list
#:test-flags #~(list "-v"
;; Deselect tests that can't run in the sandbox:
"--deselect=tests/test_net.py::test_needs_internet"
"--ignore=tests/integration")
#:build-backend "poetry-core")) ; or setuptools, flit-core, hatchling, …
(native-inputs
(list python-pytest
python-pytest-httpserver ; test-only deps go HERE
python-setuptools
python-wheel))
(propagated-inputs
(list python-requests)) ; things your Python code imports
Python dependency placement rules — this is the #1 pyproject pitfall:
native-inputs — test runners and test plugins (python-pytest,
python-pytest-httpserver, python-pytest-mock, python-hypothesis),
build backends (python-setuptools, python-wheel, python-hatchling,
python-poetry-core), code generators, linters used by tests. Anything
consumed by the check phase and not imported at runtime belongs here.propagated-inputs — every Python library the installed package
imports at runtime. Python cannot find unpropagated site-packages, so
runtime deps must propagate. This is different from C libraries.inputs — non-Python runtime dependencies (C libraries linked by
the Python extension modules, CLI programs the package shells out to).A ModuleNotFoundError during the check phase for a test-only import
(e.g. No module named 'pytest_httpserver') is almost always "I forgot to
add it to native-inputs." Diagnose with:
guix build -L modules my-package --keep-failed
grep -rn pytest_httpserver /tmp/guix-build-*/source # confirm test-only
guix search pytest-httpserver # find the Guix name
The Guix name convention is python-<pypi-name-with-dashes>. Underscores
in Python import names become dashes in Guix package names:
pytest_httpserver → python-pytest-httpserver,
opentelemetry_api → python-opentelemetry-api.
Do not "fix" a missing test dep with #:tests? #f or (delete 'check).
Those hide regressions. #:test-flags with --deselect / --ignore is
the right tool only for individual tests that genuinely cannot run in the
sandbox (network, GPU, /dev access).
In Build Phases:
;; Search for files in inputs
(search-input-file inputs "/bin/sh")
(search-input-directory inputs "/include")
;; Running commands
(invoke "make" "install") ; Fails if non-zero exit
(system* "make" "test") ; Returns exit code
;; File operations
(install-file "src/binary" (string-append #$output "/bin"))
(copy-recursively "data" (string-append #$output "/share/data"))
(mkdir-p (string-append #$output "/share/doc"))
(delete-file-recursively "unwanted")
;; Path utilities
(which "sh") ; Find in PATH
(dirname "/path/to/file")
(basename "/path/to/file")
;; Substitution (editing files)
(substitute* "config.h"
(("/usr/local") #$output)
(("/bin/sh") (which "sh")))
;; Directory context
(with-directory-excursion "subdir"
(invoke "make"))
;; Environment
(setenv "CC" "gcc")
(getenv "PATH")
Outside Build Phases:
;; Self-reference
this-package
;; File utilities
(local-file "path/to/file.txt")
(plain-file "name" "content")
(computed-file "name" #~(mkdir #$output))
;; Patches
(search-patches "package-fix.patch") ; looks in gnu/packages/patches/
;; Version manipulation
(version-major+minor "1.2.3") ; => "1.2"
;; System detection
(%current-target-system) ; Cross-compilation target
(%current-system) ; e.g., "x86_64-linux"
(target-64bit?)
(target-aarch64?)
(target-x86-64?)
Reuse existing package definitions:
(define-public hello-custom
(package
(inherit hello)
(name "hello-custom")
(arguments
(substitute-keyword-arguments (package-arguments hello)
((#:configure-flags flags)
#~(cons "--enable-custom" #$flags))
((#:phases phases)
#~(modify-phases #$phases
(add-after 'install 'install-extra
(lambda _
(install-file "extra"
(string-append #$output "/bin"))))))))))
System services go in gnu/services/CATEGORY.scm:
(define-module (gnu services myservice)
#:use-module (gnu services)
#:use-module (gnu services shepherd)
#:use-module (guix records)
#:use-module (guix gexp)
#:export (myservice-configuration
myservice-service-type))
;; Configuration record
(define-record-type* <myservice-configuration>
myservice-configuration make-myservice-configuration
myservice-configuration?
(package myservice-configuration-package
(default mypackage))
(port myservice-configuration-port
(default 8080))
(config-file myservice-configuration-config-file
(default #f)))
;; Generate config file
(define (myservice-config-file config)
(computed-file "myservice.conf"
#~(begin
(use-modules (ice-9 format))
(call-with-output-file #$output
(lambda (port)
(format port "port=~a\n"
#$(myservice-configuration-port config)))))))
;; Shepherd service definition
(define (myservice-shepherd-service config)
(list (shepherd-service
(documentation "My service daemon")
(provision '(myservice))
(requirement '(networking))
(start #~(make-forkexec-constructor
(list #$(file-append
(myservice-configuration-package config)
"/bin/myservice")
"--config"
#$(myservice-config-file config))))
(stop #~(make-kill-destructor)))))
;; Service type definition
(define myservice-service-type
(service-type
(name 'myservice)
(extensions
(list (service-extension shepherd-root-service-type
myservice-shepherd-service)
(service-extension profile-service-type
(lambda (config)
(list (myservice-configuration-package config))))))
(default-value (myservice-configuration))
(description "Run myservice daemon.")))
Usage in system config:
(service myservice-service-type
(myservice-configuration
(port 9000)))
Home services go in gnu/home/services/CATEGORY.scm:
(define-module (gnu home services myshell)
#:use-module (gnu home services)
#:use-module (gnu services configuration)
#:use-module (guix records)
#:use-module (guix gexp)
#:export (home-myshell-configuration
home-myshell-service-type))
;; Configuration using define-configuration
(define-configuration home-myshell-configuration
(package
(package myshell-package)
"The shell package to use.")
(aliases
(alist '())
"Association list of aliases.")
(extra-config
(text-config '())
"List of strings or file-like objects for config."))
;; Generate files for $HOME
(define (home-myshell-files config)
(list
`(".myshellrc"
,(mixed-text-file
"myshellrc"
#~(string-append
#$@(home-myshell-configuration-extra-config config))))))
;; Add package to profile
(define (home-myshell-profile config)
(list (home-myshell-configuration-package config)))
;; Service type
(define home-myshell-service-type
(service-type
(name 'home-myshell)
(extensions
(list (service-extension home-files-service-type
home-myshell-files)
(service-extension home-profile-service-type
home-myshell-profile)))
(default-value (home-myshell-configuration))
(description "Install and configure myshell.")))
Usage in home config:
(service home-myshell-service-type
(home-myshell-configuration
(extra-config
(list "alias ll='ls -la'"))))
When a home service needs to run a long-lived program (a daemon, a watcher,
a user-level webhook receiver), extend home-shepherd-service-type rather
than writing shell exec lines into a shell rc file. The result is
equivalent to a systemd user service: herd status shows it, herd restart <name> works, and respawning is built in.
This is the home analogue of the system service-type pattern above, but uses
home-prefixed extension points (home-shepherd-service-type,
home-profile-service-type) — not shepherd-root-service-type, which is
system-level and will look wrong in a home config.
(define-module (r0man guix home services mydaemon)
#:use-module (gnu home services)
#:use-module (gnu home services shepherd)
#:use-module (gnu services shepherd) ; for shepherd-service
#:use-module (guix gexp)
#:use-module (guix records)
#:use-module (r0man guix packages mydaemon)
#:export (home-mydaemon-configuration
home-mydaemon-service-type))
(define-record-type* <home-mydaemon-configuration>
home-mydaemon-configuration make-home-mydaemon-configuration
home-mydaemon-configuration?
(package home-mydaemon-package
(default mydaemon))
(port home-mydaemon-port
(default 7070))
(config-file home-mydaemon-config-file
(default #f))) ; file-like or #f
(define (home-mydaemon-shepherd-services config)
(list
(shepherd-service
(documentation "Run the mydaemon user service.")
(provision '(mydaemon))
(respawn? #t)
(start #~(make-forkexec-constructor
(append
(list #$(file-append
(home-mydaemon-package config)
"/bin/mydaemon")
"--port" #$(number->string
(home-mydaemon-port config)))
(if #$(home-mydaemon-config-file config)
(list "--config"
#$(home-mydaemon-config-file config))
'()))
#:log-file (string-append
(or (getenv "XDG_STATE_HOME")
(string-append (getenv "HOME")
"/.local/state"))
"/mydaemon.log")))
(stop #~(make-kill-destructor)))))
(define (home-mydaemon-profile-packages config)
(list (home-mydaemon-package config)))
(define home-mydaemon-service-type
(service-type
(name 'home-mydaemon)
(extensions
(list (service-extension home-shepherd-service-type
home-mydaemon-shepherd-services)
(service-extension home-profile-service-type
home-mydaemon-profile-packages)))
(default-value (home-mydaemon-configuration))
(description "Run mydaemon as a user-level shepherd service.")))
Key points that trip people up:
file-append to compute the binary path at build time
((file-append pkg "/bin/mydaemon")). Do not hardcode a store path and
do not call which.make-forkexec-constructor does not inherit the parent shell's
environment. If the daemon needs specific env vars, pass
#:environment-variables explicitly with a list of "KEY=value"
strings. A common pitfall is assuming PATH is set — it often isn't.start/stop gexps run in the shepherd process at service-start
time. Values from config must be lowered with #$ inside the gexp,
which is why the example let-binds at the outer level and then splices.$XDG_STATE_HOME or
~/.local/state/<name>.log is a reasonable default.home-<name>-profile-packages helper makes the package available on
$PATH, which is almost always what you also want when you're shipping
a daemon (so the user can invoke the binary directly too).Common extension points:
System Services:
shepherd-root-service-type - Add shepherd services (daemons)profile-service-type - Add packages to system profileetc-service-type - Add files to /etcactivation-service-type - Run code at system activationHome Services:
home-files-service-type - Add files to $HOMEhome-xdg-configuration-files-service-type - Add files to $XDG_CONFIG_HOMEhome-profile-service-type - Add packages to home profilehome-run-on-change-service-type - Run code when config changesMost users doing real Guix work day-to-day are not editing a checkout of
guix.git. They are working inside a personal channel or a Guix Home
repository that ships its own modules/ directory with package and service
definitions. In that situation you do not need ./pre-inst-env — you
just point Guix at your modules with -L.
The key flag is -L <path> (or --load-path=<path>), which adds a
directory to Guile's module search path for that one invocation. The
working tree is used directly, so changes are picked up immediately — no
guix pull, no rebuild of Guix itself.
# From the channel repo root — build a package from your local source
guix build -L modules my-package
# Keep the build tree on failure for inspection
guix build -L modules --keep-failed my-package
# Lint it using your local checkout
guix lint -L modules my-package
# Dry-run the whole home environment against the local tree
# (catches module-load errors, unbound variables, and derivation-graph issues)
guix home -L modules --dry-run reconfigure \
modules/r0man/guix/home/environments/m1.scm
# Drop into a REPL with the local modules visible
guix repl -L modules
,use (r0man guix packages task-management)
(package-version my-package)
If a package isn't reachable by bare name (e.g. because the CLI can't auto-discover it), build it by an expression instead:
guix build -L modules \
-e '(@ (r0man guix packages task-management) my-package)'
When to use ./pre-inst-env vs -L modules:
./pre-inst-env — you're inside a checkout of guix.git itself and are
editing packages in upstream Guix (gnu/packages/*.scm). You need a
built Guix to run.-L modules — you're in a personal channel or Guix Home repo whose
modules sit under modules/ in the working tree. Nothing to compile
first; the installed Guix just loads your modules too.Use -L modules unless you're specifically contributing to upstream Guix.
Updating a package in a personal channel (the common workflow):
version and sha256 in the package definition.git-fetch sources, see "Getting Source Hashes"
above — the easiest path is Option B: drop in a bogus (base32 "00…")
hash, run guix build -L modules <pkg>, and copy the actual: line
out of the hash-mismatch error.guix build -L modules <pkg> until it builds cleanly.guix lint -L modules <pkg> for style/metadata issues.guix home -L modules --dry-run reconfigure …environments/<host>.scm
to verify dependents still resolve.guix home reconfigure on the affected host.# Clone repository
git clone https://git.savannah.gnu.org/git/guix.git
cd guix
# Bootstrap and configure
./bootstrap
./configure --localstatedir=/var
# Build
make -j$(nproc)
# Install git hooks (for contributors)
make install-git-hooks
The ./pre-inst-env wrapper lets you test changes without installing:
# Build a package from your checkout
./pre-inst-env guix build hello
# Install a package you just defined
./pre-inst-env guix package -i my-new-package
# Start a REPL with your changes
./pre-inst-env guix repl
# Lint your package
./pre-inst-env guix lint my-package
# Check for updates
./pre-inst-env guix refresh my-package
What pre-inst-env does:
# Build with options
./pre-inst-env guix build hello --no-grafts --keep-failed
# Build from a file
guix build -f my-package.scm
# Enter build environment
./pre-inst-env guix shell -D hello
# Build and check size
./pre-inst-env guix size hello
# View dependency graph
./pre-inst-env guix graph hello | dot -Tpng > graph.png
Interactive Scheme REPL for package development:
$ ./pre-inst-env guix repl
;; Import modules
,use (gnu packages base)
,use (guix packages)
,use (guix gexp)
;; Inspect a package
hello
(package-name hello)
(package-version hello)
(package-arguments hello)
;; Build a package
,build hello
;; Lower to derivation
,lower hello
;; Work with transformations
(package-with-c-toolchain hello `(("toolchain" ,gcc-toolchain)))
;; Import entire module
(use-modules (gnu packages base))
;; Import with prefix
(use-modules ((guix licenses) #:prefix license:))
;; Import specific bindings
(use-modules ((gnu packages gcc) #:select (gcc)))
;; Autoload (lazy loading)
#:autoload (gnu packages gcc) (gcc)
Find the right module in gnu/packages/ (e.g., gnu/packages/networking.scm)
Add necessary imports:
#:use-module (guix packages)
#:use-module (guix download)
#:use-module (guix build-system gnu)
#:use-module ((guix licenses) #:prefix license:)
Define the package:
(define-public my-package
(package
(name "my-package")
(version "1.0.0")
(source (origin ...))
...))
Get the source hash:
guix download https://example.com/my-package-1.0.0.tar.gz
Test the build:
./pre-inst-env guix build my-package
Run linter:
./pre-inst-env guix lint my-package
Test installation:
./pre-inst-env guix package -i my-package
Edit the version:
(version "2.0.0")
Update URI if needed:
(uri (string-append "..." version ".tar.gz"))
Get new hash:
guix download https://example.com/package-2.0.0.tar.gz
Update sha256:
(sha256 (base32 "NEW-HASH-HERE"))
Test build:
./pre-inst-env guix build package-name
Check for changes in dependencies or build process
Create module file:
gnu/services/myservice.scmgnu/home/services/myservice.scmDefine configuration record:
(define-record-type* <myservice-configuration> ...)
Create helper functions:
Define service-type:
(define myservice-service-type
(service-type
(name 'myservice)
(extensions ...)
(default-value ...)
(description "...")))
Test in a config:
guix system reconfigure config.scm # system service
guix home reconfigure home.scm # home service
Build with --keep-failed:
./pre-inst-env guix build my-package --keep-failed
Check the build log for error messages
Enter build environment:
./pre-inst-env guix shell -D my-package
cd /tmp/guix-build-my-package-1.0.0-0 # from --keep-failed
Manually reproduce the failed step
Add diagnostic output in phases:
(add-before 'build 'debug
(lambda _
(format #t "Current directory: ~a\n" (getcwd))
(system* "ls" "-la")))
Common issues and fixes:
Problem: Source hash doesn't match
Solution: Use guix download URL to get correct hash, copy the base32 hash
Problem: Build fails with "command not found" or missing libraries
Solution: Add missing tools to native-inputs, libraries to inputs
Problem: Tests fail in sandboxed build environment Solution 1: Disable specific tests
(add-before 'check 'disable-failing-tests
(lambda _
(substitute* "tests/test_network.py"
(("test_network") "disabled_test_network"))))
Solution 2: Disable all tests (last resort)
(arguments (list #:tests? #f))
Problem: Program has /usr or /bin paths Solution: Use substitute* to replace them
(substitute* "script.sh"
(("/bin/sh") (which "sh"))
(("/usr/local") #$output))
Problem: "source directory modified" error Solution: Use out-of-source build
(arguments (list #:out-of-source? #t))
Problem: Phase runs in wrong order Solution: Use add-before, add-after, replace carefully
(add-after 'unpack 'patch-before-configure ...)
(add-before 'build 'set-flags ...)
guix build package-name # Build package
guix build -f file.scm # Build from file
guix build --check package # Rebuild to verify reproducibility
guix build --keep-failed package # Keep build directory on failure
guix build --no-grafts package # Disable security grafts
guix lint package-name # Check for issues
guix refresh package-name # Check for updates
guix size package-name # Check closure size
guix graph package-name # Show dependencies
guix shell -D package # Enter development environment
guix shell package -- command # Run command with package
guix hash file.tar.gz # Get hash of file
guix download URL # Download and hash
make check # Run test suite
./pre-inst-env guix build hello # Test with local changes
guix repl # Interactive testing
When working from a Guix repository checkout, refer to these locations:
gnu/packages/gnu/services/gnu/home/services/guix/build-system/guix/build/utils.scmgnu/packages/patches/doc/guix.texidoc/guix-cookbook.texidoc/contributing.texiWhen stuck, use these resources:
# View package definition
./pre-inst-env guix edit package-name
# Search for similar packages
./pre-inst-env guix search keyword
# Check package dependencies
./pre-inst-env guix graph package-name
# View build log
guix build --log-file package-name
# Ask on IRC: #guix on libera.chat
# Mailing list: help-guix@gnu.org
Comprehensive multi-lens code review with presets and a synthesized, prioritized verdict. Use this skill whenever you want existing changes assessed - review PRs, branches, diffs, or sets of changed files with multiple independent lenses (correctness, performance, security, etc).
Structured multi-dimension design exploration that produces a synthesized design doc with options, trade-offs, risks, and a phased plan. Use this skill when you want something thought through before it is built - for API design, data modeling, UX, scalability, security, and integration concerns. Explores problems across independent dimensions and reconciles them.
Enterprise-grade engineering — the shiny workflow with the implementation expanded into the Rule of Five iterative-refinement passes. Use this skill for critical work where quality outweighs speed - financial, payments, auth, billing, or data-migration code where mistakes are serious.
Engineer-in-a-Box — a disciplined design→implement→review→test→submit workflow with gates for any non-trivial code change. Use this skill proactively for feature work, bug fixes, and refactorings that touch multiple files. Follows five phases with gates - design before coding, review before shipping, test before submitting.
Expert knowledge for building web-based GUIs and websites with CLOG (Common Lisp Omnificent GUI), with the declarative `with-clog-create` macro as the recommended way to build UIs. Use this skill whenever the user mentions CLOG, wants to build a Common Lisp web app or browser-rendered desktop-style GUI, asks about initialize/on-new-window/connection-data-item/clog-gui/clog-web/with-clog-create, needs help with WebSocket-driven Lisp UIs, writes a CLOG plugin or new element class, hooks CLOG into a SQL database (clog-dbi / clog-auth), or deploys a CLOG server behind a reverse proxy. Trigger even when the user just says "browser GUI in Common Lisp" or "web UI for my Lisp app" without naming CLOG by name.
Expert knowledge for Asahi Linux — running, troubleshooting, and hacking on Linux for Apple Silicon Macs (M1/M2/M3/M4). Use this skill whenever the user mentions Apple Silicon Linux, Asahi, Fedora Asahi Remix, m1n1, alx.sh, or asks about bootloaders, kernel/GPU/audio/firmware, x86 emulation with muvm/FEX, DFU recovery, or Steam/gaming on M-series Macs — even if they describe the hardware as "M1 MacBook" or "Apple Silicon" without naming Asahi. Also use for contributing upstream (m1n1 hypervisor, kernel drivers, speakersafetyd, Mesa asahi/honeykrisp).