Claude Skills by Amey-Thakur

Work out whether one customer or one transaction makes money, before scaling anything. Use when deciding to grow, raise prices, or cut costs, and when growth is not producing profit.

Diagnose churn through cohort decomposition, leading indicators, and exit evidence, then fix causes over symptoms. Use when retention is slipping or a churn-reduction effort needs a target.

Grow product and open-source communities through seeded value, working moderation, and contributor ladders. Use when starting a community or reviving one that went quiet.

Reach developers through docs, honest content, and community trust instead of ads they ignore. Use when marketing developer tools or building a devrel content engine.

Build landing pages with a clear message hierarchy, credible proof, and one decisive call to action, tested where it matters. Use when creating or fixing pages that must convert visitors.

Define and read MRR, churn, NRR, CAC, and LTV correctly, with cohort views and benchmark honesty. Use when building SaaS financial dashboards or diagnosing growth quality.

Price SaaS around a value metric with tier design, seat-vs-usage decisions, and low-risk price testing. Use when setting or revisiting software pricing and packaging.

Make sites crawlable, fast, and structured so search finds what deserves finding, without tricks that expire. Use when improving organic traffic or auditing a site's search health.

Move new users to their first value moment fast by defining activation, instrumenting the funnel, and cutting time-to-value. Use when signups do not become engaged users.

Run write-first collaboration with the right document types, response-time norms, and meetings reserved for what writing cannot do. Use when improving distributed-team communication or cutting meeting load.

Get talks accepted and deliver them well through audience-first proposals, narrative structure, and rehearsed, demo-safe delivery. Use when proposing or preparing a technical talk.

Write engineering resumes with quantified impact bullets, honest tailoring, and machine-readable formatting. Use when writing or reviewing a technical resume.

Deliver feedback with situation-behavior-impact structure, timeliness, and care calibrated to stakes. Use when correcting course, recognizing work, or preparing a hard conversation.

Grow engineers through goal-anchored mentoring, calibrated stretch work, and questions before answers. Use when mentoring individuals or building a team's growth practice.

Run one-on-ones the report owns, splitting career growth from status, with notes that compound. Use when establishing 1:1 practice as a manager or getting more from 1:1s as a report.

Receive feedback by listening past delivery, extracting the signal, and closing the loop with visible action. Use when getting reviews, criticism, or hard performance conversations.

Negotiate offers with market data, competing leverage, whole-package thinking, and a clear stopping point. Use when handling a job offer or a raise conversation.

Write status updates with progress, risk, and asks calibrated to the audience, honoring the no-surprises rule. Use when reporting project status upward or fixing updates nobody reads.

Prepare for and perform in technical interviews with a practice system, aloud reasoning, and honest calibration. Use when preparing for coding, system design, or behavioral rounds.

Design autoscaling on the right metric with velocity controls, warm capacity, and flap prevention. Use when configuring autoscaling or diagnosing oscillation, lag, and cost spikes in scaled fleets.

Cut cloud spend with tagging, rightsizing, commitment mix, and egress awareness, without breaking reliability. Use when the cloud bill needs reducing or a cost-review practice needs standing up.

Build disaster recovery around RTO/RPO tiers, verified backups, and drills that prove the numbers. Use when writing a DR plan or testing whether the existing one actually works.

Migrate workloads to the cloud with honest 6R triage, dependency mapping, and rehearsed cutovers with rollback. Use when planning a datacenter exit or moving systems between clouds.

Lay out VPCs, subnets, private connectivity, and DNS so services reach each other privately and the internet only on purpose. Use when designing cloud network topology or debugging cross-service connectivity.

Match data to object, block, or file storage tiers by access pattern, consistency, and cost per operation. Use when choosing cloud storage for a workload or auditing storage spend and latency.

Structure cloud IAM with role-based access, short-lived credentials, and permission boundaries that hold at scale. Use when designing cloud access control or cleaning up accumulated permissions.

Manage infrastructure through declarative code with sane module design, state hygiene, and plan-review discipline. Use when adopting Terraform-style IaC or refactoring a sprawling configuration.

Configure Kubernetes workloads with correct requests, probes, disruption budgets, and workload types. Use when deploying services to Kubernetes or debugging evictions, OOMKills, and rollout failures.

Decide between managed services and self-hosting with honest TCO, lock-in assessment, and exit paths. Use when choosing infrastructure components or revisiting a costly managed dependency.

Choose between active-passive and active-active multi-region architectures with eyes open to data, cost, and failover reality. Use when regional resilience or data residency forces the multi-region question.

Decide where functions-as-a-service fit using cold-start, limit, and cost-crossover math. Use when choosing between serverless and containers, or rescuing a serverless design that hit its limits.

Keep the public API small by defaulting to private visibility and retiring symbols through deprecation before deletion. Use when designing a module's exports or reviewing what a package exposes to callers.

Place assertions where invariants are established or must hold: constructors, public boundaries, and loop bodies. Use when hardening code whose silent violations would otherwise surface far from their cause.

Replace opaque boolean flags with named enums or split functions so call sites read without the definition open. Use when a signature takes a bare boolean or a function branches on a mode flag.

Leave every file you touch marginally cleaner without expanding the change beyond its purpose. Use when editing code for one task and you notice small decay worth fixing in passing.

Find dependency cycles between modules and break them with layering, interface extraction, or dependency inversion. Use when imports form a loop that blocks compilation, isolated testing, or clear reasoning about load order.

Write comments that record why the code is shaped as it is, and delete the ones that only restate it. Use when adding, reviewing, or pruning comments in a codebase.

Decide when repeated code should be unified and when a duplicate is the cheaper choice. Use when tempted to extract a shared helper or facing copy-pasted code.

Hand formatting to an opinionated tool run automatically so the team stops arguing style and diffs stay readable. Use when adopting a formatter, onboarding a repo, or cleaning up noisy review diffs.

Read code metrics as smoke that points at where to look, not as verdicts that rank code good or bad. Use when triaging a large codebase for refactoring targets or reviewing metric-gated quality checks.

Understand unfamiliar code quickly by tracing real execution paths rather than reading files in order. Use when joining a codebase, reviewing an unfamiliar area, or debugging something you did not write.

Write review comments that land by labeling severity and separating genuine questions from directives. Use when leaving comments on a pull request or coaching someone on how theirs read.

Review code changes for correctness, security, and maintainability with severity-ranked, evidence-based findings. Use when asked to review a diff, a pull request, or a file before merge.

Cut the working memory a reader needs to follow code through locality, one idea per line, and naming that carries context. Use when a function makes reviewers scroll back, re-read, or hold several facts to grasp one line.

Measure a function's branching complexity and reduce it so the logic stays testable. Use when a function has many paths, deep nesting, or a long if or switch chain.

Find code that can never run and delete it without breaking a caller you missed. Use when pruning unused functions, branches, feature flags, or files.

Validate untrusted data once at the boundary, then trust invariants inside and fail loudly if they ever break. Use when writing entry points, constructors, or any code that must not proceed on bad state.

Design error handling that fails loudly, recovers deliberately, and tells the person exactly what to do. Use when writing failure paths, retries, or user-facing errors.

Write error messages that name the specific thing, show the offending state, and state the fix as an action. Use when writing any thrown exception, log line, or user-facing failure text.

Make switch and match statements provably total so adding a case forces every site to handle it, with no default that hides the gap. Use when branching over an enum, union, or sealed type.