← all publishers

nahid-sparktales

@nahid-sparktales source repo

Report this profile Claim this profile

• 80 skills
• 0 followers
• 4 hours ago last updated

1. ▌
   Frontend Performance · nahid-sparktales bundle

   Make a page measurably faster — pick the metric that is actually bad, measure it under stated conditions, find the real cause, apply the fix that moves that specific metric, re-measure the same way. Use when a page is called slow, when LCP, CLS, INP, TTFB, a Lighthouse score or bundle size is named, when a bundle has grown, or before claiming an optimization worked. Not for backend query or API latency, not for choosing a framework, and not a substitute for checking the page still works afterwards.
   0 installs
2. ▌
   Performance Profiling · nahid-sparktales bundle

   Find where the time actually goes before changing anything — define the metric and workload, build a repeatable baseline with its spread, profile on the right axis, confirm the suspected hotspot by removing its work, then re-measure under identical conditions. Use when something is slow, when an optimization is about to be written from a hunch, or when a speedup is being claimed without comparable numbers. Not for reading code to guess what is expensive, not for micro-tuning with no measured user impact, and not a licence to profile production without asking.
   0 installs
3. ▌
   Competitive Analysis · nahid-sparktales bundle

   Compare products, libraries or approaches on criteria derived from your own constraints rather than from anyone's feature list, and fill each cell with evidence you obtained — hands-on trial, primary docs, source, issue tracker — marking clearly what is only a vendor claim. Use when choosing between real alternatives, when asked how something stacks up against the competition, or when a decision is being made from a marketing comparison table. Not for general investigation method, not for judging a single source, and not for writing positioning or marketing copy.
   0 installs
4. ▌
   Idempotency And Retries · nahid-sparktales bundle

   Make an operation safe to repeat — idempotency keys and their storage, what a replay returns, retry policy with backoff and jitter, and how to reconcile after a timeout whose outcome is unknown. Use when an operation has an external side effect (a charge, an email, a provisioning call), when a caller needs to retry safely, or when duplicates have already appeared in production. Not for webhook receipt mechanics, not for database transaction design, and not for choosing a queue.
   0 installs
5. ▌
   Component Architecture · nahid-sparktales bundle

   Decide where a component's boundaries go, where state lives, what its props should be, and whether to split it — using composition instead of configuration flags. Fires when adding a component to an existing tree, when a component has grown props or responsibilities, or when a review asks whether a structure will hold. Not for visual design decisions, not for styling systems, and not a licence to restructure code the task did not ask you to touch.
   0 installs
6. ▌
   API Contract Verification · nahid-sparktales bundle

   Prove an API integration actually works by executing it — success path, documented failure paths, auth failure — and leave behind a contract test that catches the next break. Use before reporting any endpoint, client or third-party integration as working, when asked whether an integration is verified, or when checking someone else's integration work. Not for load or performance testing, not for rendered UI verification, and not a substitute for reading the provider's own documentation.
   0 installs
7. ▌
   Accessibility Verification · nahid-sparktales bundle

   Prove an accessibility claim instead of asserting it — automated scan plus the keyboard, focus, zoom and screen-reader passes a scanner structurally cannot make. Fires before anyone says a screen is accessible or WCAG AA, when signing off UI work, or when an audit result needs checking. Not for making the fixes (accessibility), and it never upgrades a clean scan into a conformance claim.
   0 installs
8. ▌
   Documentation Verification · nahid-sparktales bundle

   Documentation verification
   0 installs
9. ▌
   Database Migration Verification · nahid-sparktales bundle

   Prove a migration did what it claimed — before/after row counts, column checksums, constraint and index state, invariant queries, an exercised application read path, and a rehearsed rollback. Use after a migration has been applied to any environment and before anyone reports it as working, or when reviewing someone else's claim that a migration succeeded. Not for planning or sequencing the migration (that is migrations), and it does not treat a clean exit code, a green CI run, or a backup's existence as proof.
   0 installs
10. ▌
    Regression Testing · nahid-sparktales bundle

    Turn a fixed bug into a test that fails on the old code and passes on the new one. Assert behavior at the cheapest useful level and compare old behavior without reverting unrelated work or leaving scratch files. Use after a fix or when recurring defects lack coverage; not for a new feature's test strategy or an environmental/cosmetic failure.
    0 installs
11. ▌
    Prompt Injection Defense · nahid-sparktales bundle

    Treat everything an agent reads but did not author as data rather than instructions — an explicit trust boundary, a tool set fixed before content is read, consequential calls gated on the user, and destinations that cannot be chosen by the content. Use when an agent reads web pages, retrieved documents, emails, tool results, file contents or another agent's output and can also take actions, when adding retrieval or new tools to an agent, or when reviewing an agent for injection exposure. Not for authentication and authorization design, not for secret management, and never satisfied by "the model did not fall for it".
    0 installs
