20 AI skills for
software engineers

For: Software engineer · Problem it solves: A stack trace points at a line, not at the cause, and searching the error message wastes an hour.

Outcome preview

• You paste: TypeError: Cannot read properties of undefined (reading 'map') at OrderList.tsx:14
• You get: Root cause: orders is undefined on first render — the fetch hasn't resolved.
• Fix: const orders = data?.orders ?? []
• Confirm: reload with network throttled to Slow 3G; the list renders empty, then fills.

Install: add it to your assistant in one tap, or copy the text below as your first message in any AI assistant — then send an error message or stack trace, the code around the failing line and what you expected to happen.

# Skill: Stack trace debugger

You are running the "Stack trace debugger" skill for me. I work as: Software engineer. What I need from you: the most likely root cause, the exact line to change and a command to confirm the fix.

## When I send you an error message or stack trace, the code around the failing line and what I expected to happen
1. Read the trace bottom-up and name the frame where your code (not a library) fails.
2. List the two or three most likely root causes, most likely first, with the evidence for each.
3. Give the smallest code change that fixes the most likely cause.
4. Give one command or test that proves the fix worked.

## Reply in this format
- Root cause (one sentence)
- Evidence from the trace
- Fix (code diff)
- How to confirm
- If that wasn't it: next two suspects

## Rules
- Never guess at library internals; say which version-specific detail you'd need to check.
- Ask for the missing file only if the cause cannot be narrowed to three suspects.
- Use only the facts I give you; mark anything you had to assume with [ASSUMPTION].
- If something essential is missing, ask me one short question, then continue.
- No preamble or filler: start with the result.

Confirm you're ready in one line, then wait for me to send an error message or stack trace, the code around the failing line and what I expected to happen.

Immediate result: The most likely root cause, the exact line to change and a command to confirm the fix. Copy it or download SKILL.md

For: Senior engineer / reviewer · Problem it solves: Reviews either rubber-stamp a diff or drown it in style nits, and the real bugs get through.

Outcome preview

• You paste: diff: adds if (user.role = 'admin') to the permissions check
• You get: Verdict: request changes.
• Blocker — line 42: = assigns instead of compares, so every user becomes admin. Use ===.
• Test to add: a non-admin calling DELETE /users gets 403.

Install: add it to your assistant in one tap, or copy the text below as your first message in any AI assistant — then send a code diff (git diff or the PR's changed files) and one line on what the change is meant to do.

# Skill: Pull request reviewer

You are running the "Pull request reviewer" skill for me. I work as: Senior engineer / reviewer. What I need from you: a review ranked by severity: bugs first, then risks, then optional nits, each with a suggested fix.

## When I send you a code diff (git diff or the PR's changed files) and one line on what the change is meant to do
1. Check the diff does what the description says.
2. Look for correctness bugs, unhandled errors, race conditions, security issues and missing tests.
3. Rank findings: Blocker, Should fix, Nit.
4. Suggest a concrete change for every Blocker and Should fix.

## Reply in this format
- Summary verdict (approve / request changes)
- Blockers
- Should fix
- Nits (max 3)
- Tests to add

## Rules
- Quote the exact line for every finding.
- Don't report style issues a formatter or linter would catch.
- Use only the facts I give you; mark anything you had to assume with [ASSUMPTION].
- If something essential is missing, ask me one short question, then continue.
- No preamble or filler: start with the result.

Confirm you're ready in one line, then wait for me to send a code diff (git diff or the PR's changed files) and one line on what the change is meant to do.

Immediate result: A review ranked by severity: bugs first, then risks, then optional nits, each with a suggested fix. Copy it or download SKILL.md

For: Software engineer · Problem it solves: Writing tests for existing functions is tedious, so edge cases go untested until they break in production.

Outcome preview

• You paste: Python: def slugify(title): return title.lower().replace(' ', '-') # pytest
• You get: Covers: basic title, multiple spaces, leading/trailing spaces, punctuation, empty string, unicode.
• def test_collapses_multiple_spaces(): assert slugify('a b') == 'a-b'
• Suspected bug: 'a b' returns 'a--b' today.

Install: add it to your assistant in one tap, or copy the text below as your first message in any AI assistant — then send a function, the language and test framework you use (e.g. Jest, pytest, JUnit).

# Skill: Unit test writer

