dotfiles

Apply idiomatic, well-structured Python development practices. Use when writing, reviewing, or refactoring Python code. Covers type annotations, package management with uv, Pydantic DTOs, Typer CLIs, pytest patterns, PEP 8 style, architecture, and type-driven design.

How to manage Python dependencies with UV — inline script metadata (PEP 723), project mode, tool running, and when to use each approach. Always use UV; never pip directly.

Use when receiving code review feedback (especially if unclear or technically questionable), when completing tasks or major features requiring review before proceeding, or before making any completion/success claims. Covers four practices — receiving feedback with technical rigor, requesting reviews via code-reviewer subagent, verification gates requiring evidence before claims, and security/API-compat awareness. Essential for subagent-driven development, pull requests, and preventing false completion claims.

Synthesize knowledge from multiple sources into Zettelkasten notes for Logseq. Use when creating wiki pages, integrating academic research, or building interconnected knowledge with [[links]] and

Survey a Google Drive's actual folder structure, apply a PARA-lite organization framework, and produce (then safely execute) a concrete reorganization plan — deduping, sweeping root-level clutter, and fixing misnested folders.

Idiomatic review for Rust — async/Tokio daemon design, ports-and-adapters trait boundaries, and thiserror/anyhow error handling. Use when reviewing or writing Rust code that defines async trait "ports" (dependency-inversion boundaries), runs a single-threaded Tokio daemon (current_thread runtime + LocalSet/spawn_local), or crosses a wire/domain type boundary. Covers async fn in traits vs async-trait, Rc/RefCell vs Arc/Mutex, tokio::select! cancel-safety, blocking calls in async context, thiserror-vs-anyhow error typing, wire/domain type separation, and common anti-patterns (clone in hot loops, overly generic port bounds). NOT for pure performance/profiling work (see rust-profiling, rust-perf-tuning, rust-memory-optimization, rust-parallel-processing) or unsafe/CLI/wasm-bindgen review (no dedicated skill yet — use the sdd:6-verify research-agent fallback for those).

Design and iterate on logos using SVG. Use this skill when the user asks to "create a logo", "design a logo", "make me a logo", "iterate on this logo", "logo for my project", or discusses logo design, branding icons, or wordmarks.

Work out W-4 withholding elections (new job, job change, mid-year income jump, or an annual check-up) using the official IRS Tax Withholding Estimator, and translate the result into concrete W-4 form entries.

Apply idiomatic, well-structured Go development practices. Use when writing, reviewing, or refactoring Go code. Covers error handling, interfaces, concurrency, testing, naming, project structure, type-system maximization (generics, embedding, iota, receivers), primitive-obsession fixes, and anti-patterns based on Effective Go, Go Code Review Comments, and Go Proverbs.

Choose and apply the right Go concurrency primitive — channels, mutexes, atomics, copy-on-write, singleflight, and lock-free data structures. Use when designing concurrent access to shared state, diagnosing lock contention (paired with go-profiling), choosing between sync.RWMutex and atomic.Pointer copy-on-write, evaluating concurrent map options (sync.Map vs xsync.MapOf), implementing singleflight request coalescing, or reaching for a lock-free queue/ring-buffer library. Covers stdlib sync/atomic, golang.org/x/sync, puzpuzpuz/xsync, Workiva/go-datastructures, and golang-design/lockfree.