12. ▌
    Query Optimization · nahid-sparktales bundle

    Make one slow query fast without guessing — capture the plan, find where the time actually goes, change one thing, and measure again on comparable data. Use when a query, endpoint or report is slow and the database is the suspect, when a plan needs reading, or when someone proposes an index with no evidence. Not for modelling decisions about tables and constraints, not an engine feature reference, and not for system-wide performance work where the database has not yet been shown to be the bottleneck.
    0 installs
13. ▌
    Release Verification · nahid-sparktales bundle

    Prove a deployment is healthy rather than merely finished — the revision actually serving asked of the running system, every instance moved, smoke paths walked against the real environment, error rate and latency compared to a pre-deploy baseline. Use after any deploy to a shared environment, before a release is called good, or when checking someone else's claim that it went fine. Not for planning the rollout (deployment) or executing a revert (rollback); it never accepts a green pipeline, a 200 from a health endpoint, or a passing test suite as proof.
    0 installs
14. ▌
    Source Evaluation · nahid-sparktales bundle

    Judge whether a source can carry the weight you are about to put on it — trace it upstream to something primary, check its date and version, name who benefits if you believe it, test whether corroboration is actually independent, and cite it so a reader can reopen exactly what you read. Use before relying on a claim that changes a decision, when two sources disagree, when a number arrives without its method, or when writing citations. Not for running the overall investigation, and not for deciding between products.
    0 installs
15. ▌
    Technical Writing · nahid-sparktales bundle

    Write or repair documentation that stays true to the system it describes — README, setup guide, how-to, API reference, architecture explanation, release notes, runbook — by fixing the reader and the task first, then grounding every factual claim in code you actually read. Use when documentation is being written, restructured or found to be stale, or when a reader cannot get from the docs to a working result. Not for interface strings inside a product, not for persuasive or marketing copy, and not itself proof that the documented commands work.
    0 installs
16. ▌
    Secrets Management · nahid-sparktales bundle

    Keep credentials out of code, logs, bundles and history — one supply path, scoped per environment, rotatable on demand — and run the rotate-first response when one has already leaked. Use when adding or moving a key, token, connection string or signing secret, when a scanner or reviewer finds one committed, when a credential appears in logs or a client bundle, or when rotation is due. Not for deciding what a credential may access, and not for vulnerability advisories in dependencies.
    0 installs
17. ▌
    Secure Code Review · nahid-sparktales bundle

    Review a change or a codebase for security defects with a deliberate reading order — where bugs cluster, trace source to sink, confirm reachability, and write a finding someone can actually fix. Use when asked to security-review a pull request, feature or repository, or before shipping anything touching auth, money, tenancy, uploads or secrets. Not a scanner run (its output is leads), not design-stage threat modeling, and not a penetration test — nothing here authorizes touching a running system.
    0 installs
18. ▌
    Visual Verification · nahid-sparktales bundle

    Prove a UI looks right across every state and viewport it has to survive — enumerate the state matrix, make captures deterministic, compare against a baseline captured the same way, and triage every diff. Use before calling a visual change, a style refactor or a redesign done, when running or trusting a screenshot-comparison suite, and when asked whether a screen still looks correct. Not for judging whether a design is good, not for proving controls actually work, and never on its own sufficient to call a page verified.
    0 installs
19. ▌
    Browser Verification · nahid-sparktales bundle

    Prove a UI change actually renders and works — desktop and mobile, controls operated, console clean. Use before reporting any change to rendered UI as done, when asked whether a screen actually functions, or when checking someone else's frontend work. Not for judging whether a design is good, and not a substitute for tests you intend to keep.
    0 installs
20. ▌
    Systematic Debugging · nahid-sparktales bundle

    Find the cause of a failure by evidence — reproduce it, read what the system actually did, form hypotheses that predict something you have not looked at yet, bisect to the smallest failing case, fix where all callers route through, then re-run the original reproduction. Use when something is broken and the cause is not yet known, when a previous fix did not hold, or when an edit is about to be made because the code "looks wrong". Not for an outage still burning (mitigate first), not for a cause already established that only needs implementing, and not a licence to skip reading the stack trace.
    0 installs
