Skills

Python. Python is the primary language of machine learning and data work, valued for readable syntax and an ecosystem that covers numerics, modelling, and serving end to end. Most of my day-to-day work — training, evaluation, pipelines, and APIs — is written in it.

C++. C++ compiles to native code with direct control over memory and layout, which is why performance-critical inference runtimes and systems code are written in it. It is the language underneath most of the ML libraries that get called from Python.

C#. C# is a statically typed, object-oriented language running on the managed .NET runtime with garbage collection and a large standard library. It is the common choice for Windows desktop tooling and enterprise backend services.

Java. Java compiles to bytecode that runs on the JVM, giving the same build portable behaviour across operating systems. Its maturity and threading model make it a staple of long-lived backend and big-data systems.

R. R is built around statistical modelling and data visualisation, with first-class support for data frames, regression, and hypothesis testing. It remains the shortest path from a dataset to a rigorous statistical result.

SQL. SQL declares what data you want rather than how to fetch it, letting the database engine plan the execution. It is the common interface across relational stores and warehouses, and still the fastest way to answer most data questions.

MATLAB. MATLAB treats the matrix as its native data type, making linear algebra, signal processing, and control-system work concise to express. It is common in engineering research where simulation and numerical prototyping come before production code.

LangGraph. LangGraph models an agent as an explicit state graph of nodes and conditional edges rather than a linear chain, so loops, branches, and retries are first-class. That structure makes long-running agents inspectable and resumable instead of opaque.

LangChain. LangChain provides composable building blocks — prompts, models, retrievers, tools, output parsers — that snap together into LLM pipelines. Its value is the standard interfaces, which let you swap a model or vector store without rewriting the application.

AutoGen. AutoGen frames multi-agent work as a conversation between specialised agents that message each other until a task converges. Human participants can join the same conversation, which makes it a natural fit for review and approval loops.

CrewAI. CrewAI organises agents by role — researcher, writer, reviewer — and assigns each a task with defined inputs and expected output. The role framing keeps responsibilities separate and makes multi-step pipelines easy to reason about.

Langfuse. Langfuse is open-source observability for LLM applications, capturing traces, token cost, latency, and evaluation scores per run. It turns non-deterministic behaviour into something you can debug and track over time.

MCP. The Model Context Protocol is an open standard for how model hosts discover and call external tools, data, and prompts over a uniform interface. One MCP server works across any compliant host, replacing bespoke per-integration glue.

ADK. Google's Agent Development Kit is a code-first framework for defining, evaluating, and deploying agents, with built-in support for tools and multi-agent composition. It integrates with Vertex AI for managed deployment while remaining runnable locally.

n8n. n8n is a source-available automation platform that wires APIs, databases, and AI steps together through a visual node graph. It is a fast way to stand up agentic or ETL-style automations without building a bespoke service for each one.

ReAct. ReAct interleaves reasoning traces with tool actions so the model plans, acts, observes the result, and revises. Grounding each step in a real observation reduces the compounding errors of pure chain-of-thought.

Tool / Function Calling. Tool calling lets a model emit a structured, schema-validated request that your code executes, returning the result for the model to continue from. Constraining the call to a declared schema is what makes the integration reliable enough for production.

Multi-Agent Orchestration. Orchestration coordinates several specialised agents through patterns like supervisor-worker fan-out, sequential handoff, or debate, then merges their results. The hard parts are task decomposition, shared state, and deciding when the ensemble is actually done.

Claude Code. Claude Code is Anthropic's agentic coding tool, running an agent loop that reads, edits, and tests files directly in a repository from the terminal, IDE, or web. Because it works against the real codebase rather than pasted snippets, it handles multi-file changes end to end.

Codex. Codex is OpenAI's coding agent, which takes a task description and works on it in an isolated environment before returning a reviewable diff. The delegate-then-review model suits well-scoped changes that can run unattended.

