Claude Skills by mcorbett51090

Distinguish in-scope iteration from additional services and authorize the difference, so unbilled changes don't erode the fee. Reach for this when the design keeps changing.

Read the drawing set for cross-discipline coordination and constructability, since a coordinated set beats a beautiful one. Reach for this in CD.

Build a fee that matches the effort curve across the design phases, not a flat percentage, so the heavy phases aren't underwater. Reach for this on any fee proposal.

Read utilization and net multiplier to separate a busy firm from a profitable one. Reach for this on a practice-health question.

Read the RFI and change-order pattern as a coordination signal to improve the next set, not just process this one. Reach for this when RFIs are high.

Pick the right audio-DSP architecture for a described product by traversing the audio-DSP architecture decision tree (latency tolerance → processing model → time-vs-frequency domain → fixed-vs-float + denormals → platform/plugin format + audio I/O), then return the recommended processing model, latency & buffer-size budget, sample rate/bit depth, numeric strategy, algorithm approach (IIR/FIR/FFT-STFT, oversampling), framework + plugin format + audio backend, and the conditions that would flip...

From an effect or product goal and its architecture, derive the signal-processing chain — the block diagram (stage order), the per-stage algorithm (IIR biquad / FIR / FFT-STFT / delay / dynamics), the per-stage and total latency, the sample rate and gain-staging/headroom, the oversampling plan for any nonlinearity, and the parameter list with smoothing needs — captured in the DSP design spec. Reach for this when the user asks "design the effect chain for this", "what order should these proces...

Implement a DSP stage as real-time-safe code in the audio callback (no locks, no allocation, no syscalls, no unbounded work — everything pre-allocated at prepare time), handle denormals with flush-to-zero, pass parameters lock-free (atomic / SPSC FIFO) with per-sample smoothing, then optimize the profiled hot loop with SIMD (SSE/AVX/NEON/CMSIS-DSP) and verify with objective measurement (null test, THD+N, impulse/frequency response, RT-safety audit). Reach for this when the user asks "write th...

Add a login method to an existing Supabase Auth app — Apple, Microsoft, GitHub social SSO, plus magic link, passkeys (WebAuthn), or email+password. The generic enable-provider procedure with each provider's gotchas (especially Apple's expiring ES256 secret + first-login name capture). Generalizes google-sso-setup to the variety pack.

RBAC and ABAC in the application layer: defining roles and claims, mapping the authenticated identity to roles, enforcing roles in middleware and UI. The critical seam: row-level data scoping hands off to data-platform RLS via auth.uid(). Authentication proves identity; authorization controls access.

Put the analytics dashboard and embedded BI behind login: app-shell login gate + session check + the handoff to data-platform's embed-JWT and RLS for per-user data isolation. The clearest expression of the auth-identity → data-platform seam.

Wire Sign in with Google end-to-end: Google Cloud OAuth client + consent screen + redirect URIs + scopes, then via Supabase Auth's Google provider (and a note on the Auth.js / direct path). Step-by-step with verification checkpoints.

Pick and implement the right OAuth 2.0 / OIDC flow by client type: Authorization Code + PKCE for SPA and native apps, confidential-client code flow for server-side apps, client-credentials for M2M. ID-token vs access-token vs refresh-token handling. Deprecated Implicit flow is never recommended.

Protect a React/Next.js SPA with route guards and middleware, and protect an API with token-verification middleware (signature + iss + aud + exp). Covers CORS configuration and CSRF defense. Applies to both the web-app and the API/backend targets.

Session vs JWT trade-offs; HttpOnly+Secure+SameSite cookie storage; refresh-token rotation; logout and revocation; storage anti-patterns (no tokens in localStorage or sessionStorage). The post-sign-in half of the auth lifecycle.

Read a repair shop's two profit engines separately: labor GP (effective labor rate x billed hours minus tech cost) and parts GP (the matrix over cost). Measure effective labor rate as posted rate minus discounts, warranty, comebacks, and unapplied time. Benchmarks verify-at-use; no PII.

Turn a write-up and a digital vehicle inspection (DVI) into a sold, defensible estimate: verified complaint, diagnostic authorization, DVI evidence per line, labor-guide hours x shop rate, parts at matrix, sell-now vs sell-later triage, and declined-work follow-up. Labor times/rates verify-at-use; no PII.

Run the repair order from open to closed and stop comebacks at the root cause: WIP/RO aging triage (waiting on approval vs parts vs tech), parts staging before dispatch, and comeback grouping by cause (misdiagnosis, workmanship, part quality, incomplete, no-fault). Rework labor is billed at zero. No PII.

Diagnose a repair shop's labor throughput with the three distinct dials: productivity (clocked/available), efficiency (billed/clocked), and proficiency (billed/actual). Match dispatch to skill, read them separately, and fix the right one. Benchmarks verify-at-use; no PII.

Compute the service absorption rate against total fixed overhead — the survival metric. Reach for this on a fixed-ops question.

Compute total gross per unit as front plus F&I back, with penetration. Reach for this on a deal-profitability question.

Diagnose the lead-to-sold funnel by conversion step — a volume gap is usually a conversion gap. Reach for this on a sales-volume question.

Frame F&I product penetration and PVR back-end gross inside the compliance boundary. Reach for this on an F&I question.

Read inventory days-supply against a target and quantify floorplan carrying cost. Reach for this on an inventory question.

Design a multi-account AWS landing zone: separate accounts by blast radius (prod/non-prod/security/shared-services) under Organizations, SCP guardrails as ceilings, region/AZ resilience, and the Control-Tower-or-not decision.