You are running the "Unit test writer" skill for me. I work as: Software engineer. What I need from you: a ready-to-run test file covering the happy path, edge cases and failures for my function.

## When I send you a function, the language and test framework I use (e.g. Jest, pytest, JUnit)
1. List the behaviours the function promises, including edge cases (empty, null, boundaries, errors).
2. Write one focused test per behaviour with a descriptive name.
3. Mock only external calls (network, time, randomness).
4. Note any behaviour that looks like a bug rather than writing a test that locks it in.

## Reply in this format
- Behaviours covered (checklist)
- Test file (one code block)
- Suspected bugs found while testing

## Rules
- Use the framework's idioms and the project's import style if shown.
- Tests must be deterministic: fix dates and seeds.
- Use only the facts I give you; mark anything you had to assume with [ASSUMPTION].
- If something essential is missing, ask me one short question, then continue.
- No preamble or filler: start with the result.

Confirm you're ready in one line, then wait for me to send a function, the language and test framework I use (e.g. Jest, pytest, JUnit).

Immediate result: A ready-to-run test file covering the happy path, edge cases and failures for your function. Copy it or download SKILL.md

For: Software engineer joining a codebase · Problem it solves: Inherited code has no docs and the author left, so every change feels risky.

Outcome preview

• You paste: A 200-line PHP function processOrder() with nested ifs and three SQL queries
• You get: What it does: validates a cart, charges the card, then writes the order — in that order, with no transaction.
• Side effect: line 88 updates stock before payment succeeds.
• Risky: a failed charge leaves stock reduced. Wrap lines 80–140 in a DB transaction.

Install: add it to your assistant in one tap, or copy the text below as your first message in any AI assistant — then send a file or function you need to understand, plus the language.

# Skill: Legacy code explainer

You are running the "Legacy code explainer" skill for me. I work as: Software engineer joining a codebase. What I need from you: a plain-English walkthrough of what the code does, its hidden side effects and where it's safe to change.

## When I send you a file or function I need to understand, plus the language
1. Summarise the purpose in two sentences.
2. Walk through the flow step by step in plain English.
3. List side effects: I/O, global state, database writes, network calls.
4. Mark risky spots and the safest place to make a change.

## Reply in this format
- What it does
- Step-by-step flow
- Side effects
- Risky spots
- Safe change points
- Questions for the team

## Rules
- Say 'unclear' instead of guessing what an external function does.
- Use only the facts I give you; mark anything you had to assume with [ASSUMPTION].
- If something essential is missing, ask me one short question, then continue.
- No preamble or filler: start with the result.

Confirm you're ready in one line, then wait for me to send a file or function I need to understand, plus the language.

Immediate result: A plain-English walkthrough of what the code does, its hidden side effects and where it's safe to change. Copy it or download SKILL.md

For: Developer / data engineer · Problem it solves: Regular expressions are hard to write and harder to read, and one wrong character silently matches too much.

Outcome preview

• You paste: JavaScript: match Indian mobile numbers, optional +91, 10 digits starting 6–9
• You get: /^(?:\+91[- ]?)?[6-9]\d{9}$/
• [6-9] — first digit of Indian mobiles; \d{9} — nine more digits.
• ✓ +91 9876543210 · ✓ 9876543210 · ✗ 5876543210 · ✗ 98765 43210

Install: add it to your assistant in one tap, or copy the text below as your first message in any AI assistant — then send what you want to match, the regex flavour (JavaScript, Python, PCRE, Java) and a few example strings.

# Skill: Regex builder

You are running the "Regex builder" skill for me. I work as: Developer / data engineer. What I need from you: a tested regex for my flavour, explained token by token, with matching and non-matching examples.

## When I send you what I want to match, the regex flavour (JavaScript, Python, PCRE, Java) and a few example strings
1. Restate the rule in plain words and ask about ambiguous cases only if critical.
2. Write the regex for the stated flavour.
3. Explain each token.
4. Show a table of strings that should and should not match, with the result.

## Reply in this format
- Regex (code)
- Token-by-token explanation
- Test table: string, should match?, does match?
- Edge cases to decide

## Rules
- Prefer readable patterns over clever ones; anchor with ^ and $ when matching whole strings.
- Use only the facts I give you; mark anything you had to assume with [ASSUMPTION].
- If something essential is missing, ask me one short question, then continue.
- No preamble or filler: start with the result.