Cursor. Cursor is an AI-native code editor that keeps the model aware of the whole project and proposes edits as inline diffs you accept or reject. Keeping the human in the accept loop makes it well suited to iterative, exploratory changes.

GitHub Copilot. Copilot suggests code inline as you type, drawing on the surrounding file and project context. It is strongest on boilerplate, tests, and idiomatic patterns where the intent is clear from context.

GPT-4. GPT-4 is OpenAI's transformer-based model family supporting long context, vision input, and structured tool calling. It is a common baseline when benchmarking general reasoning and instruction-following quality.

Claude (Sonnet / Opus). Claude is Anthropic's model family, tiered so you can trade capability against speed and cost: Opus for the hardest reasoning and long-horizon agentic work, Sonnet for the best balance of intelligence and throughput, Haiku for high-volume latency-sensitive tasks. Picking the right tier per route is usually a bigger lever than prompt tuning.

Llama-2 / Llama-3. Meta's Llama models ship with open weights, so they can be fine-tuned and self-hosted on your own infrastructure. That matters when data residency, per-token cost, or customisation depth rule out a hosted API.

Mistral. Mistral publishes compact open-weight models, including mixture-of-experts variants that activate only a subset of parameters per token. The result is strong quality per unit of compute, which suits cost-constrained self-hosted deployments.

Gemini. Gemini is Google's natively multimodal model family, accepting text, images, audio, and video in a single context. Long context windows make it well suited to document and video understanding tasks.

HuggingFace. HuggingFace hosts a hub of pretrained models and datasets plus the libraries to load and fine-tune them in a few lines. It is the default starting point for anything that begins with an existing model rather than training from scratch.

NeMo Guardrails. NVIDIA's NeMo Guardrails adds programmable input, dialogue, and output rails around an LLM application using a rule language called Colang. It constrains topics, blocks unsafe responses, and enforces conversation flow without retraining the model.

SFT. Supervised fine-tuning continues training a base model on curated input-output demonstrations so it adopts a task format or domain style. It is the cheapest way to teach behaviour that prompting alone cannot reliably elicit.

RLHF. Reinforcement Learning from Human Feedback trains a reward model on human preference comparisons, then optimises the policy against that reward. It is the mechanism that turns a capable base model into one that follows instructions helpfully.

PEFT. Parameter-efficient fine-tuning freezes the pretrained weights and trains only a small set of added parameters, cutting memory and storage cost by orders of magnitude. It also lets many task-specific adapters share one base model in production.

LoRA. LoRA freezes the original weight matrix and learns a low-rank pair of matrices whose product is added as an update, training a tiny fraction of the parameters. The adapter is a few megabytes, so many task variants can be swapped over one shared base model.

QLoRA. QLoRA quantises the frozen base model to 4-bit while training LoRA adapters at higher precision, so large models fine-tune within a single GPU's memory. It made customising multi-billion-parameter models practical outside well-funded labs.

RAG. Retrieval-Augmented Generation fetches relevant documents at query time and puts them in the prompt so the model answers from evidence rather than memory. It keeps answers current and citable without retraining, and most of its quality comes from the retrieval stage.

Hybrid Search (Dense + BM25). Hybrid search runs lexical BM25 and dense vector retrieval together and fuses the two ranked lists, typically with reciprocal rank fusion. It consistently beats either method alone because keyword and semantic matching fail on different queries.

Cross-Encoder Reranking. A cross-encoder scores query and document jointly in one pass, which is far more accurate than comparing independent embeddings but too slow to run over a whole corpus. The standard pattern is cheap retrieval for a candidate set, then a cross-encoder to reorder the top results.

Quantization. Quantization stores weights and activations at lower numeric precision so a model needs less memory and runs faster on the same hardware. The engineering work is choosing the scheme and calibration data so the accuracy loss stays inside an acceptable budget.

Prompt Engineering. Prompt engineering structures the instruction — role, context, examples, constraints, and output format — so the model's behaviour is specific and repeatable. Treating prompts as versioned, evaluated artefacts rather than ad-hoc text is what makes the results hold up in production.