21. ▌
    Dependency Security · nahid-sparktales bundle

    Judge dependency risk instead of reciting it — resolve the advisory to a real path through the lockfile, decide whether the vulnerable code is reachable in this codebase, and pick upgrade, override, removal or a written acceptance. Use when an audit or advisory alert fires, before adding a new dependency, when a lockfile change needs reviewing, or when someone asks whether a named CVE actually affects this project. Not for finding vulnerabilities in code you wrote, not for secret scanning, and a clean audit output is not a claim that the application is secure.
    0 installs
22. ▌
    Design To Code · nahid-sparktales bundle

    Turn a design, mockup, Figma frame or screenshot into implementation that actually matches it — mapping values to the codebase's existing tokens and components, covering the states the design never drew, and listing what the design left ambiguous instead of guessing. Use when handed a design to build, when asked whether an implementation matches its source, or when a build has drifted from the design. Not for deciding what the design should be, and not by itself proof that the screen works.
    0 installs
23. ▌
    Github Actions · nahid-sparktales bundle

    Write and review GitHub Actions workflows that fail honestly and finish fast enough to be trusted — least-privilege permissions, untrusted pull request input, caching keyed on the right thing, matrices that mean something, and secrets that never reach a fork. Use when adding or changing a workflow file, when CI is slow, flaky, or green when it should be red, or when reviewing someone's workflow YAML. Not for provider-neutral pipeline and gate design (ci-cd), image authoring (docker), or writing the tests a workflow runs (test-design).
    0 installs
24. ▌
    Copywriting · nahid-sparktales bundle

    Write persuasive copy that is also true — landing pages, product messaging, emails, ads, launch announcements — by fixing the reader, the objection, the offer and the voice, then auditing every claim against evidence before it ships. Use when copy needs writing or rewriting, when a page says nothing specific, or when a draft's claims need checking before publication. Not for interface strings inside a product, not for documentation, and never authorization to publish or send what it produces.
    0 installs
25. ▌
    Positioning · nahid-sparktales bundle

    Say what a product is for, which alternative it beats, and why — in one segment's own words, with every claim tied to something the product actually does today. Use when a homepage or deck says what the product is, when "who is this for" or "how is this different" has no crisp answer, when entering a new segment, or when sales keeps losing to one competitor. Not for writing the final copy, not for pricing, and not for deciding what to build next.
    0 installs
26. ▌
    Test Strategy · nahid-sparktales bundle

    Decide what to test and at which level before any tests get written — enumerate failure modes by consequence, give each one the cheapest level that can actually observe it, and name what is deliberately left uncovered. Use when starting testing on a feature or a codebase, when asked for a test plan or why coverage sits where it does, or when a suite is large and still missing bugs. Not for writing the tests themselves, and not for proving a finished change works.
    0 installs
27. ▌
    Context Engineering · nahid-sparktales bundle

    Decide what actually occupies the model's window — progressive disclosure through an index, retrieval versus inlining, what compaction must preserve, and what loading everything costs. Use when a prompt or agent pulls in many files, docs or tool transcripts, when quality decays over a long session, when choosing between fetching at runtime and pasting up front, or when a context has to be trimmed or summarized. Not for the wording of the prompt, not for an agent's job and tool boundaries, and not for picking retrieval infrastructure.
    0 installs
28. ▌
    Authentication · nahid-sparktales bundle

    Establish who the caller is — session cookies, bearer tokens, refresh, and OAuth/OIDC flows — and put each where it belongs. Use when adding or changing login, logout, signup, session handling, token issuance or refresh, an identity-provider integration, or when a request arrives with a credential nobody validates. Not for deciding what an authenticated caller may then do (that is authorization), not for the login screen's design, and not for hand-rolling crypto.
    0 installs
29. ▌
    Schema Design · nahid-sparktales bundle

    Turn what a system must guarantee into tables, keys and constraints — normalization judgement, nullability, foreign key behaviour, and naming that survives. Use when designing new tables, reviewing ORM models or a migration's DDL, or when a bug reduces to "the database allowed a row that should be impossible". Not for tuning a slow query, not for engine-specific syntax and features, and not for writing or running the migration that ships the change.
    0 installs
30. ▌
    Frontend Design · nahid-sparktales bundle

    Establish a visual direction for new or reshaped UI so it reads as designed for this product rather than assembled from defaults — hierarchy, typography, colour, spacing, density. Use when building a new surface, when something looks templated and needs a direction rather than a tweak, or when asked to make an interface feel considered. Prefer the official Anthropic frontend-design skill when it is installed; this is the local counterpart for when it is not. Not for critiquing an existing interface, and not for work inside a design system that already decides these things.
    0 installs
31. ▌
    Prioritization · nahid-sparktales bundle

    Choose what not to do and make the tradeoff legible — the constraint being spent, each candidate's cost and value with the evidence behind it, what is reversible, and what would change the answer. Use when a list is longer than the capacity, when asked what to cut or what ships first, or when a decision was made and nobody can reconstruct why. Not for deciding whether a problem is real (product-discovery), not for writing the scope of what wins (prd-and-stories), and not for committing the team on their behalf.
    0 installs
32. ▌
    Auth Security · nahid-sparktales bundle

    Attack and harden an existing auth surface — session fixation and rotation, token verification, horizontal and vertical privilege escalation, password reset and account recovery, MFA bypass. Use when reviewing login, session, token, reset, invite, impersonation or role-elevation code, when someone reports seeing another user's data or an account takeover, or when auth changes are about to ship. Not for designing the login mechanism or permission model in the first place (authentication, authorization), not for infrastructure IAM, and never run against a system you have not been told you may test.
    0 installs
33. ▌
    Background Jobs · nahid-sparktales bundle

    Design queued and scheduled work so it survives duplicates, retries, crashes and restarts — job contract, idempotency, transactional enqueue, backoff, dead letters, leases and the ordering guarantees you actually have. Use when moving work off a request path, adding a worker or cron, or debugging a job that ran twice, never ran, ran out of order, or is stuck retrying forever. Not for in-request async concurrency, and not for stream processing topology design.
    0 installs
34. ▌
    CI CD · nahid-sparktales bundle

    Design the shape of a delivery pipeline — what each stage actually proves, what gates what, where verification belongs, and how a run reports the truth instead of a green tick. Use when a pipeline is being designed or restructured, when a release got through a passing pipeline broken, when deciding what blocks a merge or a deploy, or when a stage claims more than it ran. Not for provider-specific workflow YAML (github-actions), image authoring (docker), writing the tests themselves (test-design), or handling an outage in progress.
    0 installs
35. ▌
    Data Integrity · nahid-sparktales bundle

    Keep data correct over time — write the invariants down, push each one to the lowest layer that can enforce it, cover the rest with reconciliation queries, and detect drift before a user reports it. Use when deciding where a rule should be enforced, auditing a schema whose rules live only in application code, building reconciliation or drift checks, or investigating data that looks wrong. Not for sequencing a schema change (migrations) or proving one migration's outcome (database-migration-verification), and it stops before repairing rows in a shared environment.
    0 installs
36. ▌
    Data Pipelines · nahid-sparktales bundle

    Build and repair batch and streaming pipelines that can be run twice without lying — lineage, event-time windowing, late arrivals, re-runnable writes and bounded backfills. Use when writing or fixing a pipeline, scheduled transform or job that produces data someone reads, when a run dropped or duplicated rows, or when planning a backfill. Not for designing the destination schema or its migrations, not for the standing assertions that guard the data afterwards (data-quality), and not for interpreting what the numbers mean.
    0 installs
37. ▌
    Data Analysis · nahid-sparktales bundle

    Get a defensible answer out of a dataset — grain and denominators pinned, missing data accounted for, aggregates checked against their segments, and every number reproducible from raw input by a script. Use when asked what a dataset shows, when a number needs explaining or two numbers disagree, or before any finding from data is reported to someone who will act on it. Not for defining product metrics or instrumentation, not for building the pipeline that produced the data, and not for designing an experiment.
    0 installs
38. ▌
    Deep Research · nahid-sparktales bundle

    Investigate an open question properly — frame it as a decision, work from primary sources, sweep from several angles including the disconfirming one, and stop on a rule rather than on fatigue. Use when a question's answer will change what gets built or bought, when the material is unfamiliar or contested, or when someone asks for a recommendation with evidence behind it. Not for looking up a single fact you can confirm in one place, not for mapping the local codebase, and not for judging one source in isolation.
    0 installs
39. ▌
    Experimentation · nahid-sparktales bundle

    Design an A/B test that can answer its question — hypothesis, randomization unit, power, duration, pre-registered analysis — and read the result honestly, including a null. Use when someone proposes testing a change, asks how long a test must run or whether a result is real, when a test is about to be stopped early, or when a flat result is being read as "no difference". Not for defining the metric itself (product-analytics), not for a change too small or too rare to power, and not for authorizing a rollout.
    0 installs
40. ▌
    Prd And Stories · nahid-sparktales bundle

    Write a scope someone else can build from without asking you what you meant — problem, users, the flow end to end including its unhappy states, acceptance criteria phrased as observable behaviour, and explicit non-goals. Use when turning a settled problem into a brief, spec, PRD, epic or set of stories, or when repairing a ticket that is too vague to estimate or to check. Not for deciding whether the problem is real (product-discovery), not for ranking work (prioritization), and not for choosing the implementation.
    0 installs
41. ▌
    Agent Security · nahid-sparktales bundle

    Secure an agent system as a permission surface — what authority each tool call runs under, where the confused deputy sits, which controls are enforced outside the model and which are only prompt text, and how far one bad call reaches. Use when granting an agent tools or credentials, wiring in MCP servers or subagents, reviewing an agent that acted beyond what the requester could have done, or before letting an agent touch a shared or production system. Not for wording the ingestion trust boundary in detail (prompt-injection-defense), not for scoping what an agent is for (agent-design), and it never grants an agent permission it did not already have.
    0 installs
42. ▌
    Responsive Design · nahid-sparktales bundle

    Make a layout hold from 320px to wide desktop — content-driven breakpoints, intrinsic layout before media queries, fluid type that still zooms, touch targets, reflow without hiding content, and what to check at each width. Fires when building or fixing layout, when something overflows or collapses at a size, or when a design only exists at one width. Not for proving it renders (browser-verification) and not for semantics or screen readers (accessibility).
    0 installs
43. ▌
    Incident Response · nahid-sparktales bundle

    Stabilize a system that is failing right now — name the signal that flagged it, size the blast radius in numbers, keep a timestamped log written as you go, find the last known-good state, then propose the smallest reversible mitigation and confirm recovery against that same signal. Use when production is degraded or down and time to mitigation matters more than a complete explanation. Not for a defect that is not currently failing (systematic-debugging), not for the root-cause investigation or the postmortem that follows, and never authorization to touch production without asking first.
    0 installs
44. ▌
    Stack Detection · nahid-sparktales bundle

    Establish what a frontend project actually uses — framework, router, package manager, styling, component layer, TypeScript posture — from package.json, lockfiles, config files and the source itself, before loading framework-specific guidance or writing a line of code. Fires at the start of any frontend task in an unfamiliar or half-remembered repo, and whenever you are about to assume a convention. Not for choosing a stack for a new project, and not a substitute for reading the code you are about to change.
    0 installs
45. ▌
    Threat Modeling · nahid-sparktales bundle

    Work out what is actually worth defending in this system — the trust boundaries data crosses, the assets behind them, what an attacker can already do, and the small number of threats that justify a control. Use when designing or changing a system's shape, before building auth, payments, uploads, file sharing or multi-tenancy, when adding an integration that crosses a boundary, or when asked whether a design is safe. Not for finding bugs in code that already exists (that is secure-code-review), not a compliance questionnaire, and not incident response.
    0 installs
46. ▌
    Product Analytics · nahid-sparktales bundle

    Define a product metric so it means one thing — event, denominator, population, window — and check the instrumentation exists before anyone reports a number. Use when asked "how do we measure this", when a funnel or activation/retention/conversion metric is being defined, when two dashboards disagree, or before adding tracking to a feature. Not for choosing what to build (prioritization), not for designing an A/B test (experimentation), and not for general data analysis of a dataset that is already trusted.
    0 installs
47. ▌
    Product Discovery · nahid-sparktales bundle

    Find the real problem behind a feature request before anyone scopes a solution — whose job is stuck, what evidence exists already, and what observation would prove the assumption wrong. Use when a request arrives phrased as a solution ("add a dashboard", "we need notifications"), when a team is about to build on a belief nobody has checked, or when asked whether something is worth building at all. Not for writing the spec once the problem is settled, not for ranking work that is already understood, and never a licence to contact users without permission.
    0 installs
48. ▌
    Owasp Web · nahid-sparktales bundle

    Hunt the web failure classes that actually recur — broken access control, injection, XSS by output context, SSRF, unsafe deserialization and mass assignment, session and token handling, secrets leakage, file handling — as patterns to find in this codebase. Use when writing or reviewing request handlers, queries, URL fetches, templates, uploads or auth code, or when asked to check a web app for the common vulnerability classes. Not for design-stage modeling (threat-modeling), not infrastructure or network hardening, and not a list to recite without reading code.
    0 installs
49. ▌
    Migrations · nahid-sparktales bundle

    Change a live schema without breaking the application on it — expand/contract sequencing, lock-safe DDL, batched backfills, and a rollback that is actually reachable. Use when writing, reviewing or sequencing a migration that will run against a database holding real data with live readers. Not for designing a schema from scratch, not for proving afterwards that a migration did what it claimed (that is database-migration-verification), and it never runs the production step for you.
    0 installs