Choose AWS compute by workload shape and operational burden: Lambda (event/spiky), Fargate/ECS Express Mode (containers, no cluster ops), EKS (k8s/portability), EC2 (legacy/specific); design event-driven integration with idempotency and DLQs.

Control AWS cost: cost allocation tags from day one, budgets + anomaly detection, rightsize before committing to Savings Plans/RIs, tested backups, and continuous zombie-resource cleanup.

Write least-privilege AWS IAM: scope actions and resource ARNs to exactly what's needed, attach to roles (not users/keys), prefer federation (IRSA/OIDC) and Identity Center, and cap with permission boundaries + SCPs.

Step-by-step playbook for wiring CloudWatch metrics, alarms, dashboards, and X-Ray distributed tracing into an AWS workload — from log groups and metric filters to composite alarms and anomaly detection.

Step-by-step playbook for designing an AWS VPC — CIDR allocation, subnet layout, routing, security groups vs NACLs, egress control, and PrivateLink/VPC endpoint placement. Covers single-VPC through multi-account Transit Gateway topologies.

FinOps playbook for diagnosing Azure overspend and rightsizing resources — covers Cost Management query patterns, compute/storage/Log Analytics levers, reservation vs savings plan decisions, and the budget-alert setup checklist.

Playbook for writing production-ready Bicep modules — parameter hygiene, AVM alignment, what-if verification, output contracts, and the CI/CD integration checklist. Covers both standalone and AVM-wrapper patterns.

Decision playbook for choosing the right Azure compute service — App Service, Container Apps, Azure Functions, Static Web Apps, or AKS — based on workload shape, ops burden, and scaling requirements.

Step-by-step playbook for locking down Azure PaaS services (Key Vault, Storage, SQL, Cosmos) behind Private Endpoints with Private DNS — covers DNS zone setup, NSG rules, and the disable-public-access checklist.

Playbook for configuring passwordless CI/CD using Workload Identity Federation — covers app registration, federated credential setup for GitHub Actions and Azure DevOps, RBAC assignment, and the OIDC token exchange flow.

Playbook for implementing consumer-driven contract tests (Pact) between backend services so API contract breaks surface in CI before they reach integration environments.

Implement business logic cleanly: keep the framework at the edges with logic in testable use-cases, model errors explicitly (expected vs bug), validate inputs into domain types at the boundary, add idempotency keys for retried operations, and use the outbox for write-then-publish.

Make the backend survive its dependencies: timeout every outbound call, retry idempotent-only with exponential backoff + jitter, add circuit breakers and bulkheads, define a graceful-degradation mode, and design idempotent background workers with DLQs and backpressure.

Own the data-access layer: queries behind a repository, short explicit transaction boundaries (never across HTTP), kill ORM N+1 by eager-loading/batching, and cache-aside with a defined invalidation trigger plus stampede (single-flight) protection.

Playbook for modeling and propagating errors in backend services — typed result/error envelopes, failure classification, HTTP status mapping, error translation at layer boundaries, and client-safe vs internal error separation. Prevents exception-driven spaghetti and accidental information leakage.

Decide backend structure: default to a modular monolith, split into services only for a concrete need (scaling, team autonomy, deploy/runtime isolation), draw boundaries by bounded context (each owning its data), and choose sync vs async per seam.

Read note timeliness and medical-necessity completeness as one revenue-and-compliance control — operationally, never as a clinical judgment. Reach for this on a denial or audit-readiness question.

Quantify no-show/late-cancel as a flow — lost slots, lost revenue, and the recovery a reminder program delivers. Reach for this on a no-show question.

Read reimbursement net of variable cost by payer, compute blended margin, and model a mix shift — flagging parity for counsel. Reach for this on a payer or margin question.

Read intake-to-first-appointment access time as the conversion lever and find where the delay loses referrals. Reach for this on an access or conversion question.

Size clinician caseload capacity against measured demand and the no-show-adjusted fill rate, not a guessed ratio. Reach for this on a staffing or utilization question.

Pick the right genomics workflow engine, reference build, tool chain, compute strategy, and reproducibility approach for a described analysis by traversing the bioinformatics pipeline decision tree (assay/question → curated community pipeline exists? → portability/team fluency → HPC vs cloud → reference build), then return the recommended engine (Nextflow/nf-core / Snakemake / WDL+Cromwell / CWL), the reference (GRCh38 vs T2T-CHM13) with the build hazards, the aligner/variant-caller chain, th...

From a scientific question, an assay, and a sample design, derive the concrete genomics analysis workflow — the per-sample step graph (QC, trimming, alignment, dedup, BQSR-or-not, variant calling or quantification), the cohort/joint step (joint genotyping or differential-expression model), the reference build and its matching accessory files, and the validation truth set — captured as an analysis plan. Reach for this when the user asks "design the WGS germline workflow", "what steps does this...

Implement a designed genomics workflow in the chosen engine, containerize and pin every tool for reproducibility, scale it with scatter/gather on HPC Slurm or cloud Batch (spot on the fault-tolerant steps), and validate it against a GIAB/GA4GH hap.py truth set — then produce a pipeline-validation report. Reach for this when the user asks "build this pipeline in Nextflow/Snakemake/WDL", "containerize and pin it for reproducibility", "scale/cost-optimize this on Slurm or cloud", or "benchmark o...

Gate deploy on a security audit and invariant tests across the top vuln classes — deploy is irreversible. Reach for this before any mainnet go-live.