OpenCV. OpenCV is the workhorse around the model rather than the model itself — capture, colour conversion, geometric warping, calibration, and the classical algorithms that still beat a network when the problem is purely geometric. Its one persistent trap is that it reads images as BGR while every deep learning pipeline expects RGB.

TensorFlow. TensorFlow 2 runs eagerly like PyTorch but traces to a static graph through tf.function, which is what its deployment path — TF Serving, TF Lite, TFX — is built on. Keras sits on top and is genuinely faster for standard architectures; the layout difference from PyTorch, NHWC against NCHW, is the usual source of conversion bugs.

Object Detection. Detection predicts a variable-length set of boxes with classes and confidences, which is what makes it harder than classification — the model must decide how many objects exist. Two-stage detectors propose then classify for accuracy, one-stage detectors predict densely in a single pass for speed, and both depend on IoU-based suppression and mAP evaluation.

Face Recognition. The pipeline is four separable stages — detect, align to a canonical pose using landmarks, embed into a normalised vector, then compare by distance — and most accuracy problems trace to alignment rather than the network. Systems are specified as true accept rate at a fixed false accept rate, and the demographic and biometric-privacy considerations are part of the engineering, not an afterthought.

Image Segmentation. Segmentation classifies at pixel resolution, split into semantic (class per pixel), instance (separate objects), and panoptic (both at once). The recurring architectural problem is that downsampling builds meaning while destroying position, which skip connections and dilated convolutions exist to repair.

Autoencoders. An autoencoder compresses input through a bottleneck and reconstructs it with no labels beyond the input itself, so the constraint rather than the architecture is what forces useful structure. A variational autoencoder encodes to a distribution instead of a point, which is what makes the latent space continuous, sampleable, and usable as the compression stage under latent diffusion.

GANs. A generator and a discriminator train adversarially, and the discriminator's gradient is what teaches the generator to become convincing — which also makes the training a balancing act between two networks that can destabilise each other. The vocabulary that matters in practice is mode collapse, the WGAN-GP and hinge objectives that stabilise training, StyleGAN's disentangled latent space, and FID as the evaluation standard.

Diffusion Models. Noise is added to an image over many steps in a process with a closed form, and a network is trained to reverse one step at a time — usually by predicting the noise rather than the image. Latent diffusion runs the whole thing inside an autoencoder's latent space, which is what brought text-to-image generation onto consumer hardware.

Vision Transformers. A ViT splits an image into patches, embeds each as a token, and applies a standard transformer encoder, discarding the convolutional assumption that nearby pixels matter most. That missing prior is why ViTs need either large-scale pretraining or strong augmentation and distillation to match CNNs on modest datasets.

CLIP. Two encoders are trained with a symmetric contrastive loss so that matching image-text pairs score highest in both directions, producing one space where images and text are directly comparable. That single property is what enables zero-shot classification by embedding class names as text, and it breaks predictably on counting, spatial relations, and fine-grained distinctions.

Vision-Language Models. A VLM conditions a language model on visual features, most simply by projecting image patch embeddings into the token space and instruction-tuning on image-text pairs. The characteristic failure is object hallucination — describing things that are not in the image — and missed detail usually traces to token resolution rather than model capability.

Object Tracking. Tracking maintains identity across frames, and the difficulty sits in association — deciding whether this frame's box is the same object as the last one's, through occlusion, crossing paths, and missed detections. SORT pairs a Kalman motion model with Hungarian matching on IoU, and DeepSORT adds an appearance embedding so identities survive being hidden.

3D Vision. The representation choice — point cloud, voxel, mesh, or implicit field — constrains every architecture decision that follows, which is why it is usually the first question asked. NeRF made photorealistic view synthesis possible and Gaussian splatting made it real-time, which is what moved neural rendering into interactive and AR use.