50. ▌
    E2e Testing · nahid-sparktales bundle

    Build and keep end-to-end suites that are worth their runtime — which journeys belong at this level, selectors that survive refactors, waiting on state instead of sleeping, per-spec data isolation, and flake triage that finds the cause. Use when adding or repairing an e2e suite, when specs are slow or intermittently red, or when deciding whether a case belongs here at all. Not for one-off checking that a change renders, not for unit or integration tests, and not for load testing.
    0 installs
51. ▌
    Test Design · nahid-sparktales bundle

    Write unit and integration tests that fail for the right reason — behaviour-level assertions, boundary values, the smallest honest double, deterministic setup and teardown. Use when adding tests for new code, pinning a bug before fixing it, or repairing tests that stay green while the code is broken. Not for deciding what to test or at which level, not for browser journeys, and not a way to call a change verified.
    0 installs
52. ▌
    LLM Observability · nahid-sparktales bundle

    See what an agent actually did — one trace per run with nested model, tool and retrieval spans, token and latency accounted per step, and failures clustered by mechanism instead of read one at a time. Use when an agent misbehaves in ways you cannot reproduce, when cost or latency is unexplained, when "it sometimes fails" is the whole bug report, or before writing evals when you do not yet know which failures exist. Not for judging whether an output is correct (agent-evals), and not a replacement for the application's own monitoring.
    0 installs
53. ▌
    Structured Output · nahid-sparktales bundle

    Get parseable, trustworthy structured results out of a model — schema design, the enforcement mechanism the provider actually offers, validation at the boundary, bounded retry that feeds the error back, and recognising where a schema stops buying correctness. Use when a model's output feeds code rather than a human, when parsing keeps failing or fields come back plausible-but-wrong, or when designing an extraction, classification or grading step. Not for designing the tools an agent calls (tool-design), and not for free-form prose quality.
    0 installs
54. ▌
    Accessibility · nahid-sparktales bundle

    Build and fix interfaces so they meet WCAG 2.2 AA in practice — native semantics, keyboard paths, focus order and visibility, accessible names, contrast, form errors, live regions, target size. Fires while writing or reviewing UI code, when a component is keyboard- or screen-reader-hostile, or when an audit finding has to be turned into a change. Not for proving the result (accessibility-verification), not for viewport layout work (responsive-design), and not a recital of the standard.
    0 installs
55. ▌
    Motion Design · nahid-sparktales bundle

    Decide what an animation is communicating, then give it a duration, an easing curve, an interruption behaviour and a reduced-motion fallback. Use when adding or reviewing transitions, when a screen feels sluggish or jumpy, when implementing motion specified in a design, or when animation needs to survive users who ask for less of it. Not for static visual design, and not for general performance profiling of code that has no animation.
    0 installs
56. ▌
    Observability · nahid-sparktales bundle

    Instrument a service so the questions asked during an incident are answerable from data already being collected — rate, errors, latency distribution and saturation per route, structured events carrying a correlation id that survives process and queue boundaries, and alerts on symptoms users feel. Use before a service or a new critical path goes to production, after an incident that ended in "we had no data for that", or when adding a dependency, queue or job whose failure would be silent. Not for fighting a live outage (incident-response), not for profiling a known-slow path (performance-profiling), and not for tracing agent or LLM runs (llm-observability).
    0 installs
57. ▌
    Prompt Engineering · nahid-sparktales bundle

    Write or revise a prompt so it holds up — output contract, instruction placement, examples that earn their place, an escape hatch for bad input — and measure the change against a saved set of cases instead of one good-looking run. Use when a prompt is being authored or patched, when output is inconsistent or the wrong shape, when a model or version changes, or when someone reports a prompt as fixed. Not for scoping an agent's job and tools, not for deciding what material to load into the window, and not for model selection or fine-tuning.
    0 installs
58. ▌
    Authorization · nahid-sparktales bundle

    Decide what an authenticated caller may do — pick the permission model, put the check at one enforcement point close to the data, and default to deny. Use when adding roles or permissions, scoping data per tenant or per owner, building an admin-only path, reviewing an endpoint that trusts a client-supplied id, or when someone reports seeing data that is not theirs. Not for establishing identity (that is authentication), and hiding a control in the UI is never the enforcement.
    0 installs
59. ▌
    Data Quality · nahid-sparktales bundle

    Decide what must be true of a dataset and where that assertion belongs — freshness against event time, volume floors and bands, distribution and referential checks, source reconciliation, and whether it should be a schema constraint, a blocking publish gate or an alert. Use when adding or reviewing data checks, when a wrong number reached a consumer and nothing caught it, or when a check fires so often it is being ignored. Not for proving a specific migration did what it claimed (database-migration-verification), not for building the pipeline itself (data-pipelines), and not for interpreting what the numbers mean.
    0 installs
