fix: bunch of vibed edits to fix vibed edits

5 files changed, 365 insertions, 365 deletions

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 7173170..5084164 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -4,7 +4,7 @@ title: contributing guide
 
 # contributing to ubergeek
 
-ubergeek is a community study guide. Contributions are welcome — fixes,
+ubergeek is a community study guide. Contributions are welcome: fixes,
 improvements, new exercises, better explanations, and sample projects.
 
 The primary repository lives on **sourcehut** and is mirrored to GitHub and
@@ -14,13 +14,13 @@ GitLab. You can contribute from any platform.
 
 ## Ways to Contribute
 
-- **Fix errors** — typos, incorrect information, broken examples
-- **Improve explanations** — clearer wording, better analogies, added context
-- **Add exercises and projects** — practice problems, mini-projects, challenge sets
-- **Add sample code** — working examples in any of the covered languages
-- **Add diagrams and images** — ASCII art, schematics, architecture diagrams
-- **Review existing content** — flag sections that are confusing or incomplete
-- **Suggest new topics or modules** — open a discussion first
+- **Fix errors**: typos, incorrect information, broken examples
+- **Improve explanations**: clearer wording, better analogies, added context
+- **Add exercises and projects**: practice problems, mini-projects, challenge sets
+- **Add sample code**: working examples in any of the covered languages
+- **Add diagrams and images**: ASCII art, schematics, architecture diagrams
+- **Review existing content**: flag sections that are confusing or incomplete
+- **Suggest new topics or modules**: open a discussion first
 
 ---
 
@@ -50,14 +50,14 @@ topic-name/
 ## Content Style Guide
 
 ### Tone
-- Direct and practical — teach by showing, not lecturing
+- Direct and practical: teach by showing, not lecturing
 - Assume intelligence, not prior knowledge
 - Use "you" not "the student" or "one"
 
 ### Structure
 - Every page starts with frontmatter (`title` required)
 - Open with a short paragraph explaining what and why
-- Use code blocks liberally — real, runnable examples
+- Use code blocks liberally: real, runnable examples
 - End modules with exercises (drill, challenges, mini-project)
 - End with key takeaways and a "Next" link
 
@@ -154,7 +154,7 @@ git push origin fix-typo-shell-basics
 ```
 
 ### PR/MR Guidelines
-- Keep PRs focused — one fix or one module per PR
+- Keep PRs focused: one fix or one module per PR
 - Write a clear description of what you changed and why
 - If adding a new module, open an issue first to discuss scope
 
@@ -164,12 +164,12 @@ git push origin fix-typo-shell-basics
 
 When adding to `samples/`:
 
-- **Must compile/run out of the box** — include a Makefile, requirements.txt,
+- **Must compile/run out of the box**: include a Makefile, requirements.txt,
   Cargo.toml, or whatever the project needs
-- **Include a README.md** — what it does, how to build, how to run, expected output
-- **Keep it minimal** — demonstrate the concept, nothing more
-- **Pin dependencies** where practical — don't rely on "latest"
-- **Test on Linux** — that's the primary platform for this guide
+- **Include a README.md**: what it does, how to build, how to run, expected output
+- **Keep it minimal**: demonstrate the concept, nothing more
+- **Pin dependencies** where practical: don't rely on "latest"
+- **Test on Linux**: that's the primary platform for this guide
 
 ### KiCad / Hardware Projects
 
@@ -189,13 +189,13 @@ When adding to `samples/`:
 ```
 
 Types:
-- `content` — new or updated study material
-- `fix` — corrections to existing content
-- `exercises` — new or updated exercises
-- `samples` — new or updated sample code/projects
-- `images` — new or updated diagrams/images
-- `meta` — PROGRESS.md, CONTRIBUTING.md, index.md, study-plan.md
-- `infra` — CI, build scripts, tooling
+- `content`: new or updated study material
+- `fix`: corrections to existing content
+- `exercises`: new or updated exercises
+- `samples`: new or updated sample code/projects
+- `images`: new or updated diagrams/images
+- `meta`: PROGRESS.md, CONTRIBUTING.md, index.md, study-plan.md
+- `infra`: CI, build scripts, tooling
 
 Examples:
 ```
@@ -211,7 +211,7 @@ samples: add bare-metal blinky project for STM32F4
 
 1. All contributions are reviewed before merging
 2. Content accuracy is the top priority
-3. Style and formatting can be fixed post-merge — don't let it block good content
+3. Style and formatting can be fixed post-merge; don't let it block good content
 4. Disagreements are resolved by discussion, not authority
 
 ---
diff --git a/LICENSE.md b/LICENSE.md
index c78c9c0..d9c0009 100644
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -2,7 +2,7 @@
 
 This project uses a dual-license model.
 
-## Content — CC BY-SA 4.0
+## Content: CC BY-SA 4.0
 
 All written content, documentation, exercises, images, and diagrams are
 licensed under the
@@ -13,7 +13,7 @@ You are free to share and adapt the material for any purpose, including
 commercially, as long as you give credit and distribute derivative works under
 the same license.
 
-## Code Samples — MIT
+## Code Samples: MIT
 
 All code in `samples/` directories throughout the repository is licensed under
 the [MIT License](LICENSES/MIT).
diff --git a/PROGRESS.md b/PROGRESS.md
index abb0cfb..02cf05d 100644
--- a/PROGRESS.md
+++ b/PROGRESS.md
@@ -1,5 +1,5 @@
 ---
-title: ubergeek study guide — progress tracker
+title: ubergeek study guide: progress tracker
 ---
 
 # ubergeek study guide
@@ -7,17 +7,17 @@ title: ubergeek study guide — progress tracker
 Master progress tracker and study plan. Single source of truth.
 
 **Legend:**
-- `[ ]` Module Name — not started
-- `[ ]` *wip* Module Name — in progress
-- `[x]` [Module Name](path/to/module/) — complete (linked)
-- *skip* — skippable for fast-track learners
+- `[ ]` Module Name: not started
+- `[ ]` *wip* Module Name: in progress
+- `[x]` [Module Name](path/to/module/): complete (linked)
+- *skip*: skippable for fast-track learners
 
 ---
 
 ## Study Path
 
 Phases are sequential but topics within a phase can be studied in parallel.
-Prerequisites are noted — you can jump ahead if you already know the prereqs.
+Prerequisites are noted: you can jump ahead if you already know the prereqs.
 
 | Phase | Focus | Topics | Prereqs |
 |-------|-------|--------|---------|
@@ -34,475 +34,475 @@ Prerequisites are noted — you can jump ahead if you already know the prereqs.
 
 ---
 
-## Phase 1 — Toolkit & Literacy
+## Phase 1: Toolkit & Literacy
 
 ### 1.1 Linux Command Line Tools
 `path: linux-command-line/`
 > Prereqs: None
 
-- [ ] Shell Basics — navigation, file ops, permissions, pipes, redirection, man pages
-- [ ] File Management — find, locate, tar, rsync, ln, file, stat, du, df
-- [ ] Text Processing — grep, sed, awk, cut, sort, uniq, tr, wc, jq, yq
-- [ ] Process Management — ps, top/htop, kill, nice, nohup, jobs, bg/fg, screen/tmux
-- [ ] Networking — ssh, curl, wget, netstat/ss, ip, dig, nmap, nc, scp/sftp
-- [ ] System Administration — systemctl, journalctl, cron, users/groups, disk mgmt, mount
-- [ ] Advanced Shell — parameter expansion, process substitution, subshells, traps, here-docs
-- [ ] Power Tools — fzf, ripgrep, fd, bat, eza, delta, zoxide, direnv
-- [ ] *skip* Customization — shell config, aliases, functions, prompt, dotfiles management
-- [ ] Exercises & Projects — system monitor, backup script, log analyzer, file organizer
+- [ ] Shell Basics: navigation, file ops, permissions, pipes, redirection, man pages
+- [ ] File Management: find, locate, tar, rsync, ln, file, stat, du, df
+- [ ] Text Processing: grep, sed, awk, cut, sort, uniq, tr, wc, jq, yq
+- [ ] Process Management: ps, top/htop, kill, nice, nohup, jobs, bg/fg, screen/tmux
+- [ ] Networking: ssh, curl, wget, netstat/ss, ip, dig, nmap, nc, scp/sftp
+- [ ] System Administration: systemctl, journalctl, cron, users/groups, disk mgmt, mount
+- [ ] Advanced Shell: parameter expansion, process substitution, subshells, traps, here-docs
+- [ ] Power Tools: fzf, ripgrep, fd, bat, eza, delta, zoxide, direnv
+- [ ] *skip* Customization: shell config, aliases, functions, prompt, dotfiles management
+- [ ] Exercises & Projects: system monitor, backup script, log analyzer, file organizer
 
 ### 1.2 Git
 `path: git/`
 > Prereqs: Command Line basics
 
-- [ ] Fundamentals — init, add, commit, status, log, diff, .gitignore
-- [ ] Branching & Merging — branches, merge, fast-forward, merge conflicts
-- [ ] Remote Collaboration — remotes, push, pull, fetch, clone, PRs, patches (email workflow)
-- [ ] Advanced Operations — rebase, cherry-pick, bisect, reflog, stash, worktrees
-- [ ] Internals — objects (blob/tree/commit/tag), refs, packfiles, how Git works
-- [ ] Workflows & Strategies — feature branches, Git Flow, trunk-based, monorepo, submodules
-- [ ] Hooks & Automation — pre-commit, commit-msg, CI integration, custom hooks
-- [ ] *skip* Sourcehut-Specific — sr.ht workflows, mailing list patches, builds.sr.ht
-- [ ] Exercises & Projects — contribute a patch, manage a multi-branch project, write custom hooks
+- [ ] Fundamentals: init, add, commit, status, log, diff, .gitignore
+- [ ] Branching & Merging: branches, merge, fast-forward, merge conflicts
+- [ ] Remote Collaboration: remotes, push, pull, fetch, clone, PRs, patches (email workflow)
+- [ ] Advanced Operations: rebase, cherry-pick, bisect, reflog, stash, worktrees
+- [ ] Internals: objects (blob/tree/commit/tag), refs, packfiles, how Git works
+- [ ] Workflows & Strategies: feature branches, Git Flow, trunk-based, monorepo, submodules
+- [ ] Hooks & Automation: pre-commit, commit-msg, CI integration, custom hooks
+- [ ] *skip* Sourcehut-Specific: sr.ht workflows, mailing list patches, builds.sr.ht
+- [ ] Exercises & Projects: contribute a patch, manage a multi-branch project, write custom hooks
 
 ### 1.3 Technical Writing & Research Methodologies
 `path: technical-writing/`
 > Prereqs: None
 
-- [ ] Writing Fundamentals — clarity, structure, audience analysis, active voice, style guides
-- [ ] Technical Documentation — API docs, user guides, READMEs, changelogs, man pages
-- [ ] Research Methodology — literature review, hypothesis, experimental design, data collection
-- [ ] Data Presentation — tables, charts, statistical visualization, LaTeX/typst basics
-- [ ] *skip* Academic Writing — papers, citations, abstracts, peer review process
-- [ ] Documentation Tools — Markdown, AsciiDoc, Sphinx, Doxygen, mdBook
-- [ ] Exercises & Projects — write a project README, document an API, create a lab report
+- [ ] Writing Fundamentals: clarity, structure, audience analysis, active voice, style guides
+- [ ] Technical Documentation: API docs, user guides, READMEs, changelogs, man pages
+- [ ] Research Methodology: literature review, hypothesis, experimental design, data collection
+- [ ] Data Presentation: tables, charts, statistical visualization, LaTeX/typst basics
+- [ ] *skip* Academic Writing: papers, citations, abstracts, peer review process
+- [ ] Documentation Tools: Markdown, AsciiDoc, Sphinx, Doxygen, mdBook
+- [ ] Exercises & Projects: write a project README, document an API, create a lab report
 
 ### 1.4 Programming Fundamentals
 `path: programming/fundamentals/`
 > Prereqs: Command Line basics
 
-- [ ] Core Concepts — variables, types, expressions, control flow (all languages compared)
-- [ ] Functions & Modularity — functions, scope, recursion, modules/packages
-- [ ] Data Structures (language-level) — arrays, strings, hash maps, structs/classes
-- [ ] I/O & File Handling — stdin/stdout, file read/write, serialization (JSON, TOML, CSV)
-- [ ] Error Handling — exceptions, return codes, Result/Option types (cross-language comparison)
-- [ ] Memory Models — stack vs heap, value vs reference, ownership overview
-- [ ] Build & Run — compilers, interpreters, REPLs, build systems, package managers
-- [ ] Testing Basics — unit tests, assertions, test frameworks per language
-- [ ] Exercises & Projects — CLI calculator, file processor, multi-language Rosetta Stone set
+- [ ] Core Concepts: variables, types, expressions, control flow (all languages compared)
+- [ ] Functions & Modularity: functions, scope, recursion, modules/packages
+- [ ] Data Structures (language-level): arrays, strings, hash maps, structs/classes
+- [ ] I/O & File Handling: stdin/stdout, file read/write, serialization (JSON, TOML, CSV)
+- [ ] Error Handling: exceptions, return codes, Result/Option types (cross-language comparison)
+- [ ] Memory Models: stack vs heap, value vs reference, ownership overview
+- [ ] Build & Run: compilers, interpreters, REPLs, build systems, package managers
+- [ ] Testing Basics: unit tests, assertions, test frameworks per language
+- [ ] Exercises & Projects: CLI calculator, file processor, multi-language Rosetta Stone set
 
 ### 1.5 C
 `path: programming/c/`
 > Prereqs: Programming Fundamentals
 
-- [ ] C Basics — syntax, types, printf/scanf, compilation with gcc/clang
-- [ ] Pointers & Memory — pointer arithmetic, malloc/free, arrays vs pointers, void pointers
-- [ ] Strings & Arrays — C strings, buffer safety, multi-dimensional arrays
-- [ ] Structs & Unions — struct layout, padding/alignment, bit fields, tagged unions
-- [ ] Preprocessor — macros, conditional compilation, include guards, X-macros
-- [ ] Standard Library — stdio, stdlib, string.h, math.h, time.h, errno
-- [ ] File I/O & System Calls — fopen/fread, open/read/write, mmap, ioctl
-- [ ] Build Systems — Makefiles for C, static/shared libraries, linking, pkg-config
-- [ ] Debugging & Profiling — gdb, valgrind, sanitizers (ASan/UBSan), perf
-- [ ] Advanced C — function pointers, callbacks, opaque types, C11/C17/C23 features
-- [ ] Exercises & Projects — memory allocator, linked list library, simple shell, file parser
+- [ ] C Basics: syntax, types, printf/scanf, compilation with gcc/clang
+- [ ] Pointers & Memory: pointer arithmetic, malloc/free, arrays vs pointers, void pointers
+- [ ] Strings & Arrays: C strings, buffer safety, multi-dimensional arrays
+- [ ] Structs & Unions: struct layout, padding/alignment, bit fields, tagged unions
+- [ ] Preprocessor: macros, conditional compilation, include guards, X-macros
+- [ ] Standard Library: stdio, stdlib, string.h, math.h, time.h, errno
+- [ ] File I/O & System Calls: fopen/fread, open/read/write, mmap, ioctl
+- [ ] Build Systems: Makefiles for C, static/shared libraries, linking, pkg-config
+- [ ] Debugging & Profiling: gdb, valgrind, sanitizers (ASan/UBSan), perf
+- [ ] Advanced C: function pointers, callbacks, opaque types, C11/C17/C23 features
+- [ ] Exercises & Projects: memory allocator, linked list library, simple shell, file parser
 
 ### 1.6 Python
 `path: programming/python/`
 > Prereqs: Programming Fundamentals
 
-- [ ] Python Basics — syntax, types, REPL, scripts, pip, virtual environments (venv, uv)
-- [ ] Data Structures — lists, tuples, dicts, sets, comprehensions, slicing, unpacking
-- [ ] Functions & Modules — def, *args/**kwargs, lambda, imports, packages, \_\_name\_\_
-- [ ] OOP — classes, inheritance, dunder methods, properties, dataclasses, protocols
-- [ ] Error Handling — exceptions, try/except/finally, custom exceptions, context managers
-- [ ] File I/O & Data — file ops, pathlib, JSON, CSV, TOML, regex, struct/binary
-- [ ] Standard Library — os, sys, subprocess, collections, itertools, functools, logging, argparse
-- [ ] Testing — pytest, unittest, mocking, fixtures, parametrize, coverage
-- [ ] Scientific Stack Intro — NumPy basics, Matplotlib, pandas intro, Jupyter notebooks
-- [ ] Exercises & Projects — CLI tool, web scraper, data pipeline, test suite for a library
+- [ ] Python Basics: syntax, types, REPL, scripts, pip, virtual environments (venv, uv)
+- [ ] Data Structures: lists, tuples, dicts, sets, comprehensions, slicing, unpacking
+- [ ] Functions & Modules: def, *args/**kwargs, lambda, imports, packages, \_\_name\_\_
+- [ ] OOP: classes, inheritance, dunder methods, properties, dataclasses, protocols
+- [ ] Error Handling: exceptions, try/except/finally, custom exceptions, context managers
+- [ ] File I/O & Data: file ops, pathlib, JSON, CSV, TOML, regex, struct/binary
+- [ ] Standard Library: os, sys, subprocess, collections, itertools, functools, logging, argparse
+- [ ] Testing: pytest, unittest, mocking, fixtures, parametrize, coverage
+- [ ] Scientific Stack Intro: NumPy basics, Matplotlib, pandas intro, Jupyter notebooks
+- [ ] Exercises & Projects: CLI tool, web scraper, data pipeline, test suite for a library
 
 ### 1.7 Bash Scripting
 `path: programming/bash/`
 > Prereqs: Command Line Tools
 
-- [ ] Script Basics — shebang, variables, quoting, exit codes, set options (-euo pipefail)
-- [ ] Control Flow — if/elif/else, case, for, while, until, select
-- [ ] Functions — definition, local variables, return values, passing arguments
-- [ ] Text Processing in Scripts — grep/sed/awk integration, regex, here-docs/here-strings
-- [ ] Process & Job Control — subshells, command substitution, pipe chains, xargs, parallel
-- [ ] Advanced Patterns — signal handling (trap), getopts, associative arrays, nameref
-- [ ] Script Packaging — argument parsing, help messages, config files, logging, color output
-- [ ] Exercises & Projects — deployment script, system health checker, interactive menu tool
+- [ ] Script Basics: shebang, variables, quoting, exit codes, set options (-euo pipefail)
+- [ ] Control Flow: if/elif/else, case, for, while, until, select
+- [ ] Functions: definition, local variables, return values, passing arguments
+- [ ] Text Processing in Scripts: grep/sed/awk integration, regex, here-docs/here-strings
+- [ ] Process & Job Control: subshells, command substitution, pipe chains, xargs, parallel
+- [ ] Advanced Patterns: signal handling (trap), getopts, associative arrays, nameref
+- [ ] Script Packaging: argument parsing, help messages, config files, logging, color output
+- [ ] Exercises & Projects: deployment script, system health checker, interactive menu tool
 
 ### 1.8 Mathematics Foundations
 `path: mathematics/`
 > Prereqs: None (high school math assumed)
 
-- [ ] Logic & Proofs — propositional logic, predicate logic, proof techniques, set theory
-- [ ] Number Systems — integers, rationals, reals, complex numbers, modular arithmetic
-- [ ] Linear Algebra — vectors, matrices, systems of equations, determinants, eigenvalues
-- [ ] Calculus I — limits, derivatives, integrals, fundamental theorem
-- [ ] Calculus II — techniques of integration, sequences, series, Taylor/Maclaurin
-- [ ] Multivariable Calculus — partial derivatives, gradients, multiple integrals, vector fields
-- [ ] Differential Equations — first/second order ODEs, Laplace transforms, systems of ODEs
-- [ ] Probability & Statistics — combinatorics, probability theory, distributions, inference, Bayes
-- [ ] Discrete Mathematics — graph theory, combinatorics, recurrences, number theory basics
-- [ ] *skip* Numerical Methods — root finding, interpolation, numerical integration, optimization
-- [ ] *skip* Transform Methods — Fourier series/transform, Z-transform, DFT/FFT
-- [ ] Exercises & Projects — problem sets per module, computational exercises (Python/Julia)
+- [ ] Logic & Proofs: propositional logic, predicate logic, proof techniques, set theory
+- [ ] Number Systems: integers, rationals, reals, complex numbers, modular arithmetic
+- [ ] Linear Algebra: vectors, matrices, systems of equations, determinants, eigenvalues
+- [ ] Calculus I: limits, derivatives, integrals, fundamental theorem
+- [ ] Calculus II: techniques of integration, sequences, series, Taylor/Maclaurin
+- [ ] Multivariable Calculus: partial derivatives, gradients, multiple integrals, vector fields
+- [ ] Differential Equations: first/second order ODEs, Laplace transforms, systems of ODEs
+- [ ] Probability & Statistics: combinatorics, probability theory, distributions, inference, Bayes
+- [ ] Discrete Mathematics: graph theory, combinatorics, recurrences, number theory basics
+- [ ] *skip* Numerical Methods: root finding, interpolation, numerical integration, optimization
+- [ ] *skip* Transform Methods: Fourier series/transform, Z-transform, DFT/FFT
+- [ ] Exercises & Projects: problem sets per module, computational exercises (Python/Julia)
 
 ---
 
-## Phase 2 — Core Theory
+## Phase 2: Core Theory
 
 ### 2.1 Computer Science
 `path: computer-science/`
 > Prereqs: Programming Fundamentals, Math (discrete math, logic)
 
-- [ ] Data Structures — arrays, linked lists, stacks, queues, trees, heaps, graphs, hash tables
-- [ ] Algorithms — sorting, searching, graph algorithms (BFS/DFS/Dijkstra), recursion
-- [ ] Algorithm Design — divide & conquer, dynamic programming, greedy, backtracking
-- [ ] Complexity Theory — Big-O/Omega/Theta, amortized analysis, P vs NP, reductions
-- [ ] Computer Architecture — CPU design, instruction sets, pipelining, caches, memory hierarchy
-- [ ] Networking — OSI model, TCP/IP, DNS, HTTP/HTTPS, sockets, routing
-- [ ] Databases — relational model, SQL, normalization, indexing, transactions, NoSQL overview
-- [ ] *skip* Compilers — lexing, parsing, ASTs, semantic analysis, code generation
-- [ ] *skip* Distributed Systems — CAP theorem, consensus, replication, consistency models
-- [ ] Exercises & Projects — implement core data structures (C + Python + Rust), solve algorithm sets
+- [ ] Data Structures: arrays, linked lists, stacks, queues, trees, heaps, graphs, hash tables
+- [ ] Algorithms: sorting, searching, graph algorithms (BFS/DFS/Dijkstra), recursion
+- [ ] Algorithm Design: divide & conquer, dynamic programming, greedy, backtracking
+- [ ] Complexity Theory: Big-O/Omega/Theta, amortized analysis, P vs NP, reductions
+- [ ] Computer Architecture: CPU design, instruction sets, pipelining, caches, memory hierarchy
+- [ ] Networking: OSI model, TCP/IP, DNS, HTTP/HTTPS, sockets, routing
+- [ ] Databases: relational model, SQL, normalization, indexing, transactions, NoSQL overview
+- [ ] *skip* Compilers: lexing, parsing, ASTs, semantic analysis, code generation
+- [ ] *skip* Distributed Systems: CAP theorem, consensus, replication, consistency models
+- [ ] Exercises & Projects: implement core data structures (C + Python + Rust), solve algorithm sets
 
 ### 2.2 Electronics
 `path: electronics/`
 > Prereqs: Math (calculus, linear algebra, complex numbers)
 
-- [ ] Circuit Fundamentals — voltage, current, resistance, power, Ohm's/Kirchhoff's laws
-- [ ] DC Circuit Analysis — node/mesh analysis, Thevenin/Norton, superposition
-- [ ] AC Circuits — phasors, impedance, resonance, frequency response, Bode plots
-- [ ] Passive Components — resistors, capacitors, inductors, transformers, practical specs
-- [ ] Diodes & Rectifiers — PN junction, diode types, rectifier circuits, voltage regulators
-- [ ] Transistors (BJT) — operation, biasing, small-signal models, amplifier configurations
-- [ ] Transistors (MOSFET) — operation, biasing, CMOS logic, switching applications
-- [ ] Op-Amps — ideal model, inverting/non-inverting, integrator/differentiator, active filters
-- [ ] Digital Electronics — logic gates, Boolean algebra, combinational circuits, sequential (flip-flops, counters)
-- [ ] Sensors & Measurement — common sensors (temp, light, force, IMU), signal conditioning, ADC/DAC
-- [ ] Power Electronics — linear regulators, switching converters (buck/boost), battery charging
-- [ ] *skip* RF Basics — transmission lines, impedance matching, modulation, antenna fundamentals
-- [ ] Exercises & Projects — voltage divider lab, amplifier design, logic circuit build, sensor interface
+- [ ] Circuit Fundamentals: voltage, current, resistance, power, Ohm's/Kirchhoff's laws
+- [ ] DC Circuit Analysis: node/mesh analysis, Thevenin/Norton, superposition
+- [ ] AC Circuits: phasors, impedance, resonance, frequency response, Bode plots
+- [ ] Passive Components: resistors, capacitors, inductors, transformers, practical specs
+- [ ] Diodes & Rectifiers: PN junction, diode types, rectifier circuits, voltage regulators
+- [ ] Transistors (BJT): operation, biasing, small-signal models, amplifier configurations
+- [ ] Transistors (MOSFET): operation, biasing, CMOS logic, switching applications
+- [ ] Op-Amps: ideal model, inverting/non-inverting, integrator/differentiator, active filters
+- [ ] Digital Electronics: logic gates, Boolean algebra, combinational circuits, sequential (flip-flops, counters)
+- [ ] Sensors & Measurement: common sensors (temp, light, force, IMU), signal conditioning, ADC/DAC
+- [ ] Power Electronics: linear regulators, switching converters (buck/boost), battery charging
+- [ ] *skip* RF Basics: transmission lines, impedance matching, modulation, antenna fundamentals
+- [ ] Exercises & Projects: voltage divider lab, amplifier design, logic circuit build, sensor interface
 
 ### 2.3 Make & Dev Automation
 `path: make-and-automation/`
 > Prereqs: Command Line, Git, Programming (C or any compiled language)
 
-- [ ] Make Basics — targets, prerequisites, recipes, variables, automatic variables, phony targets
-- [ ] Advanced Make — pattern rules, functions, conditional directives, auto-dependencies, recursive vs non-recursive
-- [ ] CMake — CMakeLists.txt, targets, find_package, generator expressions, modern CMake idioms
-- [ ] *skip* Meson — build definitions, dependencies, cross-compilation, wraps
-- [ ] Task Runners — Justfile, Taskfile, npm scripts, Python invoke, cargo-make
-- [ ] Dev Containers — Dockerfiles for dev, devcontainer spec, reproducible environments
-- [ ] *skip* Documentation Generation — Doxygen, Sphinx autodoc, mdBook, man page generation
-- [ ] Exercises & Projects — multi-target C Makefile, CMake project with libraries, polyglot build system
+- [ ] Make Basics: targets, prerequisites, recipes, variables, automatic variables, phony targets
+- [ ] Advanced Make: pattern rules, functions, conditional directives, auto-dependencies, recursive vs non-recursive
+- [ ] CMake: CMakeLists.txt, targets, find_package, generator expressions, modern CMake idioms
+- [ ] *skip* Meson: build definitions, dependencies, cross-compilation, wraps
+- [ ] Task Runners: Justfile, Taskfile, npm scripts, Python invoke, cargo-make
+- [ ] Dev Containers: Dockerfiles for dev, devcontainer spec, reproducible environments
+- [ ] *skip* Documentation Generation: Doxygen, Sphinx autodoc, mdBook, man page generation
+- [ ] Exercises & Projects: multi-target C Makefile, CMake project with libraries, polyglot build system
 
 ---
 
-## Phase 3 — Systems & Design
+## Phase 3: Systems & Design
 
 ### 3.1 Operating Systems
 `path: operating-systems/`
 > Prereqs: CS (architecture, data structures), C, Math (basic)
 
-- [ ] Introduction — OS role, history, types, system calls, kernel vs userspace
-- [ ] Process Management — processes, threads, context switching, scheduling algorithms
-- [ ] Synchronization — race conditions, mutexes, semaphores, deadlocks, condition variables
-- [ ] Memory Management — virtual memory, paging, segmentation, page replacement, TLB
-- [ ] File Systems — VFS, inodes, ext4, FAT, journaling, directory structures
-- [ ] I/O & Devices — device drivers model, block vs character, DMA, interrupt handling
-- [ ] IPC — pipes, shared memory, message queues, signals, sockets
-- [ ] Networking in OS — socket API, TCP/IP stack, network drivers, netfilter
-- [ ] Security & Protection — access control, capabilities, namespaces, cgroups, sandboxing
-- [ ] *skip* Virtualization — hypervisors (type 1/2), containers, paravirtualization, KVM
-- [ ] Exercises & Projects — system call tracer, simple scheduler simulation, xv6 labs
+- [ ] Introduction: OS role, history, types, system calls, kernel vs userspace
+- [ ] Process Management: processes, threads, context switching, scheduling algorithms
+- [ ] Synchronization: race conditions, mutexes, semaphores, deadlocks, condition variables
+- [ ] Memory Management: virtual memory, paging, segmentation, page replacement, TLB
+- [ ] File Systems: VFS, inodes, ext4, FAT, journaling, directory structures
+- [ ] I/O & Devices: device drivers model, block vs character, DMA, interrupt handling
+- [ ] IPC: pipes, shared memory, message queues, signals, sockets
+- [ ] Networking in OS: socket API, TCP/IP stack, network drivers, netfilter
+- [ ] Security & Protection: access control, capabilities, namespaces, cgroups, sandboxing
+- [ ] *skip* Virtualization: hypervisors (type 1/2), containers, paravirtualization, KVM
+- [ ] Exercises & Projects: system call tracer, simple scheduler simulation, xv6 labs
 
 ### 3.2 PCB Design
 `path: pcb-design/`
 > Prereqs: Electronics (all fundamentals)
 
-- [ ] Fundamentals — schematic capture workflow, EDA tools overview (KiCad focus), libraries
-- [ ] Component Selection — reading datasheets, footprints, sourcing, lifecycle management
-- [ ] Schematic Design — hierarchical sheets, power symbols, net labels, design review checklist
-- [ ] PCB Layout Basics — board outline, stackup, component placement strategy, routing basics
-- [ ] Routing — trace width, via types, differential pairs, length matching, copper pours
-- [ ] Power Distribution — PDN design, decoupling strategy, thermal management, power planes
-- [ ] Signal Integrity — impedance control, crosstalk, EMI/EMC basics, ground planes
-- [ ] *skip* High-Speed Design — controlled impedance, return paths, high-speed routing rules
-- [ ] Design for Manufacturing — DFM/DFA rules, panelization, assembly drawings, BOM management
-- [ ] Exercises & Projects — LED breakout board, sensor board (2-layer), power supply board (4-layer)
+- [ ] Fundamentals: schematic capture workflow, EDA tools overview (KiCad focus), libraries
+- [ ] Component Selection: reading datasheets, footprints, sourcing, lifecycle management
+- [ ] Schematic Design: hierarchical sheets, power symbols, net labels, design review checklist
+- [ ] PCB Layout Basics: board outline, stackup, component placement strategy, routing basics
+- [ ] Routing: trace width, via types, differential pairs, length matching, copper pours
+- [ ] Power Distribution: PDN design, decoupling strategy, thermal management, power planes
+- [ ] Signal Integrity: impedance control, crosstalk, EMI/EMC basics, ground planes
+- [ ] *skip* High-Speed Design: controlled impedance, return paths, high-speed routing rules
+- [ ] Design for Manufacturing: DFM/DFA rules, panelization, assembly drawings, BOM management
+- [ ] Exercises & Projects: LED breakout board, sensor board (2-layer), power supply board (4-layer)
 
 ### 3.3 Web Technologies
 `path: web-technologies/`
 > Prereqs: CS (networking, databases), Programming (Python or JS)
 
-- [ ] HTML & CSS — semantic HTML5, CSS layout (flexbox, grid), responsive design, accessibility
-- [ ] JavaScript — ES6+, DOM manipulation, events, async/await, modules, fetch API
-- [ ] Backend Fundamentals — HTTP protocol, REST API design, authentication/authorization
-- [ ] Server-Side Development — Python (Flask/FastAPI), Node.js (Express), API development
-- [ ] Databases for Web — SQL (PostgreSQL), ORM concepts, migrations, Redis caching
-- [ ] *skip* Frontend Frameworks — component architecture, state management, SPA vs MPA concepts
-- [ ] DevOps for Web — Docker, reverse proxies (nginx), TLS, CI/CD, deployment strategies
-- [ ] Security — XSS, CSRF, CSP, SQL injection prevention, CORS, HTTPS
-- [ ] Exercises & Projects — static site, REST API with database, full-stack CRUD app
+- [ ] HTML & CSS: semantic HTML5, CSS layout (flexbox, grid), responsive design, accessibility
+- [ ] JavaScript: ES6+, DOM manipulation, events, async/await, modules, fetch API
+- [ ] Backend Fundamentals: HTTP protocol, REST API design, authentication/authorization
+- [ ] Server-Side Development: Python (Flask/FastAPI), Node.js (Express), API development
+- [ ] Databases for Web: SQL (PostgreSQL), ORM concepts, migrations, Redis caching
+- [ ] *skip* Frontend Frameworks: component architecture, state management, SPA vs MPA concepts
+- [ ] DevOps for Web: Docker, reverse proxies (nginx), TLS, CI/CD, deployment strategies
+- [ ] Security: XSS, CSRF, CSP, SQL injection prevention, CORS, HTTPS
+- [ ] Exercises & Projects: static site, REST API with database, full-stack CRUD app
 
 ### 3.4 Project Management
 `path: project-management/`
 > Prereqs: Technical Writing
 
-- [ ] Fundamentals — project lifecycle, scope, stakeholders, constraints triangle
-- [ ] Methodologies — Agile, Scrum, Kanban, Waterfall, hybrid approaches
-- [ ] Planning — work breakdown structure, estimation, scheduling, Gantt charts, risk management
-- [ ] Execution & Monitoring — KPIs, burndown charts, stand-ups, retrospectives
-- [ ] Tools & Systems — issue trackers, Kanban boards, time tracking, documentation wikis
-- [ ] *skip* Team Dynamics — communication, conflict resolution, remote collaboration
-- [ ] Engineering-Specific — hardware project management, firmware release cycles, versioning
-- [ ] Exercises & Projects — plan a personal project end-to-end, set up a Kanban workflow
+- [ ] Fundamentals: project lifecycle, scope, stakeholders, constraints triangle
+- [ ] Methodologies: Agile, Scrum, Kanban, Waterfall, hybrid approaches
+- [ ] Planning: work breakdown structure, estimation, scheduling, Gantt charts, risk management
+- [ ] Execution & Monitoring: KPIs, burndown charts, stand-ups, retrospectives
+- [ ] Tools & Systems: issue trackers, Kanban boards, time tracking, documentation wikis
+- [ ] *skip* Team Dynamics: communication, conflict resolution, remote collaboration
+- [ ] Engineering-Specific: hardware project management, firmware release cycles, versioning
+- [ ] Exercises & Projects: plan a personal project end-to-end, set up a Kanban workflow
 
 ---
 
-## Phase 4 — Security & Infrastructure
+## Phase 4: Security & Infrastructure
 
 ### 4.1 Cyber Security
 `path: cyber-security/`
 > Prereqs: CS (networking, OS concepts), Command Line, Programming
 
-- [ ] Fundamentals — CIA triad, threat modeling, attack surfaces, defense in depth
-- [ ] Network Security — firewalls, IDS/IPS, VPN, packet analysis, network scanning
-- [ ] System Hardening — access control, SELinux/AppArmor, audit logging, patching, CIS benchmarks
-- [ ] Cryptography — symmetric/asymmetric encryption, hashing, TLS/SSL, PKI, key management
-- [ ] Application Security — OWASP top 10, input validation, secure coding practices, code auditing
-- [ ] Embedded Security — secure boot, firmware encryption, hardware attacks, side-channel basics
-- [ ] *skip* Penetration Testing — methodology, recon, exploitation, post-exploitation, reporting
-- [ ] *skip* Incident Response — detection, containment, forensics, recovery, lessons learned
-- [ ] Exercises & Projects — harden a Linux server, set up TLS, CTF challenges, vulnerability assessment
+- [ ] Fundamentals: CIA triad, threat modeling, attack surfaces, defense in depth
+- [ ] Network Security: firewalls, IDS/IPS, VPN, packet analysis, network scanning
+- [ ] System Hardening: access control, SELinux/AppArmor, audit logging, patching, CIS benchmarks
+- [ ] Cryptography: symmetric/asymmetric encryption, hashing, TLS/SSL, PKI, key management
+- [ ] Application Security: OWASP top 10, input validation, secure coding practices, code auditing
+- [ ] Embedded Security: secure boot, firmware encryption, hardware attacks, side-channel basics
+- [ ] *skip* Penetration Testing: methodology, recon, exploitation, post-exploitation, reporting
+- [ ] *skip* Incident Response: detection, containment, forensics, recovery, lessons learned
+- [ ] Exercises & Projects: harden a Linux server, set up TLS, CTF challenges, vulnerability assessment
 
 ### 4.2 Ansible
 `path: ansible/`
 > Prereqs: Command Line (advanced), SSH, Linux administration
 
-- [ ] Introduction — IaC concepts, Ansible architecture, installation, configuration
-- [ ] Core Concepts — inventory, modules, ad-hoc commands, YAML syntax
-- [ ] Playbooks — plays, tasks, handlers, variables, facts, conditionals, loops
-- [ ] Roles & Organization — role structure, Galaxy, collections, reuse patterns, project layout
-- [ ] Advanced — Jinja2 templates, filters, lookups, custom modules, vault (secrets)
-- [ ] *skip* Cloud & Containers — cloud provisioning, Docker management, Kubernetes basics
-- [ ] Testing — Molecule, ansible-lint, CI integration, idempotency testing
-- [ ] Exercises & Projects — server setup playbook, multi-tier deployment, homelab automation
+- [ ] Introduction: IaC concepts, Ansible architecture, installation, configuration
+- [ ] Core Concepts: inventory, modules, ad-hoc commands, YAML syntax
+- [ ] Playbooks: plays, tasks, handlers, variables, facts, conditionals, loops
+- [ ] Roles & Organization: role structure, Galaxy, collections, reuse patterns, project layout
+- [ ] Advanced: Jinja2 templates, filters, lookups, custom modules, vault (secrets)
+- [ ] *skip* Cloud & Containers: cloud provisioning, Docker management, Kubernetes basics
+- [ ] Testing: Molecule, ansible-lint, CI integration, idempotency testing
+- [ ] Exercises & Projects: server setup playbook, multi-tier deployment, homelab automation
 
 ### 4.3 Automation
 `path: automation/`
 > Prereqs: Command Line, Bash, Git, Make basics
 
-- [ ] Principles — DRY, idempotency, reproducibility, when to automate (ROI)
-- [ ] Shell Automation — cron, systemd timers, inotify/file watching, at
-- [ ] CI/CD — concepts, GitHub Actions, sourcehut builds, pipeline design, artifacts
-- [ ] Testing Automation — unit/integration/e2e strategies, fuzzing, property-based testing
-- [ ] Infrastructure Automation — Terraform concepts, Ansible integration, GitOps basics
-- [ ] *skip* Monitoring & Alerting — Prometheus, Grafana, alerting rules, log aggregation
-- [ ] Workflow Automation — pre-commit hooks, linters, formatters, changelog generation
-- [ ] Exercises & Projects — CI pipeline for a project, pre-commit setup, automated backup system
+- [ ] Principles: DRY, idempotency, reproducibility, when to automate (ROI)
+- [ ] Shell Automation: cron, systemd timers, inotify/file watching, at
+- [ ] CI/CD: concepts, GitHub Actions, sourcehut builds, pipeline design, artifacts
+- [ ] Testing Automation: unit/integration/e2e strategies, fuzzing, property-based testing
+- [ ] Infrastructure Automation: Terraform concepts, Ansible integration, GitOps basics
+- [ ] *skip* Monitoring & Alerting: Prometheus, Grafana, alerting rules, log aggregation
+- [ ] Workflow Automation: pre-commit hooks, linters, formatters, changelog generation
+- [ ] Exercises & Projects: CI pipeline for a project, pre-commit setup, automated backup system
 
 ---
 
-## Phase 5 — Embedded World
+## Phase 5: Embedded World
 
 ### 5.1 Embedded Systems
 `path: embedded-systems/`
 > Prereqs: Electronics, C, OS concepts
 
-- [ ] Introduction — embedded vs general-purpose, architectures (ARM Cortex-M, RISC-V, AVR), dev boards
-- [ ] Microcontroller Fundamentals — CPU architecture, memory map, registers, clock system, startup code
-- [ ] GPIO & Basic I/O — digital I/O, pull-ups/downs, debouncing, LED/button interfacing
-- [ ] Interrupts — interrupt vectors, ISRs, priority, NVIC (ARM), critical sections
-- [ ] Timers & PWM — timer modes, input capture, output compare, PWM generation, frequency measurement
-- [ ] Serial Communication — UART (theory + implementation), SPI, I2C, protocol debugging
-- [ ] ADC & DAC — conversion principles, sampling, resolution, DMA-driven ADC, signal conditioning
-- [ ] DMA — DMA controller, channels, circular mode, memory-to-peripheral, performance gains
-- [ ] Memory — flash programming, linker scripts, bootloader concepts, EEPROM, external memory
-- [ ] Low Power Design — sleep modes, wakeup sources, power budgets, current measurement
-- [ ] Communication Protocols — CAN bus, Modbus, 1-Wire, wireless overview (BLE, WiFi, LoRa)
-- [ ] HAL vs Bare-Metal — vendor HALs (STM32 HAL/LL), CMSIS, register-level programming
-- [ ] Debugging & Tools — JTAG/SWD, OpenOCD, GDB for embedded, logic analyzer, oscilloscope
-- [ ] Exercises & Projects — blinky to bare-metal, UART logger, SPI sensor driver, motor controller
+- [ ] Introduction: embedded vs general-purpose, architectures (ARM Cortex-M, RISC-V, AVR), dev boards
+- [ ] Microcontroller Fundamentals: CPU architecture, memory map, registers, clock system, startup code
+- [ ] GPIO & Basic I/O: digital I/O, pull-ups/downs, debouncing, LED/button interfacing
+- [ ] Interrupts: interrupt vectors, ISRs, priority, NVIC (ARM), critical sections
+- [ ] Timers & PWM: timer modes, input capture, output compare, PWM generation, frequency measurement
+- [ ] Serial Communication: UART (theory + implementation), SPI, I2C, protocol debugging
+- [ ] ADC & DAC: conversion principles, sampling, resolution, DMA-driven ADC, signal conditioning
+- [ ] DMA: DMA controller, channels, circular mode, memory-to-peripheral, performance gains
+- [ ] Memory: flash programming, linker scripts, bootloader concepts, EEPROM, external memory
+- [ ] Low Power Design: sleep modes, wakeup sources, power budgets, current measurement
+- [ ] Communication Protocols: CAN bus, Modbus, 1-Wire, wireless overview (BLE, WiFi, LoRa)
+- [ ] HAL vs Bare-Metal: vendor HALs (STM32 HAL/LL), CMSIS, register-level programming
+- [ ] Debugging & Tools: JTAG/SWD, OpenOCD, GDB for embedded, logic analyzer, oscilloscope
+- [ ] Exercises & Projects: blinky to bare-metal, UART logger, SPI sensor driver, motor controller
 
 ### 5.2 PCB Prototyping
 `path: pcb-prototyping/`
 > Prereqs: PCB Design, Electronics
 
-- [ ] Breadboarding & Perfboard — prototyping techniques, Manhattan style, wire wrapping
-- [ ] PCB Milling — desktop CNC (3018, Bantam), FlatCAM, isolation routing, drill files
-- [ ] Chemical Etching — toner transfer, UV photoresist, etchant chemistry, safety
-- [ ] Professional Fabrication — Gerber/drill generation, fab house selection (JLCPCB, PCBWay), ordering
-- [ ] Assembly — hand soldering (through-hole + SMD), reflow (hot plate, oven), stencils
-- [ ] Testing & Debugging — continuity testing, power-on sequence, functional testing, rework
-- [ ] *skip* Rapid Iteration — version control for hardware, ECOs, change management
-- [ ] Exercises & Projects — etch a simple board, order and assemble a PCB, full prototype cycle
+- [ ] Breadboarding & Perfboard: prototyping techniques, Manhattan style, wire wrapping
+- [ ] PCB Milling: desktop CNC (3018, Bantam), FlatCAM, isolation routing, drill files
+- [ ] Chemical Etching: toner transfer, UV photoresist, etchant chemistry, safety
+- [ ] Professional Fabrication: Gerber/drill generation, fab house selection (JLCPCB, PCBWay), ordering
+- [ ] Assembly: hand soldering (through-hole + SMD), reflow (hot plate, oven), stencils
+- [ ] Testing & Debugging: continuity testing, power-on sequence, functional testing, rework
+- [ ] *skip* Rapid Iteration: version control for hardware, ECOs, change management
+- [ ] Exercises & Projects: etch a simple board, order and assemble a PCB, full prototype cycle
 
 ### 5.3 Digital Fabrication
 `path: digital-fabrication/`
 > Prereqs: Electronics basics, CAD basics
 
-- [ ] Overview — fab labs, maker culture, digital fabrication workflow
-- [ ] 3D Printing — FDM, SLA/DLP, materials, slicing (Cura/PrusaSlicer), design for 3D printing
-- [ ] Laser Cutting — materials, kerf compensation, design for laser, power/speed settings, safety
-- [ ] *skip* CNC Machining — milling basics, G-code, CAM (FreeCAD Path), materials, work-holding
-- [ ] CAD for Fabrication — FreeCAD, OpenSCAD, parametric design, export formats (STL, DXF, STEP)
-- [ ] Enclosure Design — designing for electronics, standoffs, cable routing, thermal considerations
-- [ ] *skip* Mold Making & Casting — silicone molds, resin casting, urethane, finishing
-- [ ] Exercises & Projects — 3D print an enclosure, laser-cut a panel, design a complete housing
+- [ ] Overview: fab labs, maker culture, digital fabrication workflow
+- [ ] 3D Printing: FDM, SLA/DLP, materials, slicing (Cura/PrusaSlicer), design for 3D printing
+- [ ] Laser Cutting: materials, kerf compensation, design for laser, power/speed settings, safety
+- [ ] *skip* CNC Machining: milling basics, G-code, CAM (FreeCAD Path), materials, work-holding
+- [ ] CAD for Fabrication: FreeCAD, OpenSCAD, parametric design, export formats (STL, DXF, STEP)
+- [ ] Enclosure Design: designing for electronics, standoffs, cable routing, thermal considerations
+- [ ] *skip* Mold Making & Casting: silicone molds, resin casting, urethane, finishing
+- [ ] Exercises & Projects: 3D print an enclosure, laser-cut a panel, design a complete housing
 
 ---
 
-## Phase 6 — Deep Systems
+## Phase 6: Deep Systems
 
 ### 6.1 Kernel Development
 `path: kernel-development/`
 > Prereqs: OS, C (advanced), Computer Architecture
 
-- [ ] Introduction — kernel role, monolithic vs micro, Linux source tree navigation
-- [ ] Build & Boot — kernel configuration, cross-compiling, QEMU/VM testing, boot process
-- [ ] Kernel Modules — module structure, Makefiles, loading/unloading, module parameters, licensing
-- [ ] Character Devices — file_operations, major/minor numbers, ioctl, sysfs, procfs
-- [ ] Kernel Memory — kmalloc/kfree, vmalloc, slab allocator, page allocator, GFP flags
-- [ ] Concurrency — spinlocks, mutexes, RCU, atomic operations, per-CPU data, completion
-- [ ] Interrupts & Timers — top/bottom halves, tasklets, workqueues, hrtimers, softirqs
-- [ ] Device Model — platform devices, device tree, driver model, buses, probe/remove
-- [ ] *skip* Networking — net_device, socket buffers (skb), netfilter hooks, packet flow
-- [ ] *skip* File Systems — VFS interface, implementing a simple filesystem, block layer
-- [ ] Debugging — printk/dynamic debug, ftrace, kprobes, KGDB, crash dump analysis, KASAN
-- [ ] Exercises & Projects — hello-world module, char device driver, device tree overlay, simple driver
+- [ ] Introduction: kernel role, monolithic vs micro, Linux source tree navigation
+- [ ] Build & Boot: kernel configuration, cross-compiling, QEMU/VM testing, boot process
+- [ ] Kernel Modules: module structure, Makefiles, loading/unloading, module parameters, licensing
+- [ ] Character Devices: file_operations, major/minor numbers, ioctl, sysfs, procfs
+- [ ] Kernel Memory: kmalloc/kfree, vmalloc, slab allocator, page allocator, GFP flags
+- [ ] Concurrency: spinlocks, mutexes, RCU, atomic operations, per-CPU data, completion
+- [ ] Interrupts & Timers: top/bottom halves, tasklets, workqueues, hrtimers, softirqs
+- [ ] Device Model: platform devices, device tree, driver model, buses, probe/remove
+- [ ] *skip* Networking: net_device, socket buffers (skb), netfilter hooks, packet flow
+- [ ] *skip* File Systems: VFS interface, implementing a simple filesystem, block layer
+- [ ] Debugging: printk/dynamic debug, ftrace, kprobes, KGDB, crash dump analysis, KASAN
+- [ ] Exercises & Projects: hello-world module, char device driver, device tree overlay, simple driver
 
 ### 6.2 Embedded OS & RTOS
 `path: embedded-os/`
 > Prereqs: Embedded Systems, OS, C
 
-- [ ] RTOS Concepts — real-time constraints, hard/soft RT, scheduling (rate monotonic, EDF), WCET
-- [ ] FreeRTOS — tasks, queues, semaphores/mutexes, timers, memory management, portability
-- [ ] Zephyr — architecture, devicetree, Kconfig, kernel primitives, networking stack, west tool
-- [ ] Embedded Linux — Buildroot, Yocto/OpenEmbedded, cross-toolchains, root filesystem, device tree
-- [ ] Bootloaders — U-Boot, MCUboot, boot stages, secure boot chain
-- [ ] Bare-Metal vs RTOS vs Linux — decision framework, resource constraints, trade-offs
-- [ ] Inter-Task Communication — message queues, event groups, mailboxes, shared memory, priority inversion
-- [ ] *skip* OTA Updates — firmware update strategies, A/B partitions, rollback, delta updates
-- [ ] Exercises & Projects — FreeRTOS multitask app, Zephyr sensor driver, Buildroot custom image
+- [ ] RTOS Concepts: real-time constraints, hard/soft RT, scheduling (rate monotonic, EDF), WCET
+- [ ] FreeRTOS: tasks, queues, semaphores/mutexes, timers, memory management, portability
+- [ ] Zephyr: architecture, devicetree, Kconfig, kernel primitives, networking stack, west tool
+- [ ] Embedded Linux: Buildroot, Yocto/OpenEmbedded, cross-toolchains, root filesystem, device tree
+- [ ] Bootloaders: U-Boot, MCUboot, boot stages, secure boot chain
+- [ ] Bare-Metal vs RTOS vs Linux: decision framework, resource constraints, trade-offs
+- [ ] Inter-Task Communication: message queues, event groups, mailboxes, shared memory, priority inversion
+- [ ] *skip* OTA Updates: firmware update strategies, A/B partitions, rollback, delta updates
+- [ ] Exercises & Projects: FreeRTOS multitask app, Zephyr sensor driver, Buildroot custom image
 
 ### 6.3 Internet of Things
 `path: iot/`
 > Prereqs: Embedded Systems, Web Tech (backend), Networking
 
-- [ ] IoT Architecture — edge/fog/cloud, reference architectures, design patterns
-- [ ] Connectivity — WiFi, BLE, LoRa/LoRaWAN, Zigbee, Thread, protocol comparison
-- [ ] Messaging Protocols — MQTT (deep dive), CoAP, HTTP for IoT, WebSockets
-- [ ] IoT Platforms — Home Assistant, Node-RED, Thingsboard, AWS IoT Core overview
-- [ ] Data Pipeline — collection, time-series databases (InfluxDB), processing, dashboards (Grafana)
-- [ ] Edge Computing — local processing, gateway design, edge inference, offline operation
-- [ ] Security & Privacy — device identity, secure communication, firmware signing, threat landscape
-- [ ] *skip* Standards — Matter, Thread, OPC-UA, industrial IoT
-- [ ] Exercises & Projects — MQTT sensor network, LoRa node + gateway, home automation system
+- [ ] IoT Architecture: edge/fog/cloud, reference architectures, design patterns
+- [ ] Connectivity: WiFi, BLE, LoRa/LoRaWAN, Zigbee, Thread, protocol comparison
+- [ ] Messaging Protocols: MQTT (deep dive), CoAP, HTTP for IoT, WebSockets
+- [ ] IoT Platforms: Home Assistant, Node-RED, Thingsboard, AWS IoT Core overview
+- [ ] Data Pipeline: collection, time-series databases (InfluxDB), processing, dashboards (Grafana)
+- [ ] Edge Computing: local processing, gateway design, edge inference, offline operation
+- [ ] Security & Privacy: device identity, secure communication, firmware signing, threat landscape
+- [ ] *skip* Standards: Matter, Thread, OPC-UA, industrial IoT
+- [ ] Exercises & Projects: MQTT sensor network, LoRa node + gateway, home automation system
 
 ---
 
-## Phase 7 — Intelligence & Integration
+## Phase 7: Intelligence & Integration
 
 ### 7.1 Computer Vision & Edge AI
 `path: computer-vision/`
 > Prereqs: Math (linear algebra, calculus, probability), Python, Embedded basics
 
-- [ ] Image Fundamentals — digital images, color spaces, histograms, geometric transforms
-- [ ] Image Processing — convolution, filtering, morphology, edge detection, thresholding
-- [ ] Feature Detection — corners (Harris, Shi-Tomasi), descriptors (SIFT/ORB), feature matching
-- [ ] Classical CV — template matching, object detection (Haar/HOG), tracking, optical flow
-- [ ] Deep Learning Foundations — neural networks, backprop, CNNs, training loop, PyTorch/TensorFlow
-- [ ] Object Detection & Segmentation — YOLO, SSD, U-Net, Mask R-CNN, transfer learning
-- [ ] Model Optimization — quantization, pruning, knowledge distillation, ONNX, TFLite
-- [ ] Edge Deployment — Coral TPU, Jetson, OpenMV, RPi, NPU/VPU, inference frameworks
-- [ ] *skip* Advanced Topics — 3D vision, depth estimation, visual SLAM, generative models
-- [ ] Exercises & Projects — OpenCV pipeline, train a classifier, deploy on edge device, visual inspection
+- [ ] Image Fundamentals: digital images, color spaces, histograms, geometric transforms
+- [ ] Image Processing: convolution, filtering, morphology, edge detection, thresholding
+- [ ] Feature Detection: corners (Harris, Shi-Tomasi), descriptors (SIFT/ORB), feature matching
+- [ ] Classical CV: template matching, object detection (Haar/HOG), tracking, optical flow
+- [ ] Deep Learning Foundations: neural networks, backprop, CNNs, training loop, PyTorch/TensorFlow
+- [ ] Object Detection & Segmentation: YOLO, SSD, U-Net, Mask R-CNN, transfer learning
+- [ ] Model Optimization: quantization, pruning, knowledge distillation, ONNX, TFLite
+- [ ] Edge Deployment: Coral TPU, Jetson, OpenMV, RPi, NPU/VPU, inference frameworks
+- [ ] *skip* Advanced Topics: 3D vision, depth estimation, visual SLAM, generative models
+- [ ] Exercises & Projects: OpenCV pipeline, train a classifier, deploy on edge device, visual inspection
 
 ### 7.2 Robotics
 `path: robotics/`
 > Prereqs: Math (linear algebra, calculus, diff eq), Electronics, Embedded, Programming (C++/Python)
 
-- [ ] Foundations — robot types, coordinate frames, homogeneous transforms, DH convention
-- [ ] Kinematics — forward/inverse kinematics, Jacobian, velocity kinematics, workspace analysis
-- [ ] Dynamics — Newton-Euler, Lagrangian mechanics, torque computation, gravity compensation
-- [ ] Actuators & Sensors — DC/stepper/servo motors, encoders, IMUs, LIDAR, depth cameras
-- [ ] Control Systems — PID control, state-space, trajectory generation, motion profiles
-- [ ] Motion Planning — path planning (A*, RRT, PRM), obstacle avoidance, configuration space
-- [ ] *skip* SLAM & Localization — EKF/particle filter, lidar SLAM, visual SLAM, sensor fusion
-- [ ] ROS 2 — architecture, nodes, topics, services, actions, launch files, URDF, Gazebo
-- [ ] *skip* Mobile Robots — wheeled (differential, omnidirectional), legged basics, drone basics
-- [ ] Exercises & Projects — PID line follower, robotic arm control, ROS 2 navigation stack
+- [ ] Foundations: robot types, coordinate frames, homogeneous transforms, DH convention
+- [ ] Kinematics: forward/inverse kinematics, Jacobian, velocity kinematics, workspace analysis
+- [ ] Dynamics: Newton-Euler, Lagrangian mechanics, torque computation, gravity compensation
+- [ ] Actuators & Sensors: DC/stepper/servo motors, encoders, IMUs, LIDAR, depth cameras
+- [ ] Control Systems: PID control, state-space, trajectory generation, motion profiles
+- [ ] Motion Planning: path planning (A*, RRT, PRM), obstacle avoidance, configuration space
+- [ ] *skip* SLAM & Localization: EKF/particle filter, lidar SLAM, visual SLAM, sensor fusion
+- [ ] ROS 2: architecture, nodes, topics, services, actions, launch files, URDF, Gazebo
+- [ ] *skip* Mobile Robots: wheeled (differential, omnidirectional), legged basics, drone basics
+- [ ] Exercises & Projects: PID line follower, robotic arm control, ROS 2 navigation stack
 
 ### 7.3 Rust
 `path: programming/rust/`
 > Prereqs: Programming Fundamentals, C (recommended)
 
-- [ ] Getting Started — cargo, crate structure, hello world, rustup, editions
-- [ ] Ownership & Borrowing — ownership rules, references, lifetimes, borrow checker
-- [ ] Type System — structs, enums, pattern matching, generics, traits, trait objects
-- [ ] Error Handling — Result, Option, ? operator, custom errors, anyhow/thiserror
-- [ ] Collections & Iterators — Vec, HashMap, iterator adaptors, closures, functional patterns
-- [ ] Concurrency — threads, channels, Arc/Mutex, Send/Sync, async/await, tokio basics
-- [ ] Unsafe & FFI — unsafe blocks, raw pointers, extern "C", bindgen, calling C from Rust
-- [ ] Ecosystem — serde, clap, reqwest, embedded Rust (no_std), testing, benchmarking
-- [ ] Exercises & Projects — CLI tool, concurrent web scraper, embedded Rust blinky, C FFI wrapper
+- [ ] Getting Started: cargo, crate structure, hello world, rustup, editions
+- [ ] Ownership & Borrowing: ownership rules, references, lifetimes, borrow checker
+- [ ] Type System: structs, enums, pattern matching, generics, traits, trait objects
+- [ ] Error Handling: Result, Option, ? operator, custom errors, anyhow/thiserror
+- [ ] Collections & Iterators: Vec, HashMap, iterator adaptors, closures, functional patterns
+- [ ] Concurrency: threads, channels, Arc/Mutex, Send/Sync, async/await, tokio basics
+- [ ] Unsafe & FFI: unsafe blocks, raw pointers, extern "C", bindgen, calling C from Rust
+- [ ] Ecosystem: serde, clap, reqwest, embedded Rust (no_std), testing, benchmarking
+- [ ] Exercises & Projects: CLI tool, concurrent web scraper, embedded Rust blinky, C FFI wrapper
 
 ### 7.4 C++
 `path: programming/cpp/`
 > Prereqs: C, Programming Fundamentals
 
-- [ ] C++ Basics — classes, constructors/destructors, namespaces, references, streams
-- [ ] OOP — inheritance, polymorphism, virtual functions, abstract classes, RTTI
-- [ ] Templates — function/class templates, template specialization, variadic templates, SFINAE basics
-- [ ] STL — containers, iterators, algorithms, string, functional
-- [ ] Modern C++ (17/20/23) — auto, structured bindings, ranges, concepts, modules, coroutines overview
-- [ ] Memory Management — RAII, smart pointers (unique/shared/weak), move semantics, rule of 5
-- [ ] Concurrency — std::thread, mutex, condition_variable, atomic, futures, async
-- [ ] *skip* Advanced — type erasure, CRTP, policy-based design, compile-time computation
-- [ ] Exercises & Projects — matrix library, concurrent data structure, embedded C++ on MCU
+- [ ] C++ Basics: classes, constructors/destructors, namespaces, references, streams
+- [ ] OOP: inheritance, polymorphism, virtual functions, abstract classes, RTTI
+- [ ] Templates: function/class templates, template specialization, variadic templates, SFINAE basics
+- [ ] STL: containers, iterators, algorithms, string, functional
+- [ ] Modern C++ (17/20/23): auto, structured bindings, ranges, concepts, modules, coroutines overview
+- [ ] Memory Management: RAII, smart pointers (unique/shared/weak), move semantics, rule of 5
+- [ ] Concurrency: std::thread, mutex, condition_variable, atomic, futures, async
+- [ ] *skip* Advanced: type erasure, CRTP, policy-based design, compile-time computation
+- [ ] Exercises & Projects: matrix library, concurrent data structure, embedded C++ on MCU
 
 ### 7.5 Advanced Languages
 `path: programming/advanced-languages/`
 > Prereqs: Programming Fundamentals, specific domain knowledge per language
 
-- [ ] Python Advanced — decorators, generators, metaclasses, asyncio, C extensions, type hints
-- [ ] Lua — tables, metatables, coroutines, embedding in C, LuaJIT FFI, game scripting
-- [ ] Julia — multiple dispatch, type system, macros, performance, scientific computing, GPU
-- [ ] R — data frames, tidyverse, ggplot2, statistical modeling, R Markdown
-- [ ] Cross-Language — FFI patterns, polyglot projects, language interop, choosing the right tool
-- [ ] Exercises & Projects — Python C extension, Lua-embedded app, Julia scientific notebook, R analysis
+- [ ] Python Advanced: decorators, generators, metaclasses, asyncio, C extensions, type hints
+- [ ] Lua: tables, metatables, coroutines, embedding in C, LuaJIT FFI, game scripting
+- [ ] Julia: multiple dispatch, type system, macros, performance, scientific computing, GPU
+- [ ] R: data frames, tidyverse, ggplot2, statistical modeling, R Markdown
+- [ ] Cross-Language: FFI patterns, polyglot projects, language interop, choosing the right tool
+- [ ] Exercises & Projects: Python C extension, Lua-embedded app, Julia scientific notebook, R analysis
 
 ---
 
-## Side Quest — Anytime
+## Side Quest: Anytime
 
 ### S.1 Global Geek Culture
 `path: geek-culture/`
-> Prereqs: None — read alongside any phase
-
-- [ ] Hacker Culture Origins — MIT AI Lab, Tech Model Railroad Club, PDP-1, hacker ethic, "Hackers" (Levy)
-- [ ] Phone Phreaking & Early Hacking — Captain Crunch, blue boxes, 2600 magazine, WarGames, Legion of Doom
-- [ ] The Jargon File & Hacker Lore — Jargon File, INTERCAL, RFC humor, koans, AI koans, quines, IOCCC
-- [ ] Text File Underground — textfiles.com, e-zines (Phrack, LoD/H Technical Journal), BBS culture, ANSI art
-- [ ] The Geek Code & .sig Culture — Geek Code blocks, ASCII art sigs, fortune files, Plan files, finger protocol
-- [ ] Usenet & Early Internet Culture — flame wars, FAQs, killfiles, alt.* hierarchy, trolling as art, Eternal September
-- [ ] Cryptography Wars & Cypherpunks — cypherpunk mailing list, PGP, Clipper chip, Zimmermann, remailers
-- [ ] Demoscene — demo groups, size coding (4k/64k intros), Amiga/Atari scene, Revision/Assembly parties, pouet.net
-- [ ] Open Source Movement — GNU Manifesto, FSF, Cathedral vs Bazaar, Linux, copyleft vs permissive, forking culture
-- [ ] Warez & Underground Scenes — warez groups, NFOs, cracktros, courier culture, The Scene
-- [ ] Internet Mysteries & Challenges — Cicada 3301, Webdriver Torso, Markovian Parallax Denigrate, crypto puzzles, ARGs
-- [ ] MUDs, MOOs & Virtual Worlds — text adventures, LambdaMOO, online community origins, digital identity
-- [ ] Hacker Conferences & Community — DEF CON, CCC, 2600 meetings, hackerspaces, CTF culture
-- [ ] Maker & Hardware Hacking — hackerspaces, CCC hardware, Arduino/RPi, OSHW, right to repair, modding
-- [ ] *skip* Cyberpunk & Sci-Fi Canon — Gibson, Stephenson, Dick, Doctorow, technology predictions
-- [ ] *skip* Global Perspectives — CCC vs DEF CON culture, Shenzhen, Global South tech, internet freedom
+> Prereqs: None: read alongside any phase
+
+- [ ] Hacker Culture Origins: MIT AI Lab, Tech Model Railroad Club, PDP-1, hacker ethic, "Hackers" (Levy)
+- [ ] Phone Phreaking & Early Hacking: Captain Crunch, blue boxes, 2600 magazine, WarGames, Legion of Doom
+- [ ] The Jargon File & Hacker Lore: Jargon File, INTERCAL, RFC humor, koans, AI koans, quines, IOCCC
+- [ ] Text File Underground: textfiles.com, e-zines (Phrack, LoD/H Technical Journal), BBS culture, ANSI art
+- [ ] The Geek Code & .sig Culture: Geek Code blocks, ASCII art sigs, fortune files, Plan files, finger protocol
+- [ ] Usenet & Early Internet Culture: flame wars, FAQs, killfiles, alt.* hierarchy, trolling as art, Eternal September
+- [ ] Cryptography Wars & Cypherpunks: cypherpunk mailing list, PGP, Clipper chip, Zimmermann, remailers
+- [ ] Demoscene: demo groups, size coding (4k/64k intros), Amiga/Atari scene, Revision/Assembly parties, pouet.net
+- [ ] Open Source Movement: GNU Manifesto, FSF, Cathedral vs Bazaar, Linux, copyleft vs permissive, forking culture
+- [ ] Warez & Underground Scenes: warez groups, NFOs, cracktros, courier culture, The Scene
+- [ ] Internet Mysteries & Challenges: Cicada 3301, Webdriver Torso, Markovian Parallax Denigrate, crypto puzzles, ARGs
+- [ ] MUDs, MOOs & Virtual Worlds: text adventures, LambdaMOO, online community origins, digital identity
+- [ ] Hacker Conferences & Community: DEF CON, CCC, 2600 meetings, hackerspaces, CTF culture
+- [ ] Maker & Hardware Hacking: hackerspaces, CCC hardware, Arduino/RPi, OSHW, right to repair, modding
+- [ ] *skip* Cyberpunk & Sci-Fi Canon: Gibson, Stephenson, Dick, Doctorow, technology predictions
+- [ ] *skip* Global Perspectives: CCC vs DEF CON culture, Shenzhen, Global South tech, internet freedom
 
 ---
 
diff --git a/build.sh b/build.sh
index b7e42d9..ee2e39d 100644
--- a/build.sh
+++ b/build.sh
@@ -176,7 +176,7 @@ while IFS= read -r -d '' topic; do
     process_dir "${topic}"
 done < "${find_list}"
 
-# Home page — README.md + topic listing
+# Home page: README.md + topic listing
 home_md="${TMPDIR_BUILD}/home.md"
 cp README.md "${home_md}"
 printf '\n\n## topics:\n\n' >> "${home_md}"
diff --git a/linux-command-line/shell-basics/index.md b/linux-command-line/shell-basics/index.md
index c0cf75b..f84c802 100644
--- a/linux-command-line/shell-basics/index.md
+++ b/linux-command-line/shell-basics/index.md
@@ -4,7 +4,7 @@ title: Shell Basics
 
 # Shell Basics
 
-The shell is your primary interface to a Linux system. Everything — file management, process control, system administration — flows through it. Before graphical tools, before IDEs, there was the shell. Mastering it is non-negotiable.
+The shell is your primary interface to a Linux system. Everything (file management, process control, system administration) flows through it. Before graphical tools, before IDEs, there was the shell. Mastering it is non-negotiable.
 
 **Prerequisites:** None
 **Estimated time:** 4-6 hours of practice
@@ -16,10 +16,10 @@ The shell is your primary interface to a Linux system. Everything — file manag
 A shell is a program that reads commands from your input and executes them. It's both a **command interpreter** (runs programs) and a **programming language** (scripts).
 
 Common shells:
-- **bash** — Bourne Again Shell, the default on most Linux systems
-- **zsh** — Extended bash with better completion and prompting
-- **sh** — POSIX shell, the lowest common denominator
-- **fish** — Friendly interactive shell, not POSIX-compatible
+- **bash**: Bourne Again Shell, the default on most Linux systems
+- **zsh**: Extended bash with better completion and prompting
+- **sh**: POSIX shell, the lowest common denominator
+- **fish**: Friendly interactive shell, not POSIX-compatible
 
 When you open a terminal, you're running a **terminal emulator** (alacritty, kitty, xterm) which hosts a **shell process**. The terminal draws pixels; the shell interprets commands.
 
@@ -40,12 +40,12 @@ cat /etc/shells
 
 ## Navigating the Filesystem
 
-Linux has a single filesystem tree rooted at `/`. Everything is a file — devices, processes, sockets.
+Linux has a single filesystem tree rooted at `/`. Everything is a file: devices, processes, sockets.
 
 ### Essential Navigation Commands
 
 ```bash