Audio Processing. A short-time Fourier transform turns a waveform into a time-frequency image, and warping frequency onto the mel scale matches it to human perception — at which point audio is a 2D array and vision architectures apply unchanged. Window size sets the trade-off between time and frequency resolution, and that choice usually matters more than the model.

Core ML. Core ML is Apple's on-device inference format and runtime, dispatching a converted model across CPU, GPU, and the Neural Engine, with coremltools handling conversion, palettisation, and quantisation. The failure that costs the most latency is silent: an unsupported operation falls back to CPU rather than erroring, so the conversion report matters as much as the benchmark.

PyTorch. PyTorch builds the computation graph as the code runs, so models are written and debugged like ordinary Python while autograd handles the gradients. It is the default framework for research and increasingly for production training.

Scikit-learn. Scikit-learn offers classical ML algorithms behind one consistent fit/predict interface, with pipelines that chain preprocessing and estimation into a single fitted object. Composing steps this way is what prevents train-test leakage in practice.

BERT. BERT is an encoder pretrained by masking tokens and predicting them from context on both sides, producing representations that capture full-sentence meaning. Fine-tuned, it remains a strong and cheap choice for classification, NER, and sentence similarity.

Transformers. The transformer replaces recurrence with self-attention, letting every token attend directly to every other and making training parallel across the sequence. That architecture underpins essentially all modern language, vision, and multimodal models.

LSTM. An LSTM is a recurrent cell whose input, forget, and output gates control what state persists across time steps, mitigating the vanishing gradients of plain RNNs. It remains a solid choice for modest-length sequence and time-series problems where a transformer is overkill.

MLP. A multilayer perceptron stacks fully connected layers with non-linear activations, letting it approximate arbitrary functions over fixed-size inputs. It is the baseline neural architecture for tabular data and a building block inside larger models.

TF-IDF. TF-IDF weights a term by how often it appears in a document against how rare it is across the corpus, so distinctive words outrank common ones. It is a fast, interpretable baseline that still holds up for keyword search and lightweight text classification.

spaCy. spaCy provides a fast, production-oriented NLP pipeline covering tokenisation, part-of-speech tagging, dependency parsing, and named entity recognition. Its focus on speed and a stable API makes it the practical choice for text processing at volume.

NLTK. NLTK bundles classical NLP algorithms with a large collection of corpora and lexical resources such as WordNet. It is more teaching-and-research oriented than spaCy, and still the quickest way to reach linguistic resources.

XGBoost. XGBoost builds gradient-boosted decision trees where each new tree fits the residual error of the ensemble so far, with regularisation to control overfitting. It is still the strongest default for tabular prediction and a frequent competition winner.

Sentiment Analysis. Sentiment analysis classifies text by expressed polarity or emotion, applied to reviews, support tickets, and social monitoring. The practical difficulty is sarcasm, negation, and domain-specific language, which is why in-domain labelled data matters more than model choice.

A/B Testing. A/B testing randomly splits traffic between a control and a variant so the measured difference can be attributed to the change itself. Deciding sample size and duration up front is what keeps the result from being noise read as a win.

Hyperparameter Tuning. Tuning searches over settings that are not learned from data — learning rate, depth, regularisation — using grid, random, or Bayesian strategies. Random and Bayesian search usually beat grid search because most hyperparameters barely matter and grid wastes trials on them.

AWS Bedrock. Bedrock exposes foundation models from several providers behind one managed API, with no infrastructure to run. Because the interface is shared, switching or A/B-testing models is a configuration change rather than an integration project.

Amazon SageMaker. SageMaker covers the model lifecycle on AWS — managed training jobs, hyperparameter tuning, a model registry, and autoscaling inference endpoints. It removes most cluster management from training and serving at the cost of tighter platform coupling.

AWS Lambda. Lambda runs code in response to events without any server to provision, scaling automatically and billing only for execution time. It suits bursty, event-driven work, with cold starts and execution limits as the main constraints.

Amazon S3. S3 stores objects addressed by key inside buckets, with effectively unlimited capacity and very high durability. Lifecycle rules move colder data to cheaper tiers automatically, which is why it anchors most data lakes.

Amazon EMR. EMR provisions and manages Spark, Hadoop, and related big-data clusters on AWS, scaling nodes with the workload. It handles cluster lifecycle so jobs can run over S3 data without standing up infrastructure by hand.

GCP Vertex AI. Vertex AI unifies training, tuning, model registry, pipelines, and serving on Google Cloud, alongside access to Gemini and other foundation models. Keeping the lifecycle on one platform simplifies lineage tracking and access control.

Azure. Azure is Microsoft's cloud, spanning compute, storage, networking, identity, and a managed AI service layer. It is common in enterprises already invested in Microsoft identity and tooling, where integration matters more than raw service breadth.

Docker. Docker packages an application with its dependencies into a layered image that runs identically wherever the runtime exists. For ML it is the most reliable answer to CUDA, driver, and library drift between laptop and cluster.

Kubernetes. Kubernetes takes a declared desired state and continuously reconciles the cluster toward it, scheduling containers, restarting failures, and scaling replicas. That control loop is what gives self-healing and rolling deploys for free.

Helm. Helm templates Kubernetes manifests into versioned charts parameterised by a values file, so one definition serves dev, staging, and production. Releases are tracked, which makes upgrades and rollbacks a single command.

Kafka. Kafka is a distributed append-only log where producers write to partitioned topics and consumer groups read at their own offsets. Durable, replayable ordering within a partition is what makes it the backbone of event-driven and streaming systems.

Airflow. Airflow defines workflows as Python DAGs of tasks with explicit dependencies, then schedules, retries, and monitors each run. Making the dependency graph code is what gives data pipelines version control and reviewability.

Spark. Spark distributes computation over partitioned data across a cluster of executors coordinated by a driver, keeping intermediate results in memory. It handles batch and streaming transformations far beyond what fits on a single machine.

MLflow. MLflow tracks experiment runs with their parameters, metrics, and artifacts, and promotes chosen models through a versioned registry. It is what makes "which run produced the model in production" an answerable question.

CI/CD. Continuous integration and delivery automate build, test, and release so every change is verified the same way before shipping. For AI systems the gates extend past unit tests to evaluation thresholds on model and prompt quality.

CloudWatch. CloudWatch collects metrics, logs, and traces from AWS services and applications, then evaluates alarms and dashboards over them. It is the default place to notice that latency, error rate, or spend has moved.

Redis. Redis keeps data in memory as keyed structures — strings, hashes, sorted sets, streams — serving reads in well under a millisecond. It commonly sits in front of a database as a cache, and also handles sessions, rate limiting, and queues.

FastAPI. FastAPI derives request validation and OpenAPI documentation directly from Python type hints, and serves requests asynchronously. Typed contracts plus async I/O make it a natural fit for model-serving endpoints.

ONNX. ONNX is an open graph format that lets a model trained in one framework run in a different runtime or on different hardware. It decouples the training stack from the deployment target, which matters most for edge and cross-platform serving.

TensorRT. TensorRT compiles a trained network into an optimised engine for NVIDIA GPUs, fusing layers and calibrating reduced precision. It typically delivers the largest inference speedup available on NVIDIA hardware without changing the model itself.

CUDA. CUDA is NVIDIA's parallel computing platform, running kernels across thousands of GPU threads organised into blocks. Understanding it matters even when you never write a kernel, because memory transfers and occupancy explain most GPU performance problems.

Pydantic. Pydantic validates and coerces raw input against Python type annotations, producing typed objects or precise errors. It is the standard way to enforce contracts at API boundaries and to constrain LLM structured output.

SQS FIFO. Amazon SQS FIFO queues preserve strict ordering within a message group and deduplicate to give exactly-once processing. That trades some throughput for the ordering guarantees standard queues cannot provide.

Pinecone. Pinecone is a managed vector database serving approximate nearest-neighbour queries with metadata filtering and namespace isolation. It removes index tuning and scaling work from RAG systems at the cost of a vendor dependency.

QuickSight. QuickSight is AWS's managed business-intelligence service, building interactive dashboards over warehouse, S3, and database sources. Its serverless model means dashboards scale to many viewers without capacity planning.

MongoDB. MongoDB stores flexible JSON-like documents without requiring a fixed schema, so nested and evolving shapes need no migration. Indexes and aggregation pipelines carry the query workload.

Kibana. Kibana is the query and visualisation layer over Elasticsearch, used to search logs and build dashboards from indexed data. It is where log investigation usually starts in an ELK-based stack.

Elasticsearch. Elasticsearch is a distributed search engine built on an inverted index, sharding data across nodes for scale and resilience. It powers full-text search, log analytics, and increasingly hybrid keyword-plus-vector retrieval.

Cognito. Amazon Cognito manages user sign-up, sign-in, and federated identity, issuing JWTs that downstream services verify. It removes the need to build and secure your own credential store.

SpeechBrain. SpeechBrain is a PyTorch toolkit with ready-made recipes for speech recognition, speaker identification, enhancement, and separation. The recipes give a working baseline quickly, which shortens the path to a task-specific speech model.

Whisper. Whisper is an open speech recognition model that transcribes and translates across many languages, trained on a large and varied audio corpus. Its robustness to accents and background noise makes it a strong default for transcription.

Librosa. Librosa turns raw audio into analysis-ready features — spectrograms, MFCCs, chroma, onset and beat estimates. It is the standard Python starting point for audio feature engineering before modelling.

torchaudio. torchaudio provides audio I/O and transforms that operate directly on PyTorch tensors, so preprocessing runs batched and on GPU inside the training loop. Keeping audio in the tensor world avoids a costly conversion step per batch.

YOLO. YOLO predicts bounding boxes and class probabilities for a whole image in a single forward pass over a grid, rather than proposing regions first. That design is what makes real-time object detection on video feasible.

EfficientNet. EfficientNet scales network depth, width, and input resolution together in a fixed ratio rather than enlarging one dimension alone. That compound scaling reaches a given accuracy with markedly fewer parameters and FLOPs.

ResNet. ResNet adds identity skip connections so each block learns a residual correction rather than a full transformation, which keeps gradients flowing through very deep networks. It made hundred-layer vision models trainable and is still a common backbone.

StyleGAN2. StyleGAN2 generates high-fidelity images by mapping a latent code into an intermediate space that modulates the generator's layers as styles. The disentangled latent space is what makes controlled attribute editing possible.

DiffAE. Diffusion autoencoders split an image into an interpretable semantic latent and a stochastic detail code, then reconstruct through a diffusion decoder. Editing the semantic code alone changes attributes while preserving identity and fine detail.

Tesseract. Tesseract is an open-source OCR engine that extracts machine-readable text from images and scanned documents across many languages. Output quality depends heavily on preprocessing — deskewing, thresholding, and resolution.

Selenium. Selenium drives a real browser programmatically, clicking, typing, and asserting on rendered pages. That makes it the tool of choice for end-to-end UI testing and for scraping sites that only render content through JavaScript.

ffmpeg. ffmpeg decodes, filters, and re-encodes essentially any audio or video format from a single command line. In ML work it is the standard tool for extracting frames, resampling audio, and normalising media before a pipeline.

A2A. The Agent2Agent protocol defines how independently built agents advertise capabilities and exchange tasks and results across vendor boundaries. Where MCP standardises an agent's access to tools, A2A standardises agent-to-agent communication.

Claude Agent SDK. The Claude Agent SDK packages the Claude Code harness as a library, providing the agent loop plus built-in file, bash, search, and web tools along with subagents, hooks, and permissions. It supplies the harness while you host and deploy the agent on your own infrastructure.

moto. moto mocks AWS service APIs in-process so tests exercise S3, SQS, DynamoDB, and similar without network calls or real credentials. That keeps the suite fast, deterministic, and free of cloud spend.