Claude Skills by makifbaysal

Use when a stakeholder sends a request - route it to backlog tasks, an analiz task, or a focused question, decide ask-vs-assume with a Definition of Ready, and ask only what a wrong guess would actually cost

Use when a task adds or changes an HTTP endpoint, its request/response shape, status codes, auth or error format - the request matrix, curl templates and what counts as a contract break

Wire the automation test project into the repository's own pipeline so every task must pass the suite before it can leave QA

Use when the task touches a backend API, database or worker - booting it from the task branch, driving real requests and verifying side effects (DB rows, outbound calls, logs) as evidence

Use when building cases for any input, form, endpoint or state change - boundary values, invalid and hostile data, authz and concurrency cases with a worked example

Use when any case fails or you reject a criterion - what goes in the review_criterion note, the failed case and the numbered need_revision comment, with severity

Maintain a dedicated automation test project per repository - separate from the product's unit tests - with API, worker, and UI suites written scenario-first

Use when the task changes anything a user sees in a web app - booting it, driving flows with the browser tools, the four-width check, console/network/keyboard checks and the visual checklist

Use when the task touches a mobile app - the device flow with the mobile_* tools, confirming the installed build is the task's, and what to report when no device is attached

Use when a criterion mentions speed or limits, or the change touches a list, query, endpoint or page that could get slower - timing loops, the N-vs-10N data check and Lighthouse on a production build

Use before any review_criterion approval or column move - the evidence each verdict needs, how to treat skipped, blocked and intermittent cases, and which exit a blocker takes

Use after the targeted cases pass - choosing the adjacent behaviour this change can break from the PR's files and the component's links, and the per-repository smoke set

Use at the start of every QA round - recording the case matrix with record_test_cases (categories, criterion links, rejected cases) before touching the app, then executing all of it

Use when a test needs a database - spin up a dedicated, disposable test database (Testcontainers) seeded with known data, never a shared or production database

Use when a test would otherwise call a real external dependency - replace it with WireMock or an equivalent stub so runs are deterministic, offline, and control the responses

Use before booting anything - choosing local (start_task_preview or a workspace boot), the task's preview or stage, confirming the build is the PR head, and what to do when nothing can run

Use while deriving cases - Given/When/Then and the techniques (partitions, boundaries, decision tables, state transitions) that find the cases the criteria do not state

Use when the task has a background job, queue consumer, scheduler or webhook - firing the real trigger, polling for the side effect, and the retry, idempotency and poison-message cases

Write board comments the way a colleague does — lead with the finding, a few lines, no preamble or process narration. Use when about to call add_task_comment or comment_on_pull_request, or when deciding whether something deserves a comment at all.

Use when a repository needs CI/CD - author GitHub Actions workflows so TaskTrooper's pipeline auto-detects your validate/build/test jobs and stage/preprod/prod deploys, and so a dispatch delivery profile can dispatch the production deploy

Built-in deploy recipes and deploy targets. Use when a task asks you to set up or change a stage/preprod/prod deploy workflow, including the system's "Set up <env> deploy" tasks.

How to work a production incident remediation task. Use when the task title starts with "Incident:" or its description carries an incident id and a suggest/auto_fix policy.

Commit boundaries and messages on a task branch. Use when deciding where to cut a commit or how to word one while implementing.

The local task workspace, the build/test commands the hand-off gate runs, and the file and exploration tools. Use when starting work in a task workspace or before running any build, test or verification command.

How the performance score moves for your role. Use when the score context shows a declining trend, or before handing off work you have not self-checked against every criterion.

Error-handling, security, logging and performance bar for production code. Use when writing or changing production code, before the run ends.

Root-cause debugging discipline. Use when a test, build or pipeline fails, behaviour does not match expectations, a bug task arrives, or a task comes back in need_revision — before proposing any fix.

Master workflow for an implementation task. Use when you pick up any task or bug that changes product code, including a need_revision bounce.

Test-first discipline and what makes a test worth keeping. Use when implementing any feature or bug fix, before writing production code, and whenever writing or changing a test.

Evidence rules for completion claims. Use before ticking an acceptance criterion, ending an implementation run, or writing anything that says something works, passes or is fixed.

Use when you finish an analiz report - the human must approve the analysis before any implementation task is created, via the analiz_review column

Use when a task is in code_review - how to read the diff, which findings block, and the verdict move

Use when you write the `plan` section of an analiz report - steps that pin files, signatures, tests and verify commands, nothing more

Use when an approved analiz spans more than one repository - split the work per repository and open one or more tasks per repository, each carrying its own plan slice

Use when a task in code_review was sent back before (an earlier need_revision comment exists) - verify every prior point was fixed at its root

Use when you write the `context` and `design` sections of an analiz report - components, exact interfaces, data flow, errors, decision record, out of scope

Use when an analiz task arrives in done (approved) - turn the approved split into implementation tasks with repository, AC, derived_from and ordering arguments

Use when you start an analiz task - explore every affected repository and resolve unknowns before writing the report

Use when a release reaches awaiting_verdict (or you are woken for an incident) - how to read runtime logs, error groups, health and smoke evidence for the release's component and decide finish, re-check, roll back or hand to a human

Use when you need the end-to-end merge -> deploy -> watch -> verdict sequence for a delivery mode, or a tool result you did not expect (refusal, park, tag exists)

Use before and after calling rollback_release - what a rollback restores per delivery mode, when a schema change makes a code rollback unsafe, how to work and report manual_steps, and what to do when rollback_release refuses

Use when you write or revise the analiz deliverable - the ONE self-contained HTML report (spec and plan as sections) a human reviews passage by passage

this was reusable know-how, so it was stored in the skill catalog instead of memory

Create a new skill for yourself when no skill in your index covers the work at hand. Write the skill as durable, reusable instructions (not a log of this task) so future runs can load and follow it. The skill joins your index immediately.

Load the full instructions of one of your skills by name or id. Call this right before applying a skill listed in your skill index, then follow the returned instructions.

How to work a task returned with review, QA or UAT findings. Use when a task is in need_revision or PR review comments are in your context.

Use when you design or change an endpoint's errors, status codes, pagination, idempotency or concurrency behaviour — one error shape, the status-code table, bounded lists, safe retries

Use when you add or change an endpoint, an auth check, a query by id, an outbound call to a user-supplied URL, file handling, or anything touching credentials — the OWASP API Top 10 (2023) as concrete Go and Java checks

Use before handing off any change to an endpoint, job or migration — start the service from the task branch and exercise the change with real requests, real logs and real DB side effects

Use when code calls another service, runs in the background, consumes a queue or retries anything — timeouts, safe retries, idempotent handlers, outbox, graceful shutdown