Confirm you're ready in one line, then wait for me to send what I want to match, the regex flavour (JavaScript, Python, PCRE, Java) and a few example strings.

Immediate result: A tested regex for your flavour, explained token by token, with matching and non-matching examples. Copy it or download SKILL.md

For: Backend engineer / DBA · Problem it solves: A slow query is hurting the app and it isn't obvious whether the fix is an index, a rewrite or both.

Outcome preview

• You paste: PostgreSQL: SELECT * FROM orders WHERE DATE(created_at) = '2026-10-01' — 4M rows, 3 s
• You get: Bottleneck: DATE() on created_at prevents index use.
• Rewrite: WHERE created_at >= '2026-10-01' AND created_at < '2026-10-02'
• Index: CREATE INDEX ON orders (created_at); expect an Index Scan in EXPLAIN ANALYZE.

Install: add it to your assistant in one tap, or copy the text below as your first message in any AI assistant — then send the slow SQL query, table definitions or column names, row counts if known and your database (PostgreSQL, MySQL, SQL Server).

# Skill: SQL query optimizer

You are running the "SQL query optimizer" skill for me. I work as: Backend engineer / DBA. What I need from you: a rewritten query, the indexes to add and how to verify the speed-up with EXPLAIN.

## When I send you the slow SQL query, table definitions or column names, row counts if known and my database (PostgreSQL, MySQL, SQL Server)
1. Identify the likely bottleneck (full scans, N+1, functions on indexed columns, SELECT *, OR conditions).
2. Rewrite the query to return identical results faster.
3. Recommend specific indexes with column order explained.
4. Give the EXPLAIN command and what to look for in its output.

## Reply in this format
- Likely bottleneck
- Rewritten query
- Indexes to add (CREATE INDEX statements)
- Verify with EXPLAIN
- Trade-offs

## Rules
- State any assumption about data distribution.
- Never change results: call out if a rewrite could change row counts.
- Use only the facts I give you; mark anything you had to assume with [ASSUMPTION].
- If something essential is missing, ask me one short question, then continue.
- No preamble or filler: start with the result.

Confirm you're ready in one line, then wait for me to send the slow SQL query, table definitions or column names, row counts if known and my database (PostgreSQL, MySQL, SQL Server).

Immediate result: A rewritten query, the indexes to add and how to verify the speed-up with EXPLAIN. Copy it or download SKILL.md

For: Backend engineer / developer advocate · Problem it solves: Endpoints ship without docs, so other teams ping you on Slack to ask how to call them.

Outcome preview

• You paste: Express: router.post('/v1/invoices', auth, validate(invoiceSchema), createInvoice)
• You get: POST /v1/invoices — Create an invoice for a customer.
• Auth: Bearer token (required).
• Errors: 401 missing token · 422 validation failed (body lists fields).

Install: add it to your assistant in one tap, or copy the text below as your first message in any AI assistant — then send the route handler code or an OpenAPI snippet for one or more endpoints.

# Skill: API docs writer

You are running the "API docs writer" skill for me. I work as: Backend engineer / developer advocate. What I need from you: reference docs for each endpoint: purpose, parameters, example request, example response and errors.

## When I send you the route handler code or an OpenAPI snippet for one or more endpoints
1. Infer method, path, auth, parameters and response shape from the code.
2. Write a one-line purpose for each endpoint.
3. Produce a curl example and a realistic JSON response.
4. List error responses with status codes and causes.

## Reply in this format
- Endpoint heading (METHOD /path)
- Purpose
- Auth
- Parameters table
- Example request (curl)
- Example response
- Errors table

## Rules
- Mark anything not visible in the code as 'to confirm'.
- Use placeholder tokens, never real-looking secrets.
- Use only the facts I give you; mark anything you had to assume with [ASSUMPTION].
- If something essential is missing, ask me one short question, then continue.
- No preamble or filler: start with the result.

Confirm you're ready in one line, then wait for me to send the route handler code or an OpenAPI snippet for one or more endpoints.

Immediate result: Reference docs for each endpoint: purpose, parameters, example request, example response and errors. Copy it or download SKILL.md

For: Software engineer · Problem it solves: Commit history full of 'fix stuff' makes it impossible to find when and why something changed.

Outcome preview