-pwd                     # Print working directory — where you are
+pwd                     # Print working directory: where you are
 ls                      # List files in current directory
 ls -la                  # Long format, show hidden files (dotfiles)
 ls -lh                  # Human-readable sizes (K, M, G)
@@ -107,7 +107,7 @@ mv file.txt ~/Documents/        # Move to another directory
 # Delete
 rm file.txt                     # Remove file (no trash, no undo)
 rm -r mydir/                    # Remove directory recursively
-rm -ri mydir/                   # Interactive — asks before each deletion
+rm -ri mydir/                   # Interactive: asks before each deletion
 rmdir emptydir/                 # Remove only if empty
 ```
 
@@ -125,11 +125,11 @@ wc -l file.txt                  # Count lines
 ```
 
 `less` is your friend. Use it for anything longer than a screenful. Key bindings inside `less`:
-- `Space` / `b` — page down / up
-- `/pattern` — search forward
-- `n` / `N` — next / previous search match
-- `g` / `G` — go to top / bottom
-- `q` — quit
+- `Space` / `b`: page down / up
+- `/pattern`: search forward
+- `n` / `N`: next / previous search match
+- `g` / `G`: go to top / bottom
+- `q`: quit
 
 ---
 
@@ -147,7 +147,7 @@ ls -l file.txt
 # └───────────── file type: - = regular, d = directory, l = symlink
 ```
 
-### chmod — Change Permissions
+### chmod: Change Permissions
 
 ```bash
 # Symbolic notation
@@ -156,9 +156,9 @@ chmod go-w file.txt            # Remove write for group and others
 chmod a+r file.txt             # Add read for all
 
 # Octal notation (most common)
-chmod 755 script.sh            # rwxr-xr-x — owner full, others read+execute
-chmod 644 file.txt             # rw-r--r-- — owner read+write, others read
-chmod 600 secret.key           # rw------- — owner only
+chmod 755 script.sh            # rwxr-xr-x: owner full, others read+execute
+chmod 644 file.txt             # rw-r--r--: owner read+write, others read
+chmod 600 secret.key           # rw-------: owner only
 ```
 
 **Octal cheat sheet:** r=4, w=2, x=1. Add them up per group.
@@ -168,7 +168,7 @@ chmod 600 secret.key           # rw------- — owner only
 - `4` = r-- (4)
 - `0` = --- (0)
 
-### chown — Change Ownership
+### chown: Change Ownership
 
 ```bash
 chown ahmed file.txt            # Change owner
@@ -189,9 +189,9 @@ This is where the shell gets powerful. The Unix philosophy: small programs that
 ### Redirection
 
 Every process has three standard streams:
-- **stdin** (0) — input
-- **stdout** (1) — normal output
-- **stderr** (2) — error output
+- **stdin** (0): input
+- **stdout** (1): normal output
+- **stderr** (2): error output
 
 ```bash
 # Redirect stdout to a file
@@ -231,18 +231,18 @@ ps aux | grep nginx | grep -v grep
 cat /etc/passwd | cut -d: -f1 | sort | head -5
 ```
 
-> **Useless use of cat:** `cat file | grep pattern` can be written as `grep pattern file`. But in pipelines with many stages, starting with `cat` can be clearer. Don't stress about it early on — clarity matters more than micro-optimization.
+> **Useless use of cat:** `cat file | grep pattern` can be written as `grep pattern file`. But in pipelines with many stages, starting with `cat` can be clearer. Don't stress about it early on: clarity matters more than micro-optimization.
 
 ### Command Substitution
 
 Use the output of one command inside another:
 
 ```bash
-# Using $() — preferred
+# Using $(): preferred
 echo "Today is $(date +%Y-%m-%d)"
 files=$(ls *.txt)
 
-# Using backticks — older style, harder to nest
+# Using backticks: older style, harder to nest
 echo "Today is `date +%Y-%m-%d`"
 ```
 
@@ -282,10 +282,10 @@ apropos network         # Search man pages by keyword
 ```
 
 **Reading man pages:** The synopsis section uses conventions:
-- `[optional]` — square brackets mean optional
-- `REQUIRED` — caps or no brackets means required
-- `...` — can be repeated
-- `a | b` — choose one
+- `[optional]`: square brackets mean optional
+- `REQUIRED`: caps or no brackets means required
+- `...`: can be repeated
+- `a | b`: choose one
 
 ---
 
@@ -309,7 +309,7 @@ apropos network         # Search man pages by keyword
 
 ### Mini-Project
 
-**Build a quick reference card:** Create a file `~/cheatsheet.md` that contains the 20 commands you found most useful from this section, organized by category, with a one-line description and example for each. This is your cheatsheet — you'll extend it throughout the course.
+**Build a quick reference card:** Create a file `~/cheatsheet.md` that contains the 20 commands you found most useful from this section, organized by category, with a one-line description and example for each. This is your cheatsheet: you'll extend it throughout the course.
 
 ---
 
@@ -317,11 +317,11 @@ apropos network         # Search man pages by keyword
 
 - The shell is a command interpreter and a programming environment
 - Everything in Linux is a file, organized in a single tree from `/`
-- Permissions are the foundation of Linux security — understand `rwx` and octal
+- Permissions are the foundation of Linux security: understand `rwx` and octal
 - Pipes and redirection are the core of composing commands
-- `man` and `--help` are always available — read them first, search the web second
+- `man` and `--help` are always available: read them first, search the web second
 - Practice in a real terminal. Reading about commands is not the same as using them.
 
 ---
 
-**Next:** [File Management](../file-management/) — find, locate, tar, rsync, and more
+**Next:** [File Management](../file-management/): find, locate, tar, rsync, and more