Claude Skills by snoodleboot-io

Comprehensive guide for creating entity relationship diagrams using Mermaid syntax

Messaging systems fall into three fundamental shapes, and most bad choices come

Every synchronous call does two things beyond transferring data: it adds the

A model in production is never just weights.

Software CI assumes a git sha plus a lockfile determines the build.

Every metric encodes an opinion about which mistake hurts.

\"Make it interpretable\" is four different requests.

The layers trade timeliness against definitiveness.

Run this before anything else.

\"Multi-cloud\" is a loose word that hides four distinct architectures with

Run a genuinely-parallel multiagent implementation with detailed guidance - plan, gate on environment, spawn subagents concurrently, aggregate, and debug/retry

Line coverage answers \"did this line execute during the test run\".

Relational modelling lets you defer query design: normalize the entities, and

Almost every object-storage mistake comes from carrying filesystem instincts into

The instruction to profile before optimizing survives because intuition about

Comprehensive checklist for documenting follow-up work and testing needs after implementation

A stakeholder asks to make search faster.

rate(http_requests_total[5m])

Type hints are checked by a separate tool (`mypy`, `pyright`), never by CPython

\"Quality\" is unmanageable until it is a set of numbers with agreed definitions.

Both directions produce working layouts, but very different amounts of CSS.

1.

Serverless is a billing-and-scaling model, not a badge of modernity.

**SLO (Service Level Objective):** What we promise (99.9%)

**When:** Not important (contact info)

Always start with EXPLAIN ANALYZE to understand execution:

The single highest-leverage decision is recognizing that most of what teams call

Ownership models are usually inherited rather than chosen, and the inherited one

Before writing anything, answer three questions: who reads this, what do they

Debt that exists only in engineers' heads cannot be prioritised, funded, or

The single most useful question before analysing anything is: *what does it cost

Apply Arrange-Act-Assert pattern for clear, maintainable tests with detailed guidance

Comprehensive systematic approach to achieving complete test coverage through structured category-based testing

These three are not interchangeable, and picking the wrong one is the root of a

Comprehensive guidelines for when and how to use mocks, stubs, and fakes in tests

Three shapes get argued about as if one were correct.

Every methodology — STRIDE, PASTA, LINDDUN, attack trees — is a technique for

Almost every downstream bug traces back to an index that was assumed regular and

Find rare, unexpected observations in data where labels are scarce or absent, and evaluate the result in a way that survives extreme class imbalance.

"Anomaly" covers three distinct problems, and a detector built for one is close to useless on the others.

Concrete configuration that shrinks an API's attack surface at the edge and in the runtime — transport, CORS, limits, headers, and egress.

TLS is either configured deliberately or inherited from a distro default written years ago. Pin the protocol floor and let 1.3 negotiate its own suites.

Identify and close the failure modes specific to APIs — where the caller is a program, every endpoint is directly reachable, and the UI enforces nothing.

An API has no UI to hide things behind. Every identifier a client has ever seen is an identifier it can replay against every endpoint. The dominant API vulnerability class — broken object-level authorization — is not a missing authentication check; the attacker is fully authenticated as themselves.

Evolve an API without breaking clients you do not control, and retire old shapes on a schedule instead of by surprise.

Versioning exists because you cannot deploy your clients. Once a third party — or your own mobile app sitting in an app store review queue — depends on a response shape, that shape is a contract, and the only safe assumption is that some caller depends on every observable detail of it.

Record the structure of a system and the reasoning behind it, so that the next engineer can change it without re-deriving every decision from scratch.

An ADR records one decision at the moment it is made, with the information that was actually available. Its value is not the decision — that is visible in the code — but the *forces*: what was considered, what was rejected, and what the choice costs. Six months later the code shows what; only the ADR shows why.

Design authentication that proves who a user is, without leaking credentials or sessions.

Authentication starts with never holding the secret you are checking. Store a verifier — a slow, salted hash — not the password.