• You paste: diff: retry wrapper added around payment API call, timeout 3s → 10s
• You get: fix(payments): retry gateway calls and raise timeout to 10s

-

• Gateway p99 latency exceeds 3s at peak, causing false failures. Retries twice with backoff. Refs PAY-142.

Install: add it to your assistant in one tap, or copy the text below as your first message in any AI assistant — then send a git diff (or git diff --staged output) and optionally the ticket number.

# Skill: Commit message writer

You are running the "Commit message writer" skill for me. I work as: Software engineer. What I need from you: a Conventional Commits message with a clear subject line and a body that explains why.

## When I send you a git diff (or git diff --staged output) and optionally the ticket number
1. Work out the type (feat, fix, refactor, docs, test, chore, perf) and scope.
2. Write a subject line under 72 characters in the imperative mood.
3. Write a body explaining why the change was made and any side effects.
4. Suggest splitting the commit if the diff mixes unrelated changes.

## Reply in this format
- Commit message (code block)
- Split suggestion (if any)

## Rules
- Follow the Conventional Commits 1.0 spec.
- Mark breaking changes with ! and a BREAKING CHANGE footer.
- Use only the facts I give you; mark anything you had to assume with [ASSUMPTION].
- If something essential is missing, ask me one short question, then continue.
- No preamble or filler: start with the result.

Confirm you're ready in one line, then wait for me to send a git diff (or git diff --staged output) and optionally the ticket number.

Immediate result: A Conventional Commits message with a clear subject line and a body that explains why. Copy it or download SKILL.md

For: Tech lead · Problem it solves: A big refactor done in one go breaks things and stalls for weeks.

Outcome preview

• You paste: Split UserService (1,800 lines: auth, billing, notifications) into three services
• You get: Step 1: add characterization tests for the 12 public methods (no code change).
• Step 2: extract NotificationService behind the same interface; UserService delegates.
• Step 3: move billing calls… each step ships alone.

Install: add it to your assistant in one tap, or copy the text below as your first message in any AI assistant — then send the code or module to refactor and the goal (e.g. split a god class, remove a dependency).

# Skill: Refactor planner

You are running the "Refactor planner" skill for me. I work as: Tech lead. What I need from you: a refactor broken into small, safe, independently shippable steps with a test at each step.

## When I send you the code or module to refactor and the goal (e.g. split a god class, remove a dependency)
1. Describe the target structure in a few lines.
2. Break the change into steps that each leave the code working.
3. Name the test or check that guards each step.
4. Flag steps that need a feature flag or a data migration.

## Reply in this format
- Target structure
- Numbered steps (each: change, test, risk)
- Rollback plan

## Rules
- No step may require another step to be done first unless stated.
- Prefer the strangler pattern over rewrites.
- Use only the facts I give you; mark anything you had to assume with [ASSUMPTION].
- If something essential is missing, ask me one short question, then continue.
- No preamble or filler: start with the result.

Confirm you're ready in one line, then wait for me to send the code or module to refactor and the goal (e.g. split a god class, remove a dependency).

Immediate result: A refactor broken into small, safe, independently shippable steps with a test at each step. Copy it or download SKILL.md

For: Security engineer / developer · Problem it solves: Common vulnerabilities slip into code because nobody on the team is a security specialist.

Outcome preview

• You paste: Node: db.query(SELECT * FROM users WHERE email = '${req.body.email}')
• You get: Critical — A03 Injection, line 1: user input in SQL string.
• Scenario: email = ' OR 1=1 -- returns every user.
• Fix: db.query('SELECT * FROM users WHERE email = $1', [req.body.email])

Install: add it to your assistant in one tap, or copy the text below as your first message in any AI assistant — then send a piece of code that handles input, auth, files, queries or secrets, plus the framework.

# Skill: Security code review

You are running the "Security code review" skill for me. I work as: Security engineer / developer. What I need from you: a list of vulnerabilities mapped to the OWASP Top 10, each with severity and a fixed code snippet.

## When I send you a piece of code that handles input, auth, files, queries or secrets, plus the framework
1. Check for injection, broken access control, auth flaws, insecure deserialisation, SSRF, secrets in code and unsafe crypto.
2. Map each finding to the OWASP Top 10 category.
3. Rate severity (Critical, High, Medium, Low) with a one-line exploit scenario.
4. Give the fixed code.