60. ▌
    Design Systems · nahid-sparktales bundle

    Build UI inside an existing design system — find its tokens and components, reuse before adding, decide between extending a component and introducing a new one, and preserve conventions you did not set. Use when a project already has design tokens, a component library, a theme or a shared Figma library and you are about to add or change UI inside it. Not for establishing a visual direction where no system exists, and not for reviewing an interface's usability.
    0 installs
61. ▌
    MCP Design · nahid-sparktales bundle

    Build an MCP server, or bring an existing one into a project — choosing the transport, deciding which tools, resources and prompts to expose, keeping reads separate from writes, handling auth and credentials, and defining what failure looks like to the model. Use when writing an MCP server, wrapping an internal system as one, or evaluating a third-party server before wiring it in. Not for designing the individual tool signatures inside it (tool-design), and not authorization to install, configure or run any server against real systems.
    0 installs
62. ▌
    Docker · nahid-sparktales bundle

    Build container images that are reproducible, small, and safe to run — layer order and what actually caches, multi-stage builds, and what belongs in an image versus what must never be baked into one. Use when writing or reviewing a Dockerfile, when an image build is slow, bloated, or non-deterministic, or when deciding how configuration and secrets reach a container. Not for orchestration, cluster or compose topology, not for CI workflow authoring (github-actions), and not for pipeline stage design (ci-cd).
    0 installs
63. ▌
    SEO · nahid-sparktales bundle

    Make a page findable for a real query — match the intent behind it, structure the page around that intent, and clear the technical floor that decides whether it can be crawled and indexed at all. Use when a page is written for search, when traffic drops or a page is missing from results, when someone asks "how do we rank for X", or before publishing content meant to be found. Not for writing the copy itself, not for page speed work, and not for paid search or social distribution.
    0 installs
64. ▌
    Agent Evals · nahid-sparktales bundle

    Build an eval suite that can actually detect a regression — cases pulled from real traffic, graders that check properties rather than vibes, a recorded baseline, and per-case diffs in both directions. Use before claiming a prompt, model or agent change is an improvement, when agent behaviour must not regress, or when someone reports "it seems better" after eyeballing a handful of outputs. Not for tracing what one run did (llm-observability), not for testing deterministic code, and never as evidence that behaviour the suite does not measure is safe.
    0 installs
65. ▌
    Tool Design · nahid-sparktales bundle

    Design the tools a model calls — names, parameter shapes, what a result returns, and error text written as an instruction the model can act on. Use when adding or reshaping a tool or function an LLM invokes, when an agent keeps calling the wrong tool or passing malformed arguments, or when reviewing a tool surface someone else defined. Not for building the MCP server that hosts the tools (mcp-design), not for forcing a model's final answer into a schema (structured-output), and not for prompt wording outside the tool definition.
    0 installs
66. ▌
    Agent Design · nahid-sparktales bundle

    Scope an agent or subagent before it is built — the one job it owns, the smallest tool set that closes that job, what it must never do, and the evidence it has to return. Use when adding an agent, subagent or automated role to a system, when deciding which tools it gets, when an existing agent loops, over-reaches or reports work it did not do, or when reviewing someone else's agent design. Not for wording the prompt itself, not for deciding what occupies its context window, and it never grants an agent permission it did not already have.
    0 installs
67. ▌
    Caching · nahid-sparktales bundle

    Decide what to cache, at which layer, for how long, and how it gets invalidated — before any cache is added. Use when someone proposes caching to make a read path faster, when stale or cross-user data is suspected, when adding a TTL or a Redis/CDN layer, or when reviewing a change that introduces one. Not for fixing a slow query or an N+1 (do that first — a cache over a bad query hides it), and not for HTTP header tuning with no server-side store.
    0 installs
68. ▌
    UI Audit · nahid-sparktales bundle

    Review an existing interface and return ranked, concrete findings — each with its location, the user consequence, and a specific fix — instead of taste notes. Use when asked to critique, audit or review a screen or flow, when someone's UI work needs judging, or when an interface "feels off" and the problem needs naming. Not for proving a change renders and functions, not for inventing a new visual direction, and not for an accessibility conformance audit, which is its own discipline.
    0 installs
69. ▌
    Rollback · nahid-sparktales bundle

    Get back to a known-good state, and know in advance which parts of a release cannot come back — destructive migrations, data the old version cannot read, messages already sent, published artifacts, cache and CDN state. Use while writing a release plan, when a deploy is going wrong, or when someone asks whether a change can be undone. Not the health check that decides you should revert (release-verification), not incident coordination, and it never runs a production revert without explicit per-action confirmation.
    0 installs
