Commit f16497f5f43c

@@ -0,0 +1,527 @@
+# Build Workflow
+
+Build Nix packages, NixOS configurations, and understand the build process.
+
+## When to Use
+
+- "build nix package"
+- "build nixos configuration"
+- "nix build"
+- "compile nix expression"
+
+## Quick Commands
+
+### Building Packages
+```bash
+# Build package from flake
+nix build .#package-name
+
+# Build and create result symlink
+nix build .#package-name -o result
+
+# Build specific output
+nix build .#package-name.out
+
+# Build without creating result symlink
+nix build .#package-name --no-link
+
+# Show build logs
+nix build .#package-name -L
+nix build .#package-name --print-build-logs
+```
+
+### Building NixOS Configurations
+```bash
+# Build NixOS configuration
+nixos-rebuild build --flake .#hostname
+
+# Build without switching
+nix build .#nixosConfigurations.hostname.config.system.build.toplevel
+
+# Dry build (show what would change)
+nixos-rebuild dry-build --flake .#hostname
+
+# Build with verbose output
+nixos-rebuild build --flake .#hostname --show-trace
+```
+
+### Building for Different Systems
+```bash
+# Build for different architecture
+nix build .#package-name --system x86_64-linux
+nix build .#package-name --system aarch64-linux
+
+# Cross-compile
+nix build .#package-name.pkgsCross.aarch64-multiplatform
+```
+
+## Understanding Build Process
+
+### Build Phases
+```
+Nix build phases (for stdenv.mkDerivation):
+1. unpackPhase    - Extract source
+2. patchPhase     - Apply patches
+3. configurePhase - Run ./configure
+4. buildPhase     - Run make
+5. checkPhase     - Run tests
+6. installPhase   - Install to output
+7. fixupPhase     - Fix up outputs
+```
+
+### Viewing Build Steps
+```bash
+# Show derivation
+nix show-derivation .#package-name
+
+# Show build script
+nix develop .#package-name --command cat $(type -p genericBuild)
+
+# Build with debug output
+nix build .#package-name --debug
+```
+
+## Building Packages
+
+### From Flake
+```bash
+# Build package
+nix build .#mypackage
+
+# Build and run
+nix run .#mypackage
+
+# Build all packages
+nix build .#packages.x86_64-linux.mypackage
+```
+
+### From nixpkgs
+```bash
+# Build package from nixpkgs
+nix build nixpkgs#firefox
+
+# Build specific version
+nix build github:nixos/nixpkgs/nixos-23.11#firefox
+```
+
+### Build Local Package
+```bash
+# Build package in current directory
+nix build
+
+# Build with specific expression
+nix build -f default.nix
+
+# Build attribute
+nix build -f . mypackage
+```
+
+## Building NixOS Systems
+
+### Local System
+```bash
+# Build current system configuration
+sudo nixos-rebuild build --flake .
+
+# Build specific host
+nixos-rebuild build --flake .#hostname
+
+# Build and show what will change
+nixos-rebuild dry-build --flake .#hostname
+```
+
+### Remote System
+```bash
+# Build for remote host
+nixos-rebuild build --flake .#remote-host \
+  --target-host user@remote-host \
+  --use-remote-sudo
+
+# Build locally for remote deployment
+nix build .#nixosConfigurations.remote-host.config.system.build.toplevel
+```
+
+### Build VM
+```bash
+# Build VM from configuration
+nixos-rebuild build-vm --flake .#hostname
+
+# Run the VM
+./result/bin/run-*-vm
+```
+
+## Build Options
+
+### Parallel Builds
+```bash
+# Build with more cores
+nix build .#package --cores 8
+
+# Limit parallel jobs
+nix build .#package --max-jobs 4
+```
+
+### Offline Mode
+```bash
+# Build without network access
+nix build .#package --offline
+
+# Use only local cache
+nix build .#package --no-net
+```
+
+### Rebuild Everything
+```bash
+# Force rebuild (ignore cache)
+nix build .#package --rebuild
+
+# Build from source (no binary cache)
+nix build .#package --no-substitute
+```
+
+## Build Outputs
+
+### Multiple Outputs
+```bash
+# Packages can have multiple outputs
+# Common: out, dev, doc, lib
+
+# Build specific output
+nix build .#package.dev    # Development files
+nix build .#package.doc    # Documentation
+nix build .#package.lib    # Libraries only
+
+# View all outputs
+nix show-derivation .#package | jq '.[] | .outputs'
+```
+
+### Inspect Build Result
+```bash
+# After building, result symlink created
+ls -l result/
+
+# View store path
+readlink result
+
+# Inspect contents
+tree result/
+
+# Check dependencies
+nix-store -q --references result
+nix-store -q --requisites result
+```
+
+## Build Caching
+
+### Using Binary Caches
+```bash
+# Add binary cache
+nix build .#package \
+  --extra-substituters https://cache.nixos.org \
+  --extra-trusted-public-keys cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY=
+
+# Use cachix
+cachix use mycache
+nix build .#package
+```
+
+### Push to Cache
+```bash
+# Push to cachix
+nix build .#package
+cachix push mycache result
+
+# Push with nix copy
+nix copy --to https://cache.example.com result
+```
+
+## Build for Development
+
+### Enter Build Environment
+```bash
+# Enter environment for building
+nix develop .#package
+
+# Build manually
+unpackPhase
+cd $sourceRoot
+configurePhase
+buildPhase
+```
+
+### Iterative Building
+```bash
+# Build and keep build directory
+nix build .#package --keep-failed
+
+# Failed build directory preserved at:
+# /tmp/nix-build-package-*.drv-0/
+
+# Inspect failed build
+cd /tmp/nix-build-*
+```
+
+## Repository-Specific Builds
+
+### Home Repository
+```bash
+# Build current system
+make switch
+
+# Build without switching
+make dry-build
+
+# Build specific host
+make host/hostname/build
+
+# Build all packages
+nix build .#packages.x86_64-linux --all
+```
+
+### Build Custom Package
+```bash
+# Package in pkgs/mypackage/
+nix build .#mypackage
+
+# Test package
+nix build .#mypackage -L
+
+# Install locally
+nix profile install .#mypackage
+```
+
+## Debugging Builds
+
+### Verbose Output
+```bash
+# Show all build output
+nix build .#package -L
+
+# Show evaluation trace
+nix build .#package --show-trace
+
+# Maximum verbosity
+nix build .#package -vvv --show-trace
+```
+
+### Build Failures
+```bash
+# Keep failed build directory
+nix build .#package --keep-failed
+
+# Keep successful build directory too
+nix build .#package --keep-going
+
+# Inspect build directory
+cd /tmp/nix-build-*
+ls -la
+cat build.log
+```
+
+### Interactive Debugging
+```bash
+# Enter build environment
+nix develop .#package
+
+# Run build phases manually
+genericBuild
+# Or individual phases:
+unpackPhase
+patchPhase
+configurePhase
+buildPhase
+```
+
+## Build Performance
+
+### Speed Up Builds
+```bash
+# Use more cores
+nix build .#package --cores $(nproc)
+
+# Use binary caches
+nix build .#package --substituters https://cache.nixos.org
+
+# Parallel jobs
+nix build .#package --max-jobs auto
+```
+
+### Monitor Build Progress
+```bash
+# Real-time build logs
+nix build .#package -L
+
+# Follow log file
+tail -f /tmp/nix-build-*.log
+
+# Show build statistics
+nix build .#package --print-build-logs | ts
+```
+
+## Cross-Compilation
+
+### Build for ARM
+```bash
+# ARM 64-bit
+nix build .#package --system aarch64-linux
+
+# ARM 32-bit
+nix build .#package --system armv7l-linux
+
+# Using pkgsCross
+nix build .#package.pkgsCross.aarch64-multiplatform
+```
+
+### Build for Different Platform
+```bash
+# Build for Raspberry Pi
+nix build .#nixosConfigurations.rpi4-host.config.system.build.sdImage
+
+# Build for different NixOS version
+nix build github:nixos/nixpkgs/nixos-23.11#package
+```
+
+## Advanced Build Techniques
+
+### Override Package Attributes
+```bash
+# Override during build
+nix build --impure --expr '
+  (import <nixpkgs> {}).mypackage.overrideAttrs (old: {
+    version = "custom";
+  })
+'
+```
+
+### Build from Git
+```bash
+# Build from specific commit
+nix build github:owner/repo/commit-hash#package
+
+# Build from branch
+nix build github:owner/repo/branch-name#package
+
+# Build from local git
+nix build git+file:///path/to/repo#package
+```
+
+### Conditional Builds
+```bash
+# Build only if changed
+nix build .#package --rebuild
+
+# Build with different features
+nix build .#package --arg enableFeature true
+```
+
+## Build Artifacts
+
+### Store Paths
+```bash
+# Show store path without building
+nix eval .#package
+
+# Show closure size
+nix path-info -S .#package
+
+# Show all dependencies
+nix-store -qR result
+
+# Show why package is kept
+nix-store --query --roots result
+```
+
+### Build Logs
+```bash
+# View previous build log
+nix log .#package
+
+# View log of store path
+nix log /nix/store/...-package
+
+# Save build log
+nix build .#package -L 2>&1 | tee build.log
+```
+
+## Build Best Practices
+
+1. **Use binary caches**: Avoid rebuilding common packages
+2. **Pin versions**: Use flake.lock for reproducibility
+3. **Test locally first**: Build before deploying
+4. **Keep build logs**: Debug failures with `-L` flag
+5. **Use `--dry-build`**: Preview changes before building
+6. **Check closures**: Understand dependencies with `nix path-info`
+7. **Incremental builds**: Use `nix develop` for iteration
+8. **Parallel builds**: Utilize `--cores` and `--max-jobs`
+
+## Common Build Patterns
+
+### Build and Test
+```bash
+# Build package
+nix build .#mypackage -L
+
+# Run tests
+nix build .#mypackage.tests
+
+# Build and run
+nix run .#mypackage
+```
+
+### Build Multiple Outputs
+```bash
+# Build all outputs
+nix build .#package.all
+
+# Build specific combinations
+nix build .#package.out .#package.dev
+```
+
+### Build with Local Changes
+```bash
+# Build with local modifications
+nix build .#package --override-input nixpkgs path:/local/nixpkgs
+
+# Build with local flake
+nix build path:/local/repo#package
+```
+
+## Troubleshooting Builds
+
+### Hash Mismatches
+```bash
+# Update hash
+# 1. Set hash to lib.fakeSha256 or empty string
+# 2. Build to get error with correct hash
+nix build .#package 2>&1 | grep "got:"
+
+# For fetchFromGitHub
+nix-prefetch-github owner repo --rev commit-hash
+```
+
+### Disk Space Issues
+```bash
+# Clean old build artifacts
+nix-collect-garbage -d
+
+# Check store size
+du -sh /nix/store
+
+# Remove specific paths
+nix-store --delete /nix/store/...-package
+```
+
+### Permission Errors
+```bash
+# Build as root
+sudo nix build .#package
+
+# Build with different user
+sudo -u builder nix build .#package
+```
+
+## Resources
+
+- [Nix Build Manual](https://nixos.org/manual/nix/stable/command-ref/nix-build.html)
+- [NixOS Rebuild](https://nixos.org/manual/nixos/stable/#sec-changing-config)
+- [Nix Package Stdenv](https://nixos.org/manual/nixpkgs/stable/#chap-stdenv)

@@ -0,0 +1,591 @@
+# Debug Workflow
+
+Debug Nix expressions, evaluation errors, and build failures.
+
+## When to Use
+
+- "debug nix expression"
+- "nix evaluation error"
+- "troubleshoot nix build"
+- "nix error messages"
+
+## Quick Commands
+
+### Evaluation Debugging
+```bash
+# Show evaluation trace
+nix eval .#package --show-trace
+
+# Evaluate with verbosity
+nix eval .#package -vvv
+
+# Show derivation
+nix show-derivation .#package
+
+# Inspect attribute path
+nix eval .#nixosConfigurations.hostname.config.services
+```
+
+### Build Debugging
+```bash
+# Build with full logs
+nix build .#package -L
+nix build .#package --print-build-logs
+
+# Keep failed build directory
+nix build .#package --keep-failed
+
+# Show trace on error
+nix build .#package --show-trace
+
+# Maximum verbosity
+nix build .#package -vvv --show-trace -L
+```
+
+### Interactive Debugging
+```bash
+# Enter build environment
+nix develop .#package
+
+# Enter failed build directory
+cd /tmp/nix-build-*
+
+# Run phases manually
+unpackPhase
+patchPhase
+configurePhase
+buildPhase
+```
+
+## Understanding Error Messages
+
+### Infinite Recursion
+```
+error: infinite recursion encountered
+```
+
+**Cause**: Circular dependency or self-referencing attribute
+
+**Debug**:
+```nix
+# Problem
+{
+  x = y;
+  y = x;  # Infinite recursion!
+}
+
+# Fix: Break the cycle
+{
+  x = lib.mkDefault value;
+  y = config.x;
+}
+```
+
+### Attribute Not Found
+```
+error: attribute 'foo' missing
+```
+
+**Debug**:
+```bash
+# Check what attributes exist
+nix eval .#nixosConfigurations.hostname --apply builtins.attrNames
+
+# Check nested attributes
+nix eval .#nixosConfigurations.hostname.config --apply "x: builtins.attrNames x.services"
+
+# Use --show-trace to see where error originates
+nix eval .#package --show-trace
+```
+
+### Type Errors
+```
+error: value is a set while a string was expected
+```
+
+**Debug**:
+```bash
+# Check type of value
+nix eval .#value --apply builtins.typeOf
+
+# Print value for inspection
+nix eval .#value --apply "x: builtins.trace x x"
+
+# Show detailed type error
+nix eval .#value --show-trace
+```
+
+### Hash Mismatches
+```
+error: hash mismatch in fixed-output derivation
+  got:    sha256-AAAA...
+  wanted: sha256-BBBB...
+```
+
+**Fix**:
+```bash
+# Copy the "got" hash to your expression
+# Or use nix-prefetch for correct hash
+nix-prefetch-url https://example.com/file.tar.gz
+nix-prefetch-github owner repo --rev commit-hash
+```
+
+## Debugging Techniques
+
+### Trace Values
+```nix
+# Simple trace
+value = builtins.trace "Debug: ${toString someValue}" someValue;
+
+# Trace with lib
+value = lib.traceVal someValue;
+value = lib.traceValSeq "message" someValue;
+
+# Trace attribute names
+value = lib.traceSeq (builtins.attrNames attrs) attrs;
+
+# Deep trace
+value = lib.traceValSeqN 3 someNestedValue;
+```
+
+### Evaluate Expressions
+```bash
+# Evaluate simple expression
+nix eval --expr '1 + 1'
+
+# Evaluate with nixpkgs
+nix eval --expr 'with import <nixpkgs> {}; lib.version'
+
+# Evaluate flake attribute
+nix eval .#nixosConfigurations.hostname.config.networking.hostName
+
+# Evaluate and show as JSON
+nix eval .#package --json
+
+# Evaluate and show as XML
+nix eval .#package --xml
+```
+
+### Check Configuration
+```bash
+# Check NixOS configuration validity
+nixos-rebuild build --flake .#hostname --dry-run
+
+# Show configuration options
+nix eval .#nixosConfigurations.hostname.options
+
+# Check if option exists
+nix eval .#nixosConfigurations.hostname.options.services.nginx.enable.defined
+
+# Show option documentation
+nixos-option services.nginx.enable
+```
+
+## Debugging Build Failures
+
+### Inspect Build Environment
+```bash
+# Enter build environment
+nix develop .#package
+
+# Check environment variables
+env | grep -i nix
+printenv
+
+# Check build tools available
+which gcc make cmake
+
+# Check paths
+echo $PATH
+echo $PKG_CONFIG_PATH
+```
+
+### Manual Build Steps
+```bash
+# Enter development shell
+nix develop .#package
+
+# Run phases manually
+unpackPhase
+ls -la
+
+cd $sourceRoot
+patchPhase
+
+configurePhase
+# Fix any configuration issues
+
+buildPhase
+# Fix build errors
+
+checkPhase
+installPhase
+```
+
+### Inspect Failed Build
+```bash
+# Build with --keep-failed
+nix build .#package --keep-failed
+
+# Failed build kept at:
+cd /tmp/nix-build-package-*.drv-0/
+
+# Examine source
+ls -la
+find . -type f -name "*.log"
+
+# Check build log
+cat build.log
+
+# Re-run failed command manually
+./configure
+make
+```
+
+### Debug Build Script
+```bash
+# Show builder script
+nix show-derivation .#package | jq '.[].env.builder'
+
+# Show full derivation
+nix derivation show .#package
+
+# Print build environment
+nix develop .#package --command printenv
+```
+
+## Debugging Evaluation Errors
+
+### Stack Traces
+```bash
+# Show full stack trace
+nix eval .#package --show-trace
+
+# Example output:
+# error: undefined variable 'foo'
+#
+#        at /path/to/file.nix:42:5:
+#           41|   bar = {
+#           42|     baz = foo;
+#              |           ^
+#           43|   };
+```
+
+### Find Definition Location
+```bash
+# Find where option is defined
+nix eval .#nixosConfigurations.hostname.options.services.nginx.enable.definitionsWithLocations
+
+# Find where value is set
+nix eval .#nixosConfigurations.hostname.options.services.nginx.enable.files
+```
+
+### Check Module Evaluation
+```bash
+# Evaluate specific module
+nix eval -f ./module.nix
+
+# Check module with config
+nix eval --expr 'import ./module.nix { lib = import <nixpkgs/lib>; }'
+
+# Show module errors
+nix-instantiate --eval --strict ./module.nix
+```
+
+## Debugging Package Builds
+
+### Check Dependencies
+```bash
+# Show build dependencies
+nix-store -q --references $(nix-build -A package)
+
+# Show runtime dependencies
+nix-store -q --requisites $(nix-build -A package)
+
+# Show dependency tree
+nix-store -q --tree $(nix-build -A package)
+
+# Why is package kept?
+nix-store --query --roots $(nix-build -A package)
+```
+
+### Missing Dependencies
+```bash
+# Check what's needed
+ldd result/bin/program
+
+# Patch with nix
+nix develop -c ldd ./program
+
+# Auto-patch with autoPatchelfHook
+nativeBuildInputs = [ autoPatchelfHook ];
+```
+
+### Wrong Version Built
+```bash
+# Check what will be built
+nix-build '<nixpkgs>' -A package --dry-run
+
+# Check version in store
+nix-store -q --hash $(nix-build -A package)
+
+# Force specific version
+nix build nixpkgs/nixos-23.11#package
+```
+
+## Debugging NixOS Configurations
+
+### Configuration Evaluation
+```bash
+# Build configuration
+nixos-rebuild build --flake .#hostname --show-trace
+
+# Dry build to see what changes
+nixos-rebuild dry-build --flake .#hostname
+
+# Evaluate specific option
+nix eval .#nixosConfigurations.hostname.config.system.stateVersion
+```
+
+### Module Conflicts
+```
+error: The option `services.foo.enable' is defined multiple times
+```
+
+**Debug**:
+```bash
+# Find all definitions
+nix eval .#nixosConfigurations.hostname.options.services.foo.enable.definitionsWithLocations
+
+# Check module imports
+nix eval .#nixosConfigurations.hostname.options._module.args --apply "x: builtins.attrNames x"
+```
+
+### Service Failures
+```bash
+# Check service status after deployment
+systemctl status servicename
+
+# Check service logs
+journalctl -u servicename -n 50
+
+# Check generated config
+systemctl cat servicename
+
+# Verify config file
+cat /etc/systemd/system/servicename.service
+```
+
+## Debugging Flakes
+
+### Flake Evaluation
+```bash
+# Check flake
+nix flake check
+
+# Show flake outputs
+nix flake show
+
+# Evaluate flake metadata
+nix flake metadata
+
+# Lock file issues
+nix flake lock --update-input nixpkgs
+```
+
+### Input Problems
+```bash
+# Check inputs
+nix flake metadata | grep -A 10 Inputs
+
+# Update specific input
+nix flake update nixpkgs
+
+# Show input derivation
+nix flake metadata --json | jq .locks
+```
+
+### Pure Evaluation Errors
+```
+error: access to absolute path '/home/...' is forbidden in pure eval mode
+```
+
+**Fix**:
+```nix
+# Don't use absolute paths
+# Bad
+path = /home/user/file.nix;
+
+# Good
+path = ./file.nix;
+
+# Or use --impure flag (not recommended)
+nix build --impure
+```
+
+## Advanced Debugging
+
+### Debug with nix repl
+```bash
+# Start repl
+nix repl
+
+# Load flake
+:lf .
+
+# Explore outputs
+outputs.packages.x86_64-linux
+
+# Load nixpkgs
+:l <nixpkgs>
+
+# Test expressions
+lib.version
+pkgs.hello
+
+# Tab completion works
+outputs.nixosConf[TAB]
+```
+
+### Profile Evaluation
+```bash
+# Time evaluation
+time nix eval .#package
+
+# Show evaluation statistics
+nix eval .#package --show-stats
+
+# Profile build
+nix build .#package --profile /tmp/profile
+```
+
+### Debug with breakpoints
+```nix
+# In your expression
+value = builtins.break (someExpression);
+
+# Build will pause, entering debugger
+# Commands:
+# :continue - Continue evaluation
+# :quit - Abort evaluation
+# :env - Show environment
+# :value - Show current value
+```
+
+## Common Debug Patterns
+
+### Print and Return
+```nix
+# Debug helper
+debug = msg: val: builtins.trace msg val;
+
+# Usage
+result = debug "Processing ${name}" (processValue value);
+```
+
+### Conditional Debugging
+```nix
+# Only debug when flag is set
+let
+  debugFlag = false;
+  debug = msg: val:
+    if debugFlag
+    then builtins.trace msg val
+    else val;
+in
+  debug "Value" someValue
+```
+
+### Assert Debugging
+```nix
+# Use assertions to catch errors early
+{ ... }:
+
+assert someCondition; {
+  # Your config
+}
+
+# Better with message
+{ lib, ... }:
+
+lib.assertMsg someCondition "Error: condition not met"
+```
+
+## Debugging Tools
+
+### nix-tree
+```bash
+# Install
+nix-shell -p nix-tree
+
+# Explore dependencies interactively
+nix-tree $(nix-build -A package)
+```
+
+### nix-diff
+```bash
+# Compare two derivations
+nix-diff $(nix-build -A package1) $(nix-build -A package2)
+```
+
+### nix-du
+```bash
+# Analyze disk usage
+nix-du -s=500MB
+
+# Show largest paths
+nix-du | head -20
+```
+
+## Debugging Best Practices
+
+1. **Use --show-trace**: Always show full stack traces
+2. **Keep failed builds**: Use `--keep-failed` to inspect
+3. **Enable verbose logs**: Use `-L` flag for build logs
+4. **Use nix repl**: Interactive exploration is powerful
+5. **Check documentation**: Many options have examples
+6. **Test in isolation**: Build packages separately
+7. **Use nix develop**: Debug in build environment
+8. **Check flake.lock**: Ensure inputs are correct
+
+## Emergency Debugging
+
+### System Won't Boot
+```bash
+# Boot to previous generation (at boot menu)
+# Or from rescue system:
+
+# Mount nixos
+mount /dev/sdX /mnt
+mount /dev/sdY /mnt/boot
+
+# Chroot
+nixos-enter
+
+# List generations
+nix-env --list-generations --profile /nix/var/nix/profiles/system
+
+# Rollback
+/nix/var/nix/profiles/system-42-link/bin/switch-to-configuration switch
+```
+
+### Out of Disk Space
+```bash
+# Clean old generations
+nix-collect-garbage -d
+
+# Delete specific generation
+nix-env --delete-generations 10 11 12
+
+# Optimize store
+nix-store --optimize
+
+# Find large paths
+du -sh /nix/store/* | sort -h | tail -20
+```
+
+## Resources
+
+- [Nix Manual - Debugging](https://nixos.org/manual/nix/stable/language/operators.html#debugging)
+- [NixOS Debugging Guide](https://nixos.wiki/wiki/Debugging)
+- [Nix Pills - Debugging](https://nixos.org/guides/nix-pills/debugging.html)

@@ -0,0 +1,507 @@
+# Deploy Workflow
+
+Deploy NixOS configurations safely to local and remote systems.
+
+## When to Use
+
+- "deploy nixos"
+- "nixos-rebuild switch"
+- "deploy to remote host"
+- "update nixos system"
+
+## Quick Commands
+
+### Local Deployment
+```bash
+# Build and switch
+sudo nixos-rebuild switch --flake .
+
+# Build and switch specific host
+sudo nixos-rebuild switch --flake .#hostname
+
+# Test without adding to boot
+sudo nixos-rebuild test --flake .#hostname
+
+# Boot (activate on next reboot)
+sudo nixos-rebuild boot --flake .#hostname
+```
+
+### Remote Deployment
+```bash
+# Deploy to remote host
+nixos-rebuild switch --flake .#remote-host \
+  --target-host user@remote-host \
+  --use-remote-sudo
+
+# Build locally, deploy remotely
+nixos-rebuild switch --flake .#remote-host \
+  --target-host user@remote-host \
+  --build-host localhost
+```
+
+## Safety Protocols
+
+### ALWAYS Ask Before Deploying
+
+**CRITICAL**: Never deploy to remote hosts without explicit user approval.
+
+1. **Show changes first**: Use `git diff` or explain what will be deployed
+2. **Ask for approval**: Get explicit confirmation from user
+3. **Suggest dry-run**: Offer to test build first
+4. **Confirm target**: Make sure user wants to deploy to that specific host
+
+### Pre-Deployment Checks
+```bash
+# 1. Check for uncommitted changes
+git status
+
+# 2. Review what will change
+git diff
+
+# 3. Dry build to verify
+nixos-rebuild dry-build --flake .#hostname
+
+# 4. Build without switching
+nixos-rebuild build --flake .#hostname
+
+# 5. Check for warnings
+nixos-rebuild build --flake .#hostname 2>&1 | grep -i warn
+```
+
+## Local Deployment
+
+### Standard Deployment
+```bash
+# Build and switch
+sudo nixos-rebuild switch --flake .
+
+# With specific flake
+sudo nixos-rebuild switch --flake /path/to/config
+
+# Update flake inputs first
+nix flake update
+sudo nixos-rebuild switch --flake .
+```
+
+### Test Before Committing
+```bash
+# Test configuration without bootloader
+sudo nixos-rebuild test --flake .#hostname
+
+# Test and verify
+systemctl status service-name
+journalctl -u service-name
+
+# If good, make permanent
+sudo nixos-rebuild switch --flake .#hostname
+```
+
+### Boot-Only Deployment
+```bash
+# Activate on next reboot
+sudo nixos-rebuild boot --flake .#hostname
+
+# Reboot when convenient
+sudo reboot
+```
+
+## Remote Deployment
+
+### SSH Setup
+```bash
+# Ensure SSH access
+ssh user@remote-host
+
+# Copy SSH key if needed
+ssh-copy-id user@remote-host
+
+# Test sudo access
+ssh user@remote-host sudo echo OK
+```
+
+### Deploy to Remote
+```bash
+# Full remote deployment
+nixos-rebuild switch --flake .#remote-host \
+  --target-host user@remote-host \
+  --use-remote-sudo
+
+# Build locally, deploy remotely (faster)
+nixos-rebuild switch --flake .#remote-host \
+  --target-host user@remote-host \
+  --build-host localhost \
+  --use-remote-sudo
+```
+
+### Deploy Multiple Hosts
+```bash
+# Deploy to multiple hosts
+for host in host1 host2 host3; do
+  echo "Deploying to $host..."
+  nixos-rebuild switch --flake .#$host \
+    --target-host user@$host \
+    --use-remote-sudo
+done
+```
+
+## Repository-Specific Deployment
+
+### Using Makefile
+```bash
+# Local deployment
+make switch
+
+# Dry build
+make dry-build
+
+# Build without switching
+make build
+
+# Remote deployment (ALWAYS ASK USER FIRST!)
+make host/hostname/switch
+make host/hostname/boot
+make host/hostname/build
+```
+
+### Direct Commands
+```bash
+# Build current system
+sudo nixos-rebuild switch --flake .
+
+# Build specific host
+sudo nixos-rebuild switch --flake .#hostname
+
+# Remote deployment
+nixos-rebuild switch --flake .#hostname \
+  --target-host hostname \
+  --use-remote-sudo
+```
+
+## Deployment Strategies
+
+### Canary Deployment
+```bash
+# 1. Deploy to test host first
+nixos-rebuild switch --flake .#test-host \
+  --target-host test-host \
+  --use-remote-sudo
+
+# 2. Verify it works
+ssh test-host systemctl status critical-service
+
+# 3. If good, deploy to production
+# (ALWAYS ASK USER FIRST!)
+nixos-rebuild switch --flake .#prod-host \
+  --target-host prod-host \
+  --use-remote-sudo
+```
+
+### Rolling Deployment
+```bash
+# Deploy one host at a time
+hosts=(web1 web2 web3)
+
+for host in "${hosts[@]}"; do
+  echo "Deploying to $host..."
+
+  # Deploy
+  nixos-rebuild switch --flake .#$host \
+    --target-host $host \
+    --use-remote-sudo
+
+  # Verify
+  ssh $host systemctl is-active nginx || {
+    echo "ERROR: Deployment to $host failed!"
+    exit 1
+  }
+
+  # Wait before next
+  sleep 30
+done
+```
+
+### Blue-Green Deployment
+```bash
+# Deploy to blue environment
+nixos-rebuild boot --flake .#host-blue \
+  --target-host host-blue \
+  --use-remote-sudo
+
+# Test blue environment
+ssh host-blue 'sudo reboot'
+sleep 60
+# ... test blue ...
+
+# Switch traffic to blue
+# Update load balancer, DNS, etc.
+
+# Deploy to green later
+```
+
+## Rollback Procedures
+
+### Immediate Rollback
+```bash
+# List generations
+sudo nixos-rebuild list-generations
+
+# Rollback to previous
+sudo nixos-rebuild switch --rollback
+
+# Or specific generation
+sudo nixos-rebuild switch --switch-generation 42
+```
+
+### Remote Rollback
+```bash
+# Rollback remote host
+ssh user@remote-host \
+  'sudo nixos-rebuild switch --rollback'
+
+# Or specific generation
+ssh user@remote-host \
+  'sudo nixos-rebuild switch --switch-generation 42'
+```
+
+### Boot Menu Rollback
+```
+# At boot, select previous generation from bootloader menu
+# GRUB or systemd-boot will show all generations
+```
+
+## Monitoring Deployment
+
+### Watch Deployment Progress
+```bash
+# Deploy with verbose output
+sudo nixos-rebuild switch --flake .#hostname --show-trace
+
+# Monitor systemd services
+watch systemctl status
+
+# Monitor logs in another terminal
+journalctl -f
+```
+
+### Verify Deployment
+```bash
+# Check system version
+nixos-version
+
+# Check active generation
+readlink /run/current-system
+
+# Check services
+systemctl --failed
+
+# Check recent journal
+journalctl -p err -b
+```
+
+## Deployment Best Practices
+
+1. **Always test locally first**: Build and test before remote deployment
+2. **Use dry-build**: Preview changes with `dry-build`
+3. **Commit before deploying**: Ensure configuration is tracked
+4. **Deploy during low traffic**: Minimize user impact
+5. **Monitor after deployment**: Check logs and services
+6. **Keep previous generation**: Don't delete immediately
+7. **Test rollback procedure**: Know how to revert
+8. **Document changes**: Note what was deployed and why
+9. **Use boot for risky changes**: Can revert at boot menu
+10. **Ask before remote deployment**: ALWAYS get user approval
+
+## Common Deployment Patterns
+
+### Update and Deploy
+```bash
+# Update flake inputs
+nix flake update
+
+# Review changes
+git diff flake.lock
+
+# Commit update
+git add flake.lock
+git commit -m "chore: update flake inputs"
+
+# Deploy
+sudo nixos-rebuild switch --flake .
+```
+
+### Staged Deployment
+```bash
+# 1. Build configuration
+nixos-rebuild build --flake .#hostname
+
+# 2. Review changes
+nix-diff /run/current-system ./result
+
+# 3. If good, switch
+sudo nixos-rebuild switch --flake .#hostname
+```
+
+### Emergency Deploy
+```bash
+# For urgent fixes, can skip dry-build
+# But still test first!
+
+# Quick build and test
+sudo nixos-rebuild test --flake .#hostname
+
+# If urgent and working
+sudo nixos-rebuild switch --flake .#hostname
+
+# Monitor closely
+journalctl -f
+```
+
+## Troubleshooting Deployments
+
+### Build Failures
+```bash
+# Build fails during deployment
+sudo nixos-rebuild switch --flake .#hostname --show-trace
+
+# Check build logs
+journalctl -u nixos-rebuild -n 100
+
+# Fix configuration
+vim configuration.nix
+
+# Try again
+sudo nixos-rebuild switch --flake .
+```
+
+### Service Failures After Deploy
+```bash
+# Check failed services
+systemctl --failed
+
+# Check service status
+systemctl status service-name
+
+# View logs
+journalctl -u service-name -n 50
+
+# If broken, rollback
+sudo nixos-rebuild switch --rollback
+```
+
+### SSH Connection Lost
+```bash
+# If remote deployment loses connection
+# Wait for deployment to complete
+# Or connect via console/IPMI
+
+# Check if system is accessible
+ping remote-host
+
+# Try to reconnect
+ssh user@remote-host
+
+# If accessible, check status
+ssh user@remote-host systemctl status
+```
+
+### Disk Space Issues
+```bash
+# Clean old generations before deploying
+sudo nix-collect-garbage -d
+
+# Optimize store
+sudo nix-store --optimize
+
+# Check space
+df -h /nix
+```
+
+## Automation
+
+### Automated Deployment Script
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+
+HOST=$1
+
+echo "Deploying to $HOST..."
+
+# Build configuration
+echo "Building..."
+nixos-rebuild build --flake .#$HOST
+
+# Ask for confirmation
+read -p "Deploy to $HOST? [y/N] " -n 1 -r
+echo
+if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+    echo "Deployment cancelled"
+    exit 1
+fi
+
+# Deploy
+echo "Deploying..."
+nixos-rebuild switch --flake .#$HOST \
+  --target-host $HOST \
+  --use-remote-sudo
+
+# Verify
+echo "Verifying..."
+ssh $HOST systemctl is-system-running --wait
+
+echo "Deployment complete!"
+```
+
+### CI/CD Integration
+```bash
+# Example GitHub Actions workflow
+# .github/workflows/deploy.yml
+
+name: Deploy
+on:
+  push:
+    branches: [main]
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: cachix/install-nix-action@v20
+
+      # Build only, don't deploy automatically
+      - name: Build configuration
+        run: nix build .#nixosConfigurations.hostname.config.system.build.toplevel
+
+      # Manual deployment approval required
+```
+
+## Security Considerations
+
+### Secrets in Deployment
+```bash
+# Never deploy with secrets in plain text
+# Use agenix for secrets management
+
+# Secrets are deployed encrypted
+# Decrypted at activation time
+```
+
+### Deployment Authentication
+```bash
+# Use SSH keys, not passwords
+ssh-keygen -t ed25519
+
+# Add to remote host
+ssh-copy-id user@remote-host
+
+# Restrict sudo if needed
+# In /etc/sudoers.d/nixos-rebuild:
+# user ALL=(ALL) NOPASSWD: /run/current-system/sw/bin/nixos-rebuild
+```
+
+## Resources
+
+- [NixOS Deployment](https://nixos.org/manual/nixos/stable/#sec-changing-config)
+- [nixos-rebuild Manual](https://nixos.org/manual/nixos/stable/index.html#sec-nixos-rebuild)
+- [Remote Deployment](https://nixos.wiki/wiki/Nixos-rebuild)

@@ -0,0 +1,626 @@
+# Develop Workflow
+
+Create and use Nix development environments with direnv integration.
+
+## When to Use
+
+- "nix development shell"
+- "nix develop"
+- "development environment"
+- "direnv with nix"
+
+## Quick Commands
+
+### Development Shells
+```bash
+# Enter development shell
+nix develop
+
+# Enter shell for specific package
+nix develop .#package-name
+
+# Run command in shell
+nix develop -c make build
+nix develop --command npm test
+
+# Print shell environment
+nix develop --print-build-logs
+```
+
+### direnv Integration
+```bash
+# Create .envrc
+echo "use flake" > .envrc
+
+# Allow direnv
+direnv allow
+
+# Reload environment
+direnv reload
+
+# Check status
+direnv status
+```
+
+## Creating Development Shells
+
+### Basic devShell
+```nix
+# flake.nix
+{
+  outputs = { self, nixpkgs }: {
+    devShells.x86_64-linux.default = let
+      pkgs = nixpkgs.legacyPackages.x86_64-linux;
+    in pkgs.mkShell {
+      buildInputs = with pkgs; [
+        go
+        gopls
+        golangci-lint
+      ];
+
+      shellHook = ''
+        echo "Welcome to dev environment"
+        go version
+      '';
+    };
+  };
+}
+```
+
+### Multi-Shell Setup
+```nix
+# Multiple development shells
+{
+  outputs = { self, nixpkgs }: {
+    devShells.x86_64-linux = {
+      default = pkgs.mkShell {
+        buildInputs = [ pkgs.go ];
+      };
+
+      rust = pkgs.mkShell {
+        buildInputs = with pkgs; [
+          rustc
+          cargo
+          rust-analyzer
+        ];
+      };
+
+      python = pkgs.mkShell {
+        buildInputs = with pkgs; [
+          python3
+          python3Packages.pip
+        ];
+      };
+    };
+  };
+}
+```
+
+### Access Specific Shell
+```bash
+# Use default shell
+nix develop
+
+# Use named shell
+nix develop .#rust
+nix develop .#python
+```
+
+## Shell Configuration
+
+### Environment Variables
+```nix
+pkgs.mkShell {
+  buildInputs = [ pkgs.go ];
+
+  shellHook = ''
+    export GOPATH=$PWD/.go
+    export GOCACHE=$PWD/.cache/go-build
+    export PATH=$GOPATH/bin:$PATH
+
+    # Create directories
+    mkdir -p $GOPATH $GOCACHE
+  '';
+
+  # Or use env
+  env = {
+    GOPATH = "$PWD/.go";
+    GOCACHE = "$PWD/.cache/go-build";
+  };
+}
+```
+
+### Shell Hooks
+```nix
+pkgs.mkShell {
+  buildInputs = [ pkgs.nodejs ];
+
+  shellHook = ''
+    # Print banner
+    echo "================================"
+    echo "Node.js Development Environment"
+    echo "================================"
+    node --version
+    npm --version
+
+    # Install dependencies
+    if [ ! -d "node_modules" ]; then
+      npm install
+    fi
+
+    # Setup git hooks
+    if [ ! -f ".git/hooks/pre-commit" ]; then
+      echo "Setting up git hooks..."
+      npx husky install
+    fi
+  '';
+}
+```
+
+### Package-Specific Shell
+```nix
+# For a specific package's dev environment
+{
+  outputs = { self, nixpkgs }: {
+    packages.x86_64-linux.myapp = /* package definition */;
+
+    devShells.x86_64-linux.default = let
+      pkgs = nixpkgs.legacyPackages.x86_64-linux;
+    in pkgs.mkShell {
+      # Include all build inputs from package
+      inputsFrom = [ self.packages.x86_64-linux.myapp ];
+
+      # Add development tools
+      buildInputs = with pkgs; [
+        go-tools
+        delve
+        gopls
+      ];
+    };
+  };
+}
+```
+
+## direnv Integration
+
+### Setup direnv
+```bash
+# Install direnv
+nix profile install nixpkgs#direnv
+nix profile install nixpkgs#nix-direnv
+
+# Configure shell (bash)
+eval "$(direnv hook bash)"
+
+# Configure shell (zsh)
+eval "$(direnv hook zsh)"
+```
+
+### Basic .envrc
+```bash
+# .envrc
+use flake
+
+# Optional: Use specific flake output
+# use flake .#rust
+```
+
+### Advanced .envrc
+```bash
+# .envrc
+use flake
+
+# Watch additional files
+watch_file shell.nix
+watch_file flake.nix
+watch_file flake.lock
+
+# Set environment variables
+export EDITOR=vim
+export DATABASE_URL=postgresql://localhost/mydb
+
+# Source local secrets
+if [ -f .env.local ]; then
+  dotenv .env.local
+fi
+
+# Layout for different languages
+# layout python  # Auto-create venv
+# layout node    # Add node_modules/.bin to PATH
+```
+
+### nix-direnv Configuration
+```bash
+# ~/.config/direnv/direnvrc or ~/.direnvrc
+source $HOME/.nix-profile/share/nix-direnv/direnvrc
+
+# Or if installed via home-manager
+# It's automatically configured
+```
+
+### Performance with nix-direnv
+```bash
+# nix-direnv caches the environment
+# Much faster reloads!
+
+# First load (slow)
+$ cd project/
+direnv: loading ~/project/.envrc
+direnv: using flake
+# ... downloads and builds ...
+
+# Subsequent loads (instant!)
+$ cd project/
+direnv: loading ~/project/.envrc
+direnv: using cached flake environment
+```
+
+## Common Development Patterns
+
+### Go Development
+```nix
+{
+  devShells.x86_64-linux.default = pkgs.mkShell {
+    buildInputs = with pkgs; [
+      go
+      gopls
+      gotools
+      golangci-lint
+      delve
+    ];
+
+    shellHook = ''
+      export GOPATH=$PWD/.go
+      export GOCACHE=$PWD/.cache/go-build
+      export PATH=$GOPATH/bin:$PATH
+      mkdir -p $GOPATH $GOCACHE
+    '';
+  };
+}
+```
+
+### Rust Development
+```nix
+{
+  devShells.x86_64-linux.default = pkgs.mkShell {
+    buildInputs = with pkgs; [
+      rustc
+      cargo
+      rustfmt
+      rust-analyzer
+      clippy
+    ];
+
+    RUST_SRC_PATH = "${pkgs.rust.packages.stable.rustPlatform.rustLibSrc}";
+  };
+}
+```
+
+### Node.js Development
+```nix
+{
+  devShells.x86_64-linux.default = pkgs.mkShell {
+    buildInputs = with pkgs; [
+      nodejs_20
+      nodePackages.npm
+      nodePackages.typescript
+      nodePackages.prettier
+    ];
+
+    shellHook = ''
+      export NODE_PATH=$PWD/node_modules
+      export PATH=$PWD/node_modules/.bin:$PATH
+    '';
+  };
+}
+```
+
+### Python Development
+```nix
+{
+  devShells.x86_64-linux.default = let
+    python = pkgs.python3.withPackages (ps: with ps; [
+      flask
+      requests
+      pytest
+    ]);
+  in pkgs.mkShell {
+    buildInputs = [ python ];
+
+    shellHook = ''
+      # Create virtual environment if needed
+      if [ ! -d "venv" ]; then
+        python -m venv venv
+      fi
+      source venv/bin/activate
+    '';
+  };
+}
+```
+
+### C/C++ Development
+```nix
+{
+  devShells.x86_64-linux.default = pkgs.mkShell {
+    buildInputs = with pkgs; [
+      gcc
+      cmake
+      gnumake
+      gdb
+      clang-tools
+    ];
+
+    shellHook = ''
+      export CC=gcc
+      export CXX=g++
+    '';
+  };
+}
+```
+
+## Advanced Shell Features
+
+### Multiple Package Sets
+```nix
+{
+  devShells.x86_64-linux.default = let
+    pkgs = nixpkgs.legacyPackages.x86_64-linux;
+    unstable = inputs.nixpkgs-unstable.legacyPackages.x86_64-linux;
+  in pkgs.mkShell {
+    buildInputs = [
+      pkgs.go             # Stable Go
+      unstable.gopls      # Latest gopls
+    ];
+  };
+}
+```
+
+### Conditional Tools
+```nix
+pkgs.mkShell {
+  buildInputs = with pkgs; [
+    go
+    gopls
+  ] ++ lib.optionals stdenv.isLinux [
+    # Linux-specific tools
+    strace
+    ltrace
+  ] ++ lib.optionals stdenv.isDarwin [
+    # macOS-specific tools
+    darwin.apple_sdk.frameworks.Security
+  ];
+}
+```
+
+### Project-Specific Scripts
+```nix
+pkgs.mkShell {
+  buildInputs = [ pkgs.go ];
+
+  shellHook = ''
+    # Create helper scripts
+    cat > run.sh <<'EOF'
+    #!/usr/bin/env bash
+    go run ./cmd/server
+    EOF
+    chmod +x run.sh
+
+    cat > test.sh <<'EOF'
+    #!/usr/bin/env bash
+    go test ./... -v
+    EOF
+    chmod +x test.sh
+
+    echo "Helper scripts created: run.sh, test.sh"
+  '';
+}
+```
+
+## Development Workflow
+
+### Typical Session
+```bash
+# Enter project
+cd myproject/
+
+# direnv automatically loads environment
+direnv: loading ~/myproject/.envrc
+direnv: using flake
+
+# Environment ready
+go version
+gopls version
+
+# Work on project
+vim main.go
+go build
+go test
+
+# Leave project
+cd ..
+
+# Environment unloaded
+direnv: unloading
+```
+
+### Update Development Environment
+```bash
+# Update flake inputs
+nix flake update
+
+# Reload direnv
+direnv reload
+
+# Or manually re-enter
+nix develop
+```
+
+### Share Environment
+```bash
+# Commit flake.nix and flake.lock
+git add flake.nix flake.lock
+git commit -m "chore: add nix development environment"
+
+# Team members get same environment
+git clone repo
+cd repo
+direnv allow  # Or nix develop
+```
+
+## Troubleshooting
+
+### direnv Not Loading
+```bash
+# Check direnv status
+direnv status
+
+# Manually allow
+direnv allow
+
+# Check .envrc syntax
+cat .envrc
+
+# Test flake
+nix flake check
+```
+
+### Slow Shell Activation
+```bash
+# Install nix-direnv for caching
+nix profile install nixpkgs#nix-direnv
+
+# Configure in ~/.config/direnv/direnvrc
+source $HOME/.nix-profile/share/nix-direnv/direnvrc
+
+# Reload
+direnv reload
+```
+
+### Environment Variables Not Set
+```bash
+# Check environment
+nix develop --command printenv
+
+# Verify shellHook
+nix develop --command bash -c 'echo $MY_VAR'
+
+# Debug direnv
+direnv exec . env | grep MY_VAR
+```
+
+### Binary Cache Issues
+```bash
+# Use substituters
+nix develop --extra-substituters https://cache.nixos.org
+
+# Build locally if needed
+nix develop --no-substitute
+```
+
+## Best Practices
+
+1. **Use direnv**: Automatic environment loading
+2. **Install nix-direnv**: Much faster reloads with caching
+3. **Commit flake.lock**: Ensure reproducibility
+4. **Pin versions**: Use specific nixpkgs inputs
+5. **Minimal dependencies**: Only what's needed for development
+6. **Document setup**: Add README with instructions
+7. **Use inputsFrom**: Inherit from package definitions
+8. **Test environment**: Verify with fresh clone
+
+## Integration with Editors
+
+### VS Code
+```json
+// .vscode/settings.json
+{
+  "nix.enableLanguageServer": true,
+  "nix.serverPath": "nixd"
+}
+```
+
+```bash
+# Install nixd language server in devShell
+buildInputs = [ pkgs.nixd ];
+```
+
+### Vim/Neovim
+```bash
+# Install LSPs in devShell
+buildInputs = with pkgs; [
+  gopls        # Go
+  rust-analyzer # Rust
+  nodePackages.typescript-language-server # TypeScript
+];
+```
+
+### Emacs
+```elisp
+;; direnv integration
+(use-package direnv
+  :config
+  (direnv-mode))
+```
+
+## Common Patterns
+
+### Database Development
+```nix
+pkgs.mkShell {
+  buildInputs = with pkgs; [
+    postgresql
+    pgcli
+  ];
+
+  shellHook = ''
+    export PGDATA=$PWD/.postgres
+    export PGHOST=$PWD/.postgres
+    export PGDATABASE=mydb
+
+    if [ ! -d "$PGDATA" ]; then
+      initdb --no-locale --encoding=UTF8
+      echo "unix_socket_directories = '$PGHOST'" >> $PGDATA/postgresql.conf
+      pg_ctl start -l $PGDATA/logfile
+      createdb $PGDATABASE
+    else
+      pg_ctl start -l $PGDATA/logfile
+    fi
+  '';
+}
+```
+
+### Docker Development
+```nix
+pkgs.mkShell {
+  buildInputs = with pkgs; [
+    docker
+    docker-compose
+  ];
+
+  shellHook = ''
+    export DOCKER_HOST=unix://$XDG_RUNTIME_DIR/docker.sock
+  '';
+}
+```
+
+### Multiple Environments
+```bash
+# .envrc
+# Choose environment based on directory
+if [ -f "Cargo.toml" ]; then
+  use flake .#rust
+elif [ -f "go.mod" ]; then
+  use flake .#go
+elif [ -f "package.json" ]; then
+  use flake .#node
+else
+  use flake
+fi
+```
+
+## Resources
+
+- [nix develop Manual](https://nixos.org/manual/nix/stable/command-ref/new-cli/nix3-develop.html)
+- [direnv Documentation](https://direnv.net/)
+- [nix-direnv](https://github.com/nix-community/nix-direnv)
+- [Development Environments](https://nixos.wiki/wiki/Development_environment_with_nix-shell)