NLP/LLM Engineer with 3+ years of experience building LLM assistants using retrieval (RAG) and hybrid search, including LLM fine-tuning with PEFT methods and model deployment via vLLM, Kubernetes, and FastAPI. Also works as a DL engineer on training neural models for XPS spectrum decomposition and entity recognition, improving processing speed and reported metrics using neural architectures and distillation/ensembling.

A senior-level LLM-engineering practitioner focused on trustworthy LLM evaluation, agent workflows, and inference-capacity tooling. The strongest proven skill is building rigorous evaluation and benchmarking pipelines rooted in deterministic validity gates and honest scoring (e.g., scorecard construction in assay/assay/scorecard.py and solver orchestration in assay/assay/solver.py). What is not evidenced is custom model training or novel neural-architecture development—there are analytical and simulation layers but no bespoke training loops or new model implementations in public code.

A capable developer who produces clean, self-contained tooling and educational/game code at a middle (early mid-level) competence. The strongest proven skill is Python CLI/tooling and text-processing, demonstrated by the analyze_lessons.py script (argparse-driven CLI, modular analysis, CSV output and reporting). There is limited evidence of backend system design - no databases, network APIs, scalability patterns or production-grade reliability/observability features are present in the analyzed human-authored files.

A capable LLM-focused engineer at a lower-senior level who builds agentic pipelines, RAG components and production MLOps glue. The strongest proven skill is building LLM-based code-review and RAG pipelines - evidenced by the LangGraph pipeline, dedup/enrichment logic (src/agent/graph.py) and a schema-enforced security scanner (src/tools/security_scanner.py). The public code shows limited evidence of custom neural-model engineering, GPU/quantization work, or advanced serving/performance benchmarking.

A competent ML engineer with solid hands-on experience building custom training pipelines and numerical experiment code; the strongest proven skill is implementing and running GPU-batched custom training/evaluation pipelines (e.g., MultiCandidateAngleRNN and oracle optimization in QAOA/angle_rnn_core.py and oracle_lab_core.py). There is limited public evidence of large-scale production deployment, CI/CD for models, or monitoring/drift tooling, and several high-value areas (serving, observability, MLOps automation) are not evidenced in the human-authored code.

An LLM-focused engineer with solid, production-oriented ML/LLM engineering experience at a lower-end Senior level. The strongest proven skill is building and evaluating retrieval-augmented systems and LLM orchestration - evidenced by the RAG graph (grade/rewrite/verify), Store/Qdrant integration and the evaluation harness. There is limited evidence of full-scale MLOps (monitoring, drift detection, CI/CD for models) and no industrial-scale distributed training or custom CUDA kernels in public code.

A pragmatic ML engineer with demonstrated ability to build and ship GPU-backed computer vision inference services. The strongest proven skill is production-oriented inference engineering, evidenced by MobileCLIP-based encoder and GPU-aware retrieval plus a benchmark measuring p50/p95 latencies (AmaHamster/app/adapters/mobileclip_encoder.py and AmaHamster/benchmark.py). There is no public evidence of custom model training, experiment tracking, large-scale data pipelines, or full production MLOps automation in the human-authored files.

A generalist C++ developer at a lower-middle (early middle) level who builds multithreaded desktop and systems utilities. The strongest proven skill is concurrent C++ and low-level data-structure work, evidenced by the atomic queue implementation (Labmem-015/two_queues/include/atomic_queue.hpp) and coroutine scaffolding (Labmem-015/two_queues/include/async.hpp). The work shows limited attention to correctness and production hardening - there are unsafe manual allocations, UB-prone pointer arithmetic, race-prone lock usage and no CI/tests or MCU/driver firmware artifacts.

AI engineer (senior-level) focused on document-grounded retrieval and API orchestration for RAG systems. The strongest proven skill is building and integrating a production-minded retrieval stack and service boundary (Python RAG HTTP/gRPC service + Go orchestration) as shown by api/http/app.py and grounded-horticulture_ru/server/rag_chat.go. There is limited public evidence of large-scale distributed systems work like sharding/consensus, measured performance tuning at scale, or an exhaustive cloud IaC/ops pipeline in the analyzed human-authored files.

A mid-level SDET/test-engineering practitioner with cross-stack automation experience across Python unit helpers, API service tests in TypeScript, and Playwright end-to-end tests. The strongest proven skill is building CI-aware test automation infrastructure and pragmatic fixtures, evidenced by the Vitest runner configuration, Playwright fixtures, and pytest parallel/rerun setup. There is limited public evidence of contract/schema testing, performance/load engineering, or formal bug-triage artifacts and RCA.

A pragmatic backend API engineer at a solid middle-to-senior level with repeated evidence of building and testing production HTTP services. The strongest proven skill is backend API and data-layer engineering, demonstrated by layered handlers → services code, sqlx-based queries with batched lookups and transactional flows (examples: services/listing.rs, services/user.rs and replace_profile_links/delete_account tests). The public code shows limited evidence of large-scale distributed architecture, sophisticated caching or formal runtime resilience frameworks beyond pragmatic rate limiting and background tasks.

A backend API engineer at an early senior level who produces well-structured service code with deliberate transaction and concurrency controls. The strongest proven skill is data-layer design and concurrency control (row-level locking, skip_locked, migration history and transactional use-cases) as implemented in create_order.py, related infrastructure models and Alembic migrations. Public code does not show advanced operational artifacts like distributed queuing, caching/invalidation strategies or a multi-service production architecture.

A backend-focused engineer at a senior level who builds careful, well-tested Python services and local tooling. The strongest proven skill is data-layer and analytics engineering (hand-tuned SQL and time-bucketed aggregation) as shown in token_lens/app/storage/queries.py. Not evidenced are large-scale distributed production deployments, advanced authn/authz lifecycle management, or formal API versioning and rate-limiting strategies in production.

A pragmatic frontend engineer at roughly a middle level who builds admin-facing applications and supporting utilities for an iGaming platform. The strongest proven skill is building robust mock/server-state layers and data utilities - evidenced by src/services/mock/mockData.ts which implements a deterministic mock API router and rich data generators used across the admin UI. The public code shows strong visual/theming and data-shaping work but lacks explicit evidence of advanced state-machine logic, request-cancellation/race handling, comprehensive automated tests, or focused a11y implementations.

A senior-level distributed-systems backend engineer who builds real-time, sharded push infrastructure using Rust (with a complementary Go jobs tool). The strongest proven skill is designing DB-driven coordination for messaging - evidenced by the Store layer using FoundationDB transactions, versionstamped keys and shard-watch/drain logic in src/store.rs and the pusher components. There is limited public evidence of production auth/token management, secrets handling, formal API versioning, or extensive operational runbooks and SLO/monitoring artefacts.

A pragmatic senior-level backend engineer focused on API-driven pipelines and integrations. The strongest proven skill is designing and implementing a clean-architecture marketplace pipeline (composition container, ports/adapters, job runner, idempotency and LLM integration) as seen in the marketplace-pipeline package. The public code does not show large-scale multi-region operations, detailed DB performance tuning at raw SQL level, or long-lived token lifecycle/revocation systems.

A pragmatic Rust systems/tooling engineer at a Middle level (approx 3.0/10) who builds CLI-first developer tools and content pipelines. The strongest proven skill is developer tooling and pipeline design - exemplified by loadout/src/main.rs (sync_target), loadout/src/catalog.rs (catalog parsing/resolution) and the integration tests in t3chn/loadout/tests/integration.rs that validate idempotent end-to-end flows. There is no evidence of game-engine work (rendering/shaders/physics), deterministic simulation, or multiplayer/netcode in the human-authored files analyzed; several other files in the tree are AI-authored or boilerplate and were ignored per analysis policy.

A protocol-focused smart-contract engineer at a senior (mid-senior) level who designs and tests custom on-chain token economics. The strongest proven skill is DeFi protocol design - evidenced by Reserve.redemptionSignal/quoteRedeem, PrimeMarket emission math, and the extensive invariant and break tests in Solidus.t.sol. What is not evidenced publicly here is frontend UX, multi-repo production orchestration (CI/CD beyond scripts), or formal audit reports and on-chain governance controllers.