Drive SQLite from Rust with rusqlite — connections, prepared statements, parameterized queries, and transaction-wrapped bulk inserts

Build typed CSV and JSON ingestion paths with the csv crate and serde_json, and round-trip data back out as exports or SQL dumps

Ship a clap v4 CLI (fscrawl) that walks a filesystem with walkdir, stores metadata in SQLite, and exposes crawl / query / export / db-dump

Design typed Rust ETL pipelines that uphold a totality contract — every input row either yields a validated record or a structured error.

Write dual-format sinks that emit NDJSON and CSV from a single pipeline pass using the Write trait, with round-trip invariants verified by proptest

Build thiserror-based error enums that propagate with ? and give every pipeline run a structured, auditable exit code

Install Kubuntu on a Framework Laptop from a flashed USB and complete first-boot setup including partitioning and user accounts

Configure System Settings end-to-end — display scaling, multi-monitor, user accounts and sudo, software installation via Discover and apt

Customize the KDE Plasma desktop with global themes, widgets, virtual desktops, Activities, KRunner, keyboard shortcuts, and workspace effects

Use the terminal for navigation, file operations, user and group management, system monitoring with top/htop/journalctl, and basic troubleshooting

Configure and use the Polars Rust crate with the lazy and csv feature flags to build typed DataFrames over Apache Arrow memory

Apply Polars expressions to clean and aggregate the wine-ratings dataset, with documented null-handling, normalization, and predicate-filter rules

Build wine-pipeline, three Rust CLI binaries that realize a bronze, silver, gold medallion architecture over a shared SQLite database

Build, test, and deploy AWS Lambda functions in Rust using Cargo Lambda's five core commands: cargo lambda new, build, watch, invoke, and deploy

Compare serverless runtime performance across Python, Ruby, Node.js, and Rust on the same handler workload running inside AWS Lambda

Reframe AI ethics around human externalities — what is best for humans, not what is best for GDP or corporations

Recognize and counter common tech-propaganda patterns: FOMO, naive utopianism, business-model circular logic, and Trojan-horse open-source plays

Apply externality-first market corrections — addictiveness taxes, repairability credits, and humanism over GDP as a course-level KPI

Adapt agile ceremonies to your team's actual workflow — drop the rituals that don't generate value, keep the ones that shorten feedback loops

Apply pragmatic project-management patterns using Trello and spreadsheets — small-batch work, lightweight artifacts, weekly cadence, blameless retros

Integrate AI workflows into engineering practice — diagram prompt engineering, summarization with Claude, AI pair programming

Recognize and avoid the project-management anti-patterns that produce ticket-shaped work and status theater

Read and write Zig — including the four standard-library allocators (GPA, Arena, FixedBuffer, page_allocator) — and map each idiom back onto Rust

Build a tiny statically-linked Zig binary and ship it inside a multi-stage Dockerfile that produces a kilobyte-sized container image

Make the language choice on a real team — pick Zig for footprint, fast cold start, and C interop; stay with Rust for long-running services

Build native desktop applications in Rust using iced, FLTK, GTK4, relm4, and egui on Kubuntu Linux

Develop a counter, calculator with unit tests, to-do list, Pong game, password generator, Simon Says, and quiz app in real-time recorded sessions

Choose the right Rust GUI framework for a project, persist state to disk with serde or rusqlite, and ship a working binary

Set up a free Linux environment in your browser using GitHub Codespaces, Google Cloud Shell, or Azure Cloud Shell — no local install required

Use the shell fluently — bash, zsh, history recall, tab completion, the which command, variables, and the PATH variable — like a daily user

Navigate and manipulate the Linux filesystem with cd, pwd, ls, globbing wildcards, and cp for both files and directories

Build a Rust handler that reads from Cloud Storage, queries BigQuery via REST or Storage Read API, and deploys to Cloud Run

Apply Pub/Sub push subscriptions with content-hash idempotency keys and concurrency × max-instances backpressure caps

Gate Rust GCP services on cargo-audit, cargo-deny, and GitHub Actions CI with secure-by-design defaults from the first commit

Build a clap-driven Rust binary CLI with a tuned release profile that produces a sub-10 MB stripped binary, then ship it inside a 6 MB scratch

Compose a CI gate stack of fmt + clippy + test + 100% coverage + audit + deny + pmat + bashrs + forjar + pv

Author criterion benchmarks with warmup and statistical sampling, then wire a regression gate

Pick the right Claude surface for the task: when chat is enough, when a Project pays off, and when Claude Code is the only viable shape.

Author slash-command skills that wrap Rust binaries, then constrain parallel sub-agents with YAML contracts so review converges to passing.

Replace raw grep with pmat query enrichment flags and wire pmat comply into pre-commit so the gate runs every commit.

Build a production Rust CLI with clap, including subcommands designed for data pipelines, input validation

Handle errors with `anyhow` and `Result`/`?

Package and ship a Rust CLI by writing crates.io-ready `Cargo.toml`

Implement BFS, DFS, Dijkstra, PageRank, and Kosaraju strongly-connected components from scratch in Rust using petgraph and aprender-graph

Apply each algorithm to a real dataset: a Lisbon walking-route graph, a sports link graph, UFC fight records, and a Twitter follower graph

Ship a clap-based command-line tool that exposes every algorithm as a subcommand and emits machine-readable JSON

Connect to MySQL from the terminal, import the Sakila sample database, and query it with `SELECT`, `INNER JOIN`, and `LEFT JOIN`

Read an `EXPLAIN ANALYZE` plan to tell whether your query uses an index (`type=ref` / `type=range`) or scans the whole table (`type=ALL`)

Connect to MySQL from a typed Rust client using `sqlx::MySqlPool`, map result rows to a `FromRow`-derived struct, and embed runtime `assert!`

Operate PostgreSQL from psql with transactional writes (BEGIN ... ROLLBACK) and safe \copy CSV export.

Read Pagila JOIN paths and EXPLAIN ANALYZE plans — distinguish INNER vs LEFT JOIN and Seq Scan vs Index Scan.

Ship a typed Rust client with sqlx::PgPool and FromRow that emits contract-verified JSON reports.

Apply the five-stage RAG pipeline (encode, chunk, index, fuse, retrieve) using the aprender-rag crate against a real corpus

Analyze recursive-chunking overlap and reciprocal-rank-fusion k for the recall-vs-noise trade-off

Evaluate pmat query enrichment flags (--churn, --duplicates, --entropy, --faults, -G) for ranking source-code search by intent

Embed DuckDB inside a Rust binary using bundled feature flags and choose between in-memory and on-disk connections.

Run SQL over local CSV, Parquet, and JSON files with read_csv_auto and read_parquet using projection and predicate pushdown.

Stream Arrow record batches from DuckDB into Polars and ship a polished single-file CLI with cargo dist.

Instrument Rust HTTP services with Prometheus metrics, structured tracing logs, and ELK-stack log shipping for full observability

Build Rust CLIs that crawl filesystems with walkdir and glob, parse logs with regex, and wrap external commands with robust error handling

Ship a graded compliance utility that reads JSON rules, audits the filesystem, and exits with a non-zero status to gate CI/CD pipelines

Build production-grade CI/CD pipelines for Rust applications using GitHub Actions, Makefiles, and Docker.

Manage advanced workflow patterns including matrix builds, interdependent jobs, and conditional logic.

Package, lint, and release containerized Rust data applications through an end-to-end deployment pipeline.

Apply the three-element HelixQL schema (N::, V::, E::) and the four-keyword QUERY shape compiled into typed Rust handlers.

Build a hybrid-RAG pipeline with SearchV and ::In<EmbeddingOf>, shipped as a typed Rust client.

Compose graph traversal and vector search in one HelixQL query language and one engine.

Build IAC solutions

Comprehend Rust binary advantages in IAC

Build a pure-Rust terminal-UI framework from the cell buffer up, with byte-deterministic snapshot tests in CI.

Apply the Elm-style init/update/view shape and composite layout to build production widgets (CpuGrid, ProcessTable, MemoryBar).

Create ptop-mini end-to-end — a Snapshot-fixture-driven process monitor that swaps to a live /proc reader without changing the view function.

Compile Rust to WebAssembly and render to the HTML5 canvas with a deterministic Canvas2DRenderer

Build Elm-style components with update/view, then compose them with a small router into a multi-screen app

Package with wasm-pack and verify VDOM behavior against committed snapshot fixtures for byte-identical CI runs

Apply a receipt-driven, three-mode workflow (Discover, Refactor, Translate) to move object-oriented Python code into idiomatic Rust.

Translate Python class hierarchies into Rust structs, traits, enums, and the type-state pattern using composition over inheritance.

Score Python-to-Rust translation pull requests using a breakeven analysis and complexity-claim review rubric.