Improves existing docs/journeys/*.md spec files — fills in gaps flagged by journeys-extract, refines vague steps, and links plausible test_ids by searching the repo's test suite — without a full rediscovery pass and without clobbering fields owned by journeys-verify. Always proposes a before/after diff and waits for explicit approval before writing (plan-validate-execute), then applies via journeys-extract's upsert script so the verified→stale invariant stays enforced in one place. Use when a journey is marked draft or stale and needs deepening or test-linking — not for discovering new journeys (journeys-extract) or for mechanically checking existing links (journeys-verify).

Extracts user journeys from an app's existing code into persistent, declarative markdown+YAML spec files under docs/journeys/ — one file per journey, each with a stable journey_id and frontmatter fields for test linkage (test_ids, status, last_verified) that journeys-verify and journeys-enrich own and update later. Uses three parallel lean agents (PM story-map backbone, UX flow analysis, Mermaid diagram generation) to discover journeys, then upserts by journey_id so re-running never duplicates or clobbers verification state. Use when journeys aren't documented yet, or to rediscover/add journeys after major app changes. This is the extraction phase only — it does not check whether journeys still work (journeys-verify) or fill in narrative detail on existing drafts (journeys-enrich).

Verifies that docs/journeys/*.md spec files (written by journeys-extract) still hold true — every source_ref path still exists and every test_id is still findable in the repo's test suite. Runs a cheap deterministic script (Tier 1, safe for CI/pre-commit on every PR) that flips each journey's status between draft/verified/stale, plus an optional LLM semantic-drift pass (Tier 2, per journey, checks whether the narrative still matches the actual UI/code) for a fuller review. Use to check journeys are still accurate — for a quick CI gate ("is anything broken"), or before trusting a journey doc during onboarding or planning. Does not discover new journeys (journeys-extract) or improve/deepen journey content (journeys-enrich).

Bootstrap a new personal/side project using Tyler's researched default app stack (Angular, Rust+Axum, Connect-RPC/WebSocket, GCP Cloud Run, Neon+R2, OpenTofu). Runs a short decision interview to adapt the defaults (KMP-sharing frontend, Firebase migration, personal vs production scale) then scaffolds the full repo — build files, RPC/proto layer, multi-environment IaC (staging+prod), CD pipeline (Workload Identity Federation, build/push/deploy), local dev via Neon Local, sqlx migrations tooling, secrets/.env conventions, quality tooling, and CLAUDE.md/AGENTS.md referencing the /sdd:full, journeys-extract, and pm-brand-strategy skills for ongoing development. Use when starting a new personal project, asking "what stack should I use for this", or "bootstrap a new project".

Apply software architecture best practices when designing or reviewing systems, classes, modules, or services. Use when structuring new code, evaluating design decisions, applying SOLID principles, Clean Architecture, Hexagonal Architecture, or Domain-Driven Design patterns. Works across languages — includes specific guidance for Python and Java/Spring Boot.

Best practices for the AWS Strands Agents SDK — structuring prompts, multi-agent patterns, structured I/O, and splitting monolithic agents into specialists. Use when designing or refactoring Strands-based agent systems.

Evaluate new Claude and Claude Code techniques, tools, features, prompting patterns, or workflow changes for adoption value. Use when encountering blog posts, release notes, tutorials, community tips, or configuration changes related to Claude and want to assess whether they fit the user's existing workflow (Logseq wiki, Python tools monorepo, skills library), align with Anthropic best practices, and are worth adopting. Produces structured evaluations with go/no-go recommendations and integration paths.

Audit a SKILL.md file for missing cross-references to related skills, or map a task description to the skills that should be combined to handle it. Writes inline section callouts and "Related Skills" tables using the canonical pattern. Use when improving an existing skill, building a new one, or determining which skills to activate for a complex multi-domain task.

Standards for writing standalone Python scripts — UV inline deps, loguru logging, typer CLI, exit codes, and the canonical script template. References python-dependency-management for dep management.

Create a new Claude Agent Skill following Anthropic's best practices with prompt engineering guidance

Encode invariants and business logic into the type system so illegal states are unrepresentable. Use when designing domain models, reviewing code for primitive obsession, building Value Objects, modeling state machines, or applying Parse-Don't-Validate. Covers Go, Python, and Java with concrete before/after examples.

Find, validate, and compare home renovation products (fixtures, hardware, appliances, finishes) with confirmed working image URLs and product links, plus community review and longevity research per candidate. Handles retailer bot-protection by routing image sourcing through accessible CDNs. Runs a structured discovery interview first to narrow requirements before searching. Output is a comparison table ready to paste into a wiki page or shareable email. ALWAYS trigger this skill when the user asks to find, research, compare, or select any physical product for the 711 N 60th remodel or any home improvement project — even if they don't say 'product selection' explicitly.

How to research community reviews and longevity signals for a physical product — where to look, how to weigh sponsored vs. organic sources, and how to read warranty/repairability/failure-mode signals as durability proxies. Use as a sub-step inside a larger research or product-selection process, not as a standalone entry point.

Forces the laziest solution that actually works, simplest, shortest, most minimal. Channels a senior dev who has seen everything: question whether the task needs to exist at all (YAGNI), reach for the standard library before custom code, native platform features before dependencies, one line before fifty. Supports intensity levels: lite, full (default), ultra. Use whenever the user says "ponytail", "be lazy", "lazy mode", "simplest solution", "minimal solution", "yagni", "do less", or "shortest path", and whenever they complain about over-engineering, bloat, boilerplate, or unnecessary dependencies.

Ground architecture/refactoring reviews in tool-generated evidence instead of code-reading alone — static coupling graphs (package dependency, call graph, struct/interface size) plus temporal coupling (files that change together in git history, independent of imports) combined into a complexity × churn hotspot score. The open-source technique behind CodeScene. Use before `architecture-review`/`find-refactor-candidates` to find WHERE to look; use those commands to analyze WHY once you're there.

Validates all [[wiki links]] and

Guide through creating a new purpose-built agent for specialized tasks with proper configuration

Use this skill when breaking a large change into a stack of reviewable PRs with git on GitHub. Works in stages — evaluate changes, plan dependencies and ordering, execute the stack, then ship each PR through CI using the pr-ship workflow. Primary tool is git-machete. Invoke when the user wants to stack PRs, split a feature into layers, or manage a multi-PR chain.

Use this skill when breaking a large change into a stack of reviewable PRs with git on GitHub. Works in stages — evaluate changes, plan dependencies and ordering, execute the stack, then ship each PR through CI using the pr-ship workflow. Primary tool is git-machete. Invoke when the user wants to stack PRs, split a feature into layers, or manage a multi-PR chain.

Execute an implementation plan by dispatching fresh subagents per task with dual-review (spec compliance + code quality). Use when running sdd:5-implement or executing any multi-task implementation plan.

Idiomatic review for Kotlin Multiplatform (KMP) with Kotlin 2.x — expect/actual discipline, Swift boundary safety, ViewModel lifecycle, SQLDelight conventions

Scan Gmail for clothing purchase receipts, extract item details (brand, product, color, size, price, purchase date), download product images, then catalog each item in the Logseq wiki: update Wardrobe.md in the correct section, create/update brand pages, and link to the product page, Internet Archive snapshot, and original receipt email. TRIGGER when the user wants to sync recent clothing purchases to their wiki, catalog new wardrobe items from email receipts, or audit what they've bought.

Hub skill for Rust development. Covers the full workflow from profiling → performance diagnosis → CPU/memory optimization → parallelism. Routes to the right specialist skill based on the symptom. Links all four Rust skills: rust-profiling, rust-perf-tuning, rust-memory-optimization, rust-parallel-processing.

Execute a full bidirectional sync between the personal fork (origin) and the work upstream (upstream-fanatics). Creates a dated integration branch, resolves known conflict patterns, runs CI checks, opens two PRs (fork→upstream and upstream→fork), and monitors until checks pass. Use after /fork-merge-plan or whenever both repos have diverged and need to be brought back in sync.

Design and document a port assignment strategy for local development environments. Use when setting up new projects, resolving port conflicts, or establishing team conventions for port usage across services.

Reduce Rust memory usage, eliminate allocation churn, size types precisely, apply custom allocators and arenas, build bounded telemetry buffers, and detect leaks. Covers the full cycle: measure → diagnose → fix → verify. Companion to rust-profiling (CPU flamegraphs) and rust-perf-tuning (CPU throughput).

Exploit CPU, GPU, and multi-machine parallelism in Rust. Covers rayon (data parallelism), tokio (task/async parallelism), SIMD (auto-vectorization + wide crate), wgpu/cudarc/candle (GPU compute and ML), tonic/tarpc/quinn (multi-machine RPC), MPI/ractor/DataFusion (HPC and distributed), algorithm patterns (map-reduce, pipeline, work-stealing, SPMD), profiling parallel programs, and common anti-patterns. Companion to rust-profiling (collect data first) and rust-perf-tuning (single-core fixes).

Diagnose Rust performance bottlenecks from profiling data and apply targeted optimizations. Covers the full cycle: measure → profile (see rust-profiling skill) → diagnose → fix → verify. Includes pattern-matched fixes for common flamegraph hotspots, allocation elimination, data layout, compiler settings, and parallelism tuning.

Profile Rust binaries and benchmarks using cargo-flamegraph, samply, perf, and heaptrack. Covers CPU flamegraphs, collapsed stacks for LLM analysis, memory profiling, criterion benchmark profiling, and interactive Firefox Profiler UI.

Complete browser automation with Playwright. Auto-detects dev servers, writes clean test scripts to /tmp. Test pages, fill forms, take screenshots, check responsive design, validate UX, test login flows, check links, automate any browser task. Use when user wants to test websites, automate browser interactions, validate web functionality, or perform any browser-based testing.