Skills taxonomy

Prompt engineering covers the design of instructions, context, examples, and output constraints given to a language model, plus the iteration loop used to make model behaviour reliable across many inputs rather than impressive on one.

AI evaluation covers designing test sets, choosing metrics that track the thing you actually care about, building automated graders, and interpreting results — including knowing when a metric is being gamed by the system it measures.

Agent design covers deciding what tools a model gets, how the loop is bounded, how failures and partial progress are handled, and where human approval is required.

This covers component boundaries, context management, caching, model selection, fallback behaviour, and cost/latency budgets in systems where a language model is a core dependency rather than a feature.

Retrieval systems cover chunking strategy, embedding and index choice, hybrid and re-ranked retrieval, context assembly, and the evaluation of retrieval quality independently from generation quality.

Discovery covers identifying the real problem behind a request, designing research that could disprove your own hypothesis, running non-leading interviews, and turning raw signal into a decision.

Prioritisation covers sequencing work under real constraints, making trade-offs between competing stakeholders, stating the cost of each decision, and communicating a cut so the people affected accept it.

Specification writing covers stating the problem, defining scope and explicit non-goals, handling edge cases and failure states, defining acceptance criteria, and writing so the reader can act without asking a clarifying question.

This covers writing for a specific audience, leading with the decision needed, presenting trade-offs honestly including the inconvenient ones, and delivering bad news in a way that preserves both trust and momentum.

Data analysis covers framing a question quantitatively, choosing appropriate cuts and comparisons, distinguishing correlation from causation, quantifying uncertainty, and communicating a finding with its caveats intact.

Experiment design covers hypothesis formation, choosing a metric that reflects the real goal, sizing and duration, controlling for confounds, and pre-committing to a decision rule before results arrive.

This covers reading unfamiliar API documentation, handling rate limits, retries, timeouts and partial failures, designing idempotent operations, and managing credentials safely.

Debugging covers reproducing a failure reliably, forming and eliminating hypotheses in cost order, reading evidence rather than guessing, and confirming the fix addressed the cause rather than masking the symptom.

Code review covers reading unfamiliar code for correctness, spotting real defects and security issues, calibrating severity, and writing feedback that gets acted on rather than resented.

This covers funnel analysis, locating the binding constraint, sizing the opportunity before building, designing a test that isolates the change, and reading the result without motivated reasoning.