Claude Skills by nafeeur

Design system architecture with explicit requirements, boundaries, data flows, tradeoffs, failure modes, and evolution paths.

Design and implement reliable local or network APIs with validation, streaming, cancellation, observability, and stable contracts.

Automate and verify browser workflows using accessibility-first locators, deterministic waits, screenshots, and failure artifacts.

Repair broken builds, type checks, packaging, and startup paths across environments with minimal, verifiable changes.

Create and repair CI/CD pipelines with caching, parallelism, reproducibility, artifacts, and actionable failures.

Review changes for real correctness, maintainability, regressions, missing tests, and integration defects with low-noise findings.

Build and maintain scalable repository indexes for lexical, structural, symbol, and semantic retrieval with bounded context.

Implement and debug modern C++ and Qt applications, including signals/slots, models, threading, CMake, rendering, and ownership.

Analyze datasets reproducibly, validate quality, calculate defensible metrics, and produce clear artifacts.

Evolve persistent schemas safely with compatible migrations, backfills, rollback strategy, and integrity checks.

Diagnose and repair software failures using evidence, reproduction, instrumentation, and regression tests rather than speculative edits.

Upgrade libraries and runtimes with compatibility research, focused changes, lockfile integrity, and regression verification.

Containerize and operate development services with reproducible images, health checks, persistent state, and clear networking.

Write accurate user, operator, API, and architecture documentation grounded in the implemented product.

Implement production features end to end, including integration, error states, tests, documentation, and verification.

Use Git worktrees and checkpoints for parallel agents, isolated changes, review, integration, and recovery.

Implement idiomatic Go services and tools with context propagation, interfaces, concurrency discipline, and tests.

Diagnose and stabilize production incidents, preserve evidence, restore service, and produce actionable follow-up work.

Build and integrate MCP servers and clients across modern 2026 stateless and legacy initialization-based protocol revisions.

Modernize legacy code or frameworks incrementally while preserving behavior, interoperability, and delivery velocity.

Profile and optimize latency, throughput, memory, context usage, and startup costs using measured bottlenecks.

Create modular MaskShift plugins that add tools, skills, providers, hooks, UI panels, or MCP catalog sources without coupling core policy.

Create evaluations for agent prompts, tool routing, context retrieval, and coding outcomes using reproducible tasks and scoring.

Build maintainable Python applications and automation with typed boundaries, packaging, environments, tests, and robust subprocess handling.

Restructure code safely while preserving behavior, reducing duplication, clarifying ownership, and maintaining compatibility.

Prepare reproducible production releases with versioning, changelogs, packaging, smoke tests, and rollback notes.

Map unfamiliar repositories and identify the correct files, dependency paths, conventions, and verification commands before implementation.

Implement reliable Rust systems with ownership-aware design, errors, async cancellation, tests, and workspace conventions.

Implement numerically sound scientific and engineering software with units, validation, reproducibility, and performance awareness.

Audit code and dependencies for concrete exploitable weaknesses while preserving MaskShift’s intentionally permissive local execution philosophy.

Capture durable, non-obvious workflow knowledge as reusable skills and improve it from verified outcomes.

Design and implement high-signal unit, integration, end-to-end, property, and regression tests for changed behavior.

Build strict TypeScript applications with stable runtime validation, modular architecture, and browser/server correctness.

Inspect web user interfaces for clipping, overlap, responsiveness, focus, loading, empty, error, and interaction-state defects.

Research changing technical facts from primary sources and convert findings into implementation decisions with traceability.

Build MaskShift terminal interfaces in the MaskShift design system — tokens over hex values, one marker gutter per pane, one filled chip per screen, and the ANSI width discipline that keeps a TUI aligned.