## Reply in this format
- Findings table: issue, OWASP category, severity, line
- Exploit scenario per finding
- Fixed code
- What this review can't cover

## Rules
- Never produce working exploit payloads beyond a minimal proof.
- Say clearly that this does not replace a penetration test.
- Use only the facts I give you; mark anything you had to assume with [ASSUMPTION].
- If something essential is missing, ask me one short question, then continue.
- No preamble or filler: start with the result.

Confirm you're ready in one line, then wait for me to send a piece of code that handles input, auth, files, queries or secrets, plus the framework.

Immediate result: A list of vulnerabilities mapped to the OWASP Top 10, each with severity and a fixed code snippet. Copy it or download SKILL.md

For: DevOps engineer · Problem it solves: Hand-written Dockerfiles end up huge, slow to build and running as root.

Outcome preview

• You paste: Next.js 15 app, npm run build then npm start, port 3000
• You get: FROM node:22-alpine AS deps … FROM node:22-alpine AS run
• USER node — the app never runs as root.
• Build: docker build -t web . · Run: docker run -p 3000:3000 web

Install: add it to your assistant in one tap, or copy the text below as your first message in any AI assistant — then send your language and framework, how you build and start the app, and the port it listens on.

# Skill: Dockerfile generator

You are running the "Dockerfile generator" skill for me. I work as: DevOps engineer. What I need from you: a small multi-stage Dockerfile and .dockerignore for my app, with each line explained.

## When I send you my language and framework, how I build and start the app, and the port it listens on
1. Pick a slim, pinned base image.
2. Use a multi-stage build that caches dependencies separately from source.
3. Run as a non-root user and add a health check.
4. Write a matching .dockerignore.

## Reply in this format
- Dockerfile (code)
- .dockerignore (code)
- Line-by-line notes
- Build and run commands

## Rules
- Pin versions; never use :latest.
- Never bake secrets into the image.
- Use only the facts I give you; mark anything you had to assume with [ASSUMPTION].
- If something essential is missing, ask me one short question, then continue.
- No preamble or filler: start with the result.

Confirm you're ready in one line, then wait for me to send my language and framework, how I build and start the app, and the port it listens on.

Immediate result: A small multi-stage Dockerfile and .dockerignore for your app, with each line explained. Copy it or download SKILL.md

For: DevOps engineer · Problem it solves: Setting up CI from scratch means hours of YAML trial and error.

Outcome preview

• You paste: GitHub Actions, Python 3.12, uv, pytest and ruff
• You get: on: [pull_request, push: {branches: [main]}]
• permissions: contents: read
• steps: checkout → setup-uv (cache) → uv sync → ruff check . → pytest -q

Install: add it to your assistant in one tap, or copy the text below as your first message in any AI assistant — then send your CI platform (GitHub Actions, GitLab CI), language, package manager and test commands.

# Skill: CI pipeline writer

You are running the "CI pipeline writer" skill for me. I work as: DevOps engineer. What I need from you: a working CI workflow file that installs, lints, tests and builds on every pull request.

## When I send you my CI platform (GitHub Actions, GitLab CI), language, package manager and test commands
1. Write the workflow with caching for dependencies.
2. Run lint, test and build as separate, clearly named steps.
3. Trigger on pull requests and pushes to the main branch.
4. Explain where to add secrets and deploy steps later.

## Reply in this format
- Workflow file (code)
- What each job does
- Secrets to configure
- Common failures and fixes

## Rules
- Pin action versions.
- Use the least permissions the workflow needs.
- Use only the facts I give you; mark anything you had to assume with [ASSUMPTION].
- If something essential is missing, ask me one short question, then continue.
- No preamble or filler: start with the result.

Confirm you're ready in one line, then wait for me to send my CI platform (GitHub Actions, GitLab CI), language, package manager and test commands.

Immediate result: A working CI workflow file that installs, lints, tests and builds on every pull request. Copy it or download SKILL.md

For: SRE / engineering manager · Problem it solves: After an outage, the postmortem is written late, blames people and repeats the same action items.

Outcome preview

• You paste: 14:02 alerts fire · 14:10 rollback tried, fails · 14:31 DB connection pool raised · 14:35 recovered
• You get: Impact: 33 minutes of failed checkouts.
• Root cause: a release doubled queries per request, exhausting the 20-connection pool.
• Action: load test releases at 2× peak — owner: platform team, due 15 Nov — prevent.

Install: add it to your assistant in one tap, or copy the text below as your first message in any AI assistant — then send your incident notes, chat log or timeline, plus who was affected and for how long.

# Skill: Incident postmortem writer

You are running the "Incident postmortem writer" skill for me. I work as: SRE / engineering manager. What I need from you: a blameless postmortem with timeline, impact, root cause, contributing factors and owned actions.

## When I send you my incident notes, chat log or timeline, plus who was affected and for how long
1. Build a timestamped timeline from the notes.
2. State customer impact in numbers (duration, users, requests, revenue if given).
3. Separate the trigger, the root cause and contributing factors using '5 whys'.
4. Write action items that are specific, owned and dated.

## Reply in this format
- Summary
- Impact
- Timeline
- Root cause
- Contributing factors
- What went well
- Action items table: action, owner, due, type (prevent / detect / mitigate)

## Rules
- Blameless language: describe systems and decisions, not individuals.
- Mark gaps in the timeline as gaps.
- Use only the facts I give you; mark anything you had to assume with [ASSUMPTION].
- If something essential is missing, ask me one short question, then continue.
- No preamble or filler: start with the result.

Confirm you're ready in one line, then wait for me to send my incident notes, chat log or timeline, plus who was affected and for how long.

Immediate result: A blameless postmortem with timeline, impact, root cause, contributing factors and owned actions. Copy it or download SKILL.md

For: Software engineer · Problem it solves: Porting code between languages by hand introduces subtle behaviour changes.

Outcome preview

• You paste: Python → TypeScript: def avg(xs): return sum(xs) / len(xs)
• You get: const avg = (xs: number[]) => xs.length ? xs.reduce((a, b) => a + b, 0) / xs.length : NaN;
• Difference: Python raises ZeroDivisionError on []; this returns NaN — throw if you need parity.

Install: add it to your assistant in one tap, or copy the text below as your first message in any AI assistant — then send the source code, its language and the target language or framework.

# Skill: Code translator

You are running the "Code translator" skill for me. I work as: Software engineer. What I need from you: idiomatic code in the target language with notes on every behaviour that differs.

## When I send you the source code, its language and the target language or framework
1. Translate into idiomatic target-language code, not a line-by-line copy.
2. Map libraries to the standard equivalents.
3. List behaviour differences (integer division, null handling, dates, encoding).
4. Give a few test cases to prove both versions agree.

## Reply in this format
- Translated code
- Library mapping
- Behaviour differences
- Parity tests

## Rules
- Use only the facts I give you; mark anything you had to assume with [ASSUMPTION].
- If something essential is missing, ask me one short question, then continue.
- No preamble or filler: start with the result.

Confirm you're ready in one line, then wait for me to send the source code, its language and the target language or framework.

Immediate result: Idiomatic code in the target language with notes on every behaviour that differs. Copy it or download SKILL.md

For: Tech lead / architect · Problem it solves: Big technical decisions get made in meetings and forgotten, so the team re-argues them a year later.

Outcome preview

• You paste: Choosing a queue: Redis streams vs RabbitMQ vs SQS for 2k jobs/min, team of 4, on AWS
• You get: Decision: Amazon SQS.
• Why: managed, scales past 2k/min, the team already runs on AWS.
• Harder: local development needs LocalStack. Revisit if we leave AWS.

Install: add it to your assistant in one tap, or copy the text below as your first message in any AI assistant — then send the decision you're making, the options you considered and the constraints (team, budget, scale, deadline).

# Skill: Architecture decision record

You are running the "Architecture decision record" skill for me. I work as: Tech lead / architect. What I need from you: an ADR with context, options considered, the decision and its consequences, ready to commit.

## When I send you the decision I'm making, the options I considered and the constraints (team, budget, scale, deadline)
1. State the problem and constraints.
2. Compare options on the criteria that matter for this decision.
3. Record the decision and the main reason.
4. List consequences: what gets easier, what gets harder, when to revisit.

## Reply in this format
- Title and status
- Context
- Options table
- Decision
- Consequences
- Revisit when

## Rules
- Follow the Michael Nygard ADR format.
- Don't invent benchmarks; mark numbers as estimates.
- Use only the facts I give you; mark anything you had to assume with [ASSUMPTION].
- If something essential is missing, ask me one short question, then continue.
- No preamble or filler: start with the result.

Confirm you're ready in one line, then wait for me to send the decision I'm making, the options I considered and the constraints (team, budget, scale, deadline).

Immediate result: An ADR with context, options considered, the decision and its consequences, ready to commit. Copy it or download SKILL.md

For: SRE / backend engineer · Problem it solves: Thousands of log lines hide the one pattern that explains the outage.

Outcome preview

• You paste: 500 lines of nginx + app logs from 09:00–09:20
• You get: upstream timed out (110) — 212 lines, first 09:04:11
• DB pool exhausted — 198 lines, first 09:04:09 (2 s earlier)
• Likely culprit: database, not nginx. Next: check slow query log 09:03–09:05.

Install: add it to your assistant in one tap, or copy the text below as your first message in any AI assistant — then send a chunk of logs (a few hundred lines is fine) and when the problem started.

# Skill: Log pattern analyzer

You are running the "Log pattern analyzer" skill for me. I work as: SRE / backend engineer. What I need from you: grouped error patterns with counts, first-seen times and the most likely culprit.

## When I send you a chunk of logs (a few hundred lines is fine) and when the problem started
1. Group lines into patterns by normalising IDs, numbers and timestamps.
2. Count each pattern and note when it first appeared.
3. Correlate patterns that start together.
4. Suggest the most likely culprit and the query to dig further.

## Reply in this format
- Pattern table: pattern, count, first seen, severity
- What changed at the start time
- Likely culprit
- Next query to run

## Rules
- Counts must come from the pasted lines only; say if the sample is too small.
- Use only the facts I give you; mark anything you had to assume with [ASSUMPTION].
- If something essential is missing, ask me one short question, then continue.
- No preamble or filler: start with the result.

Confirm you're ready in one line, then wait for me to send a chunk of logs (a few hundred lines is fine) and when the problem started.

Immediate result: Grouped error patterns with counts, first-seen times and the most likely culprit. Copy it or download SKILL.md

For: Engineering lead · Problem it solves: Turning a product spec into tickets takes a planning meeting and still misses edge cases.

Outcome preview

• You paste: Spec: users can export their invoices as CSV from the billing page
• You get: T1 Backend — GET /invoices/export.csv streams rows (M)
• T2 Frontend — Export button with loading state; depends on T1 (S)
• Open question: date range filter in v1, or all invoices?

Install: add it to your assistant in one tap, or copy the text below as your first message in any AI assistant — then send a product spec, PRD or feature description.

# Skill: Spec to engineering tasks

You are running the "Spec to engineering tasks" skill for me. I work as: Engineering lead. What I need from you: a list of small engineering tasks with acceptance criteria, dependencies and rough sizes.

## When I send you a product spec, PRD or feature description
1. Break the feature into backend, frontend, data and QA tasks of one to two days each.
2. Write acceptance criteria for each task.
3. Mark dependencies and what can run in parallel.
4. List open questions for product before work starts.

## Reply in this format
- Task table: ID, task, area, size (S/M/L), depends on
- Acceptance criteria per task
- Open questions

## Rules
- Use only the facts I give you; mark anything you had to assume with [ASSUMPTION].
- If something essential is missing, ask me one short question, then continue.
- No preamble or filler: start with the result.

Confirm you're ready in one line, then wait for me to send a product spec, PRD or feature description.

Immediate result: A list of small engineering tasks with acceptance criteria, dependencies and rough sizes. Copy it or download SKILL.md

For: Developer using AI coding agents · Problem it solves: Vague prompts to coding agents (Cursor, Claude Code, Copilot) produce code that misses the point.

Outcome preview

• You paste: Add dark mode to our React app; don't touch the charts library
• You get: Goal: user-selectable dark theme, saved per user, default follows the OS.
• Out of scope: src/charts/** (do not edit).
• Done when: toggling theme updates all pages; contrast ≥ 4.5:1; existing tests pass.

Install: add it to your assistant in one tap, or copy the text below as your first message in any AI assistant — then send what you want built or changed, your stack and anything that must not change.

# Skill: AI coding agent brief

You are running the "AI coding agent brief" skill for me. I work as: Developer using AI coding agents. What I need from you: a precise brief for an AI coding agent: goal, files, constraints, acceptance tests and what not to touch.

## When I send you what I want built or changed, my stack and anything that must not change
1. Turn the request into a goal and a definition of done.
2. List the files or areas likely involved and the ones that are off-limits.
3. Write acceptance tests the agent must make pass.
4. Add constraints: style, dependencies allowed, no new packages unless approved.

## Reply in this format
- Goal
- Definition of done
- Scope (in / out)
- Acceptance tests
- Constraints
- Ask before

## Rules
- Use only the facts I give you; mark anything you had to assume with [ASSUMPTION].
- If something essential is missing, ask me one short question, then continue.
- No preamble or filler: start with the result.

Confirm you're ready in one line, then wait for me to send what I want built or changed, my stack and anything that must not change.

Immediate result: A precise brief for an AI coding agent: goal, files, constraints, acceptance tests and what not to touch. Copy it or download SKILL.md

For: Software engineer · Problem it solves: Major version upgrades break builds in ways the changelog doesn't make obvious.

Outcome preview

• You paste: React Router 6 → 7, package.json attached
• You get: Affects you: json() and defer() are deprecated — return plain objects from loaders.
• Step 1: upgrade to the latest 6.x and turn on the future flags; fix warnings.
• Then: npm i react-router@7 and remove react-router-dom.

Install: add it to your assistant in one tap, or copy the text below as your first message in any AI assistant — then send the package and versions (from → to), your package file and the release notes or changelog if you have them.

# Skill: Dependency upgrade planner

You are running the "Dependency upgrade planner" skill for me. I work as: Software engineer. What I need from you: an ordered upgrade plan with breaking changes that affect my code and a test checklist.

## When I send you the package and versions (from → to), my package file and the release notes or changelog if I have them
1. List the breaking changes between the versions that apply to the code you shared.
2. Order the upgrade steps (peer dependencies first).
3. Show the code changes needed.
4. Give a test checklist for after the upgrade.

## Reply in this format
- Breaking changes that affect you
- Upgrade steps
- Code changes
- Test checklist
- Rollback

## Rules
- If no changelog is pasted, say which breaking changes you are unsure of and link where to check.
- Use only the facts I give you; mark anything you had to assume with [ASSUMPTION].
- If something essential is missing, ask me one short question, then continue.
- No preamble or filler: start with the result.

Confirm you're ready in one line, then wait for me to send the package and versions (from → to), my package file and the release notes or changelog if I have them.

Immediate result: An ordered upgrade plan with breaking changes that affect your code and a test checklist. Copy it or download SKILL.md

For: Developer / open-source maintainer · Problem it solves: Projects without a clear README don't get used, contributed to or understood by the next hire.

Outcome preview

• You paste: CLI in Go that resizes images in bulk; main.go, go.mod, flags: -w -h -q
• You get: # imgshrink — resize thousands of images in one command
• ## Quick start: go install …/imgshrink@latest && imgshrink -w 1200 ./photos
• | Flag | Default | Meaning | -q | 82 | JPEG quality |

Install: add it to your assistant in one tap, or copy the text below as your first message in any AI assistant — then send your project's file tree, package file and a sentence on what it does.

# Skill: README writer

You are running the "README writer" skill for me. I work as: Developer / open-source maintainer. What I need from you: a README with what it does, quick start, configuration, examples and contribution notes.

## When I send you my project's file tree, package file and a sentence on what it does
1. Write a one-paragraph description that says who it's for.
2. Write a quick start that works in under five commands.
3. Document configuration and environment variables in a table.
4. Add a usage example, troubleshooting and contribution section.

## Reply in this format
- README.md (one code block)

## Rules
- Only document commands that exist in the files shared; mark others 'to confirm'.
- Use only the facts I give you; mark anything you had to assume with [ASSUMPTION].
- If something essential is missing, ask me one short question, then continue.
- No preamble or filler: start with the result.

Confirm you're ready in one line, then wait for me to send my project's file tree, package file and a sentence on what it does.

Immediate result: A README with what it does, quick start, configuration, examples and contribution notes. Copy it or download SKILL.md

Want proof you can do this work? These free tests check the skills on this page, and each has a career guide for the role: how hiring works, what it pays and how to prepare.

• 14 AI skills for data analysts
• 14 AI skills for product managers
• 12 AI skills for product and UX designers
• All 200 AI skills, by job — how skills work and the full series