70. ▌
    Agent Dispatcher · nahid-sparktales bundle

    Handle requested Agent Dispatcher work with direct execution or prepared specialist guidance. Includes named roles, context inspection and controls.
    0 installs
71. ▌
    Memory Design · nahid-sparktales bundle

    Decide what an agent should remember, which layer holds it, who it is scoped to, and how a stale or contradicted memory is detected and retired. Use when an agent forgets something across sessions, when a memory or persistent-context feature is being designed, or when stored memories have grown noisy, wrong, or are leaking between users. Not for retrieval over a document corpus, not for prompt or context-window packing, and not for conversation transcript storage.
    0 installs
72. ▌
    Model Routing · nahid-sparktales bundle

    Pick a model per job and degrade sensibly when one fails — a quality bar per call site, candidates compared on the same task set, a readable routing rule, and an explicit retry-versus-fallback path with pinned model ids. Use when cost or latency has become a problem, when adding a cheaper or larger model to an existing system, or when a fallback fires silently and quality drops without anyone noticing. Not for prompt authoring, not for retrieval tuning, and not for capacity or infrastructure planning.
    0 installs
73. ▌
    Retrieval RAG · nahid-sparktales bundle

    Build and fix retrieval that actually returns the right passage — structure-aware chunking, one pinned embedding model, lexical plus vector search fused, reranking, and a recall measurement that is run separately from the generator. Use when a RAG system answers wrong or vaguely, when an index is being designed or reindexed, or when someone proposes a prompt change to fix what is really a retrieval miss. Not for prompt or output-quality work once the right passage is already in context, not for agent memory design, and not for choosing a vector database.
    0 installs
74. ▌
    Webhooks · nahid-sparktales bundle

    Receive or send HTTP webhooks correctly — signature verification on the raw body, fast acknowledgement, deduplication, out-of-order handling, retry and dead-letter behaviour, and the delivery contract a consumer needs. Use when adding or debugging a webhook endpoint, when integrating a provider's events, or when your own service has to notify others of changes. Not for internal queue or event-bus messages that never cross an HTTP boundary, and not for general outbound API retry policy.
    0 installs
75. ▌
    Postgres · nahid-sparktales bundle

    Postgres
    0 installs
76. ▌
    UX Writing · nahid-sparktales bundle

    Write or repair the words inside an interface — button labels, empty states, error messages, confirmation dialogs, form hints, success and loading text — so a reader knows what just happened and what to do next. Use when a screen's copy is being written or reviewed, when an error says something unhelpful, when a confirmation is vague about what it will do, or when users hesitate at a control. Not for marketing or landing-page copy, not for documentation, and not for deciding layout or visual design.
    0 installs
77. ▌
    Deployment · nahid-sparktales bundle

    Prepare and run a release you can explain and undo — exact artifact identity, environment parity, config and secrets, a rollout strategy matched to blast radius, and a preflight that names the abort condition in advance. Use when planning or performing a deploy, building a release path, or when someone says "ship it" and the steps are not written down anywhere. Not for proving the deployed thing is healthy (release-verification) or for getting back out (rollback), and it never treats a green build or an approved plan as permission to deploy.
    0 installs
78. ▌
    Tailwind · nahid-sparktales bundle

    Work inside an existing Tailwind codebase without degrading it — use the project's theme tokens instead of arbitrary values, extend the theme when a token is genuinely missing, extract repetition into components rather than @apply, resolve class conflicts with the project's merge helper, and make dark mode a token decision. Fires when writing or editing Tailwind classes in a repo that already uses it. Not for deciding whether to adopt Tailwind, not for visual design direction, and not a rendered-output check.
    0 installs
79. ▌
    API Design · nahid-sparktales bundle

    Design or change an HTTP API — resources, verbs, status codes, one error shape, pagination, versioning, and an OpenAPI description that cannot drift from the handlers. Use when adding or reshaping endpoints, when asked what a response should return, or when reviewing whether a change to a published API breaks its consumers. Not for choosing between REST, GraphQL and RPC, not for database schema design, and not for implementing the handler's business logic.
    0 installs
80. ▌
    Shadcn UI · nahid-sparktales bundle

    Work with shadcn/ui components and the Radix primitives under them — components are copied into the repo and are your source, so customize them in place, know that re-running the generator overwrites local edits, and know which accessibility behaviour Radix gives you and which it does not. Fires when adding, customizing or debugging a component in a repo with components.json and a vendored UI directory. Not for choosing a component library, not for general component structure, and not an accessibility audit.
    0 installs