Kirill Ergin
Rust
Go
Python
MLOps & Deployment: 5/10
Experimentation & Evaluation: 4/10
Computational Efficiency: 4/10
Active 16 days ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Roles
Overview
A senior platform engineer (tier: Senior, tier_score 6.0) focused on building production-grade cloud-native runtime and operator infrastructure. The strongest proven skill is Kubernetes operator and runtime GitOps design, evidenced by internal/runtime/operator/reconciler.go and the comprehensive tests in internal/runtime/operator/reconciler_test.go. Public evidence does not show complete end-to-end production CI hardening (artifact signing), a secrets-management runtime (Vault/SOPS integration), or published SLO/burn-rate alerting rules and measured cost-optimization numbers.
Technical skills
Rust• Senior
Go• Senior
Python• Senior
Python
FastAPI
Alembic
HTTPX
Asyncio
Pydantic
Uvicorn
aiogram
AI/ML
Google GenAI SDK
Vertex AI
Speech Recognition
LLM
DevOps
Docker Compose
GitHub Actions
ArgoCD
GitOps
Kubernetes
OpenTelemetry
Prometheus
WebRTC
Senior AI/ML Engineer
Confidence: High LLM Engineer
A systems-focused LLM engineer building production conversational workflows and realtime voice+LLM orchestration at a senior level. The strongest proven skill is designing robust LLM orchestration and streaming pipelines with provider fallbacks and observability, as seen in llm_service/app/orchestrator.py and related live_* bridges. There is little to no evidence of custom model training, novel research implementations, or GPU/quantization engineering in the public code.
Model Architecture & Training
2/10
How well models are designed and trained
Mostly integration and orchestration of hosted LLMs (Vertex / Google GenAI / custom Cerebras client). No custom model architectures, training loops, schedulers or optimization experiments are present.
Evidence
rec-sidecar-mvp/llm_service/app/providers.py: VertexClient.generate_structured / CerebrasClient.text (LLM API wrappers)
rec-sidecar-mvp/llm_service/app/orchestrator.py: live/_vertex_live_generate (selection between providers)
Data Pipeline & Feature Engineering
3/10
How data is prepared for models
Code includes parsing and normalization of LLM-driven structured outputs, scorecard / stage parsing, and small dataset/seed scripts, but not large-scale ETL or feature-engineering pipelines.
Evidence
rec-sidecar-mvp/llm_service/app/scorecard.py: normalize_scorecard / safe_parse_scorecard (contract parsing and evidence extraction)
rec-sidecar-mvp/llm_service/app/stage_assets.py: parse_stage_agenda / parse_stage_detection (stage detection parsing)
Experimentation & Evaluation
4/10
How results are measured and tested
Good automated test coverage and benchmarking/diagnostic scripts for evaluation; lacks formal experiment tracking configs (W&B/MLflow) or reproducible experiment manifests but has many targeted unit tests and bench scripts.
Evidence
rec-sidecar-mvp/llm_service/tests/test_service.py: extensive pytest coverage of orchestrator and parsing logic
rec-sidecar-mvp/scripts/bench_stage_scorecard_models.py: benchmarking script for stage/scorecard behavior
MLOps & Deployment
5/10
How models are shipped to production
Clear production-facing engineering: observability, telemetry, timeouts, connection pooling, provider fallbacks, streaming endpoints, and service lifecycle are implemented and tested.
Evidence
rec-sidecar-mvp/llm_service/app/telemetry.py: setup_observability / metrics_middleware
rec-sidecar-mvp/llm_service/app/orchestrator.py: _new_http_client (connection limits), aclose (graceful shutdown), stage_agenda (fallbacks and retries)
Computational Efficiency
4/10
How efficiently computing resources are used
Engineering attention to concurrency, streaming and resource limits (asyncio, httpx limits, semaphores). No GPU/quantization/low-level optimization or measured before/after profiling shown.
Evidence
rec-sidecar-mvp/fresh-start/chat_loop_app.py: RoleplaySession with asyncio tasks, locks, Condition, streaming client handling
rec-sidecar-mvp/llm_service/app/orchestrator.py: use of asyncio, stream_text iterators and httpx.AsyncClient pool/limits
Research Depth & Innovation
2/10
Depth of research and new ideas
Some domain-specific heuristics and careful prompt/contract engineering (stage/scorecard semantics) but no original research, novel algorithms, or paper implementations.
Evidence
rec-sidecar-mvp/llm_service/app/paper_roleplay.py: heuristic_stage_tag / heuristic_next_action (heuristic policy)
rec-sidecar-mvp/llm_service/app/scorecard.py: scorecard parsing and normalization logic
Expertise
Conversational AI & Chatbots• Senior
MLOps & Model Lifecycle• Senior
Technologies
Python• Senior
OpenTelemetry
Vertex AI
WebRTC
FastAPI
Prometheus
Speech Recognition
Google GenAI SDK
LLM
Asyncio
Pydantic
HTTPX
Uvicorn
aiogram
Recommendations
- Lead development of real-time conversational assistants and live audio-LLM integrations (voice->ASR->live LLM->action pipeline).
- Implement and operate production LLM orchestration and provider-fallback services with observability and SLA guarantees (streaming, telemetry, backpressure).
- Build evaluation & experiment plumbing (experiment tracking, systematic A/B evaluation and cost/latency dashboards) to complement current unit tests and bench scripts.
- Productize roleplay/agent pipelines into reusable hosted microservices or internal platform components (managed connectors, prompt-contract libraries).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Backend Developer
Confidence: Medium Generalist
A systems-focused backend/generalist at a Senior level for native Rust rendering work, evidenced by a large, high-quality renderer implementation. The strongest proven skill is performance-sensitive systems and rendering engineering, supported concretely by render-core/src/layer_eval.rs (motion blur sampling, accumulation buffers, deferred rasterization, and extensive tracing). There is limited or no public evidence of API versioning/idempotency, database schema evolution, or network/security subsystems in the analyzed human-authored file.
API Design
2/10
How well APIs are designed
Well-defined internal function/API surface for the renderer (library functions) but no network API versioning, idempotency or pagination concerns.
Data Layer & Database
Working with databases
Not evidenced in public code
Scalability & Performance
7/10
Handling load and speed
Significant performance-oriented code and micro-optimizations (motion-blur sampling, accumulation buffers, cropped effect inputs, constrained loops) indicating attention to throughput and memory usage.
Evidence
VileBody/ae-native-renderer/crates/render-core/src/layer_eval.rs:render_motion_blurred_layer (sampling loop, accum buffer)
VileBody/ae-native-renderer/crates/render-core/src/layer_eval.rs:accumulate_motion_sample (vectorized accumulation)
VileBody/ae-native-renderer/crates/render-core/src/layer_eval.rs:adjustment_effect_input_plan (cropped input optimization)
System Architecture
6/10
Overall system structure
Deliberate renderer architecture and module boundaries - composition/render pipeline, precomp collapse and deferred rasterization are explicit design choices for correctness and performance.
Evidence
VileBody/ae-native-renderer/crates/render-core/src/layer_eval.rs:render_composition_frame (composition traversal)
VileBody/ae-native-renderer/crates/render-core/src/layer_eval.rs:render_collapsed_precomp / can_collapse_composition
VileBody/ae-native-renderer/crates/render-core/src/layer_eval.rs:bee_text_carrier_routes_for_precomp (deferred raster planning)
Security & Auth
1/10
Protecting data and access
Minimal input-safety checks in rendering math (finite checks, cycle detection) but no auth/secret handling, network security or dependency-audit patterns in the analyzed file.
Evidence
VileBody/ae-native-renderer/crates/render-core/src/layer_eval.rs:posterize_bucket_id (is_finite checks)
VileBody/ae-native-renderer/crates/render-core/src/layer_eval.rs:source_frame_quantization (bounds checks and validity)
VileBody/ae-native-renderer/crates/render-core/src/layer_eval.rs:precomp cycle detection using stack checks
Reliability & Observability
7/10
Stability and monitoring
Rich structured tracing and debug telemetry baked into the render path - trace records, effect debug payloads and measurable timing points are present for observability and diagnostics.
Evidence
VileBody/ae-native-renderer/crates/render-core/src/layer_eval.rs:FrameRenderTrace struct and many record_* functions
VileBody/ae-native-renderer/crates/render-core/src/layer_eval.rs:effect_debug_trace_json (per-effect debug payloads)
VileBody/ae-native-renderer/crates/render-core/src/layer_eval.rs:elapsed_ms timing usage and trace.effects/trace.layers population
Expertise
Rust• Senior
Backend AI & LLM• Middle
Go Development• Middle
Python• Middle
Industries
Real Estate• Middle
Technologies
Rust• Senior
Docker• mentioned only
Recommendations
- Lead development of performance-critical native components (rendering, rasterization, text layout) in Rust where low-level correctness and telemetry are required.
- Implement or own telemetry-driven performance tuning and operator dashboards that consume the existing FrameRenderTrace and effect debug payloads.
- Work on integration points that require careful boundary contracts - e.g., native renderer CLI/daemon API contracts and robust request validation for dispatch/polling.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior DevOps Engineer
Confidence: High Platform SRE
A senior platform engineer (tier: Senior, tier_score 6.0) focused on building production-grade cloud-native runtime and operator infrastructure. The strongest proven skill is Kubernetes operator and runtime GitOps design, evidenced by internal/runtime/operator/reconciler.go and the comprehensive tests in internal/runtime/operator/reconciler_test.go. Public evidence does not show complete end-to-end production CI hardening (artifact signing), a secrets-management runtime (Vault/SOPS integration), or published SLO/burn-rate alerting rules and measured cost-optimization numbers.
CI/CD Pipelines
6/10
Automated build and deploy
CI/CD Pipelines - non-trivial Makefile targets, verification and test-focused CI targets and recorded GitHub workflow files showing integration, but no visible artifact signing or advanced reusable workflow templates in the provided human-authored files.
Infrastructure as Code
5/10
Managing servers with code
Infrastructure as Code - GitOps-oriented renderer and repository code, Argo CD application set manifest and tests for safe gitops paths; limited evidence of remote state locking or state migration scripts in the inspected human-authored files.
Containerization & Orchestration
6/10
Working with containers
Containerization & Orchestration - substantial Kubernetes operator and kube client code with security-hardening and rollout logic; resource/security settings and HPA interactions are implemented and tested.
Observability & Monitoring
5/10
Watching system health
Observability & Monitoring - domain-level audit/outbox and recovery tests, and code that preserves audit/diagnostic signals; there is limited direct evidence of SLO/burn-rate alerting or advanced alert routing in the inspected human-authored files.
Reliability & Incident Response
7/10
Keeping systems up
Reliability & Incident Response - deliberate design and many tests for idempotency, outbox delivery with lease/retry reclaim, rollout/readiness and rollback behavior, plus GitOps commit recovery tests demonstrating incident-aware design.
Cloud & Cost Optimization
6/10
Smart use of the cloud
Cloud & Cost Optimization - placement, HPA ownership and usage/billing tests show thought about autoscaling and cost-aware runtime accounting; explicit spot/eviction strategies or measured rightsizing numbers are not present in the inspected human-authored files.
Evidence
VileBody/ai-native-paas/internal/runtime/operator/reconciler_test.go: TestOperator_HPAOwnsReplicaCountWhenAutoscalingEnabled
VileBody/ai-native-paas/internal/commerce/application/commercial_tdd_test.go: runtime usage and billing tests
VileBody/vietnam-rent-miniapp/Dockerfile: multi-stage Go build and small runtime image
Expertise
Kubernetes Ecosystem• Senior
CI/CD & Pipeline Automation• Senior
Infrastructure as Code• Senior
Industries
Artificial Intelligence• Middle
Real Estate• Middle
Technologies
Go• Senior
Docker Compose
GitHub Actions
GitOps
ArgoCD
Kubernetes
Alembic
Recommendations
- Design and implement Kubernetes operators, runtime reconciliers and GitOps pipelines with ArgoCD.
- Build and harden platform CI/CD and release automation (artifact immutability, reproducible builds and deploy gates).
- Develop backend services and ingestion pipelines in Go with Postgres integration and data-enrichment workflows (geocoding/LLM extraction).
- Lead reliability work - rollout strategies, rollback procedures and incident runbooks for the platform.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: