🇬🇧 English | 🇷🇺 Русский

Polyglot engineer. I build systems designed to outlive their first million lines.

I pick the language after the problem, not before. Nearly eight years that started in Python now span C#/.NET, Rust, Go, TypeScript, Swift and Lua — what stays constant is the architecture: strict module boundaries, contract-first APIs, domain-driven design. I take on almost everything except gamedev itself — though game servers are very much my thing.

• Building my own multiplayer game platform — a C# modular monolith already past hundreds of thousands of lines → details
• Running a multi-agent AI development pipeline we designed from scratch — agent fleets in parallel across the team → how it works
• Shipping yandex-music-streamdeck — a full Rust rewrite, live on two marketplaces → below

Stream Deck / Stream Dock plugin for Yandex Music — a complete Rust port of my original Python version.

• 13 crates, hexagonal architecture — tokio runtime, Chrome DevTools Protocol for player control, custom key rendering on tiny-skia
• Distributed where users are: Elgato Marketplace, Mirabox StreamDock Store and GitHub Releases — 500+ downloads
• v2.0.0 “Rust Rewrite” → v2.3.0 in one week (July 2026): six releases, the runtime cut down to a single binary

A multiplayer game platform built as a C# modular monolith on .NET: every feature module is a bounded context with DDD layering, CQRS with a mediator pipeline, domain events, and a transactional outbox. PostgreSQL is the single writer of persistent state; Redis is the coordination fabric — streams for commands, pub/sub for notifications, locks and idempotency keys. Contracts come first: OpenAPI, protobuf and AsyncAPI definitions are the single source of truth, fanning out into generated clients for web (TypeScript), native iOS (SwiftUI) and internal Python services (ML anti-cheat, bots) over gRPC. Gameplay logic lives in a sandboxed Lua scripting layer behind a single hand-written REST bridge — the one deliberate exception to client codegen, because the game runtime speaks HTTP, not gRPC.

Today it spans hundreds of thousands of lines across a monorepo plus dedicated game-server and iOS/Android repositories on GitLab CI, and the roadmap points at several million lines with real infrastructure around it. The module boundaries are extraction-ready: hot paths — the exchange engine first — have a planned extraction path into Rust services, with seams clean enough that even the core could follow. A system this size is exactly why the development process itself had to be engineered (next section).

flowchart LR
    subgraph hub["Platform core — C# modular monolith (.NET)"]
        direction TB
        MOD["Feature modules = bounded contexts<br/>(DDD layers, CQRS + mediator)"]
        OUT["Domain events →<br/>transactional outbox"]
        MOD --> OUT
    end
    PG[("PostgreSQL —<br/>single writer of state")]
    RD[("Redis —<br/>streams · pub/sub · locks")]
    CON["Contracts — OpenAPI · protobuf · AsyncAPI<br/>(single source of truth, client codegen)"]
    subgraph game["Game layer — sandboxed Lua runtime"]
        direction TB
        BR["Hand-written REST bridge —<br/>the one codegen exception"]
        SRV["Server-side authority modules"]
        NUI["In-game UI (React/TS)"]
        BR --> SRV
        SRV --- NUI
    end
    WEB["Web (TypeScript)"]
    IOS["iOS (SwiftUI)"]
    SVC["Internal services (Python) —<br/>ML anti-cheat, bots"]
    RUST["Rust services —<br/>hot-path extraction (planned)"]
    DEV["Agentic dev pipeline —<br/>ADR-first → gates → MR flow,<br/>parallel agent fleets (git worktrees)"]
    hub --- PG
    OUT --> RD
    RD -->|HTTP relay| BR
    RD -->|WebSocket / SSE| WEB
    RD -->|APNs| IOS
    hub <-->|REST| BR
    hub <-->|gRPC| SVC
    CON === hub
    CON -->|generated client| WEB
    CON -->|generated client| IOS
    CON -->|generated client| SVC
    hub -.->|measured extraction| RUST
    DEV -.->|builds & reviews| hub
    DEV -.->|builds & reviews| game

The most interesting thing we built this year isn't a service — it's a process. Together with my project partner, we designed and built from scratch a multi-agent development workflow where AI agents operate like a disciplined engineering organization rather than autocomplete — several engineers, each with their own fleet of agents, building one codebase in parallel:

• a devkit that routes every significant change through an ADR (architecture decision record) before any code is written
• brain-check gates — an agent must demonstrate correct understanding of the task, the module contracts and the constraints before it is allowed to proceed
• merge-request flow — agent-written, gate-checked, human-audited changes only
• task-scoped parallelism — one task = one issue = one branch = one git worktree = one agent, claimed before any work starts
• agent teams × human team — every engineer drives their own agents across parallel terminal sessions; claim-first coordination keeps entire fleets from colliding, so the process scales across people, not just within one machine

The orchestration, the gates and the conventions are our own design — born from running a codebase that no longer fits in one head, human or agent.

Years of commercial work live in private repositories:

• Payment gateway — FastAPI, async SQLAlchemy 2, HMAC-signed webhooks, idempotency keys; Yookassa and self-employment tax service integrations
• Game servers — custom server-side logic and frameworks for RageMP and FiveM
• Commercial full-stack — warehouse management system on Next.js + FastAPI
• Native iOS — SwiftUI applications
• Go microservices (including an API) and a fleet of Discord/Telegram bots

Languages
Backend & frameworks
Data & contracts
Infra & delivery

📊 This Week I Spent My Time On

💬 Programming Languages: 
JavaScript               4 hrs 26 mins       ⣿⣿⣿⣿⣿⣿⣿⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀   27.29 % 
Markdown                 3 hrs 21 mins       ⣿⣿⣿⣿⣿⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀   20.58 % 
Python                   2 hrs 44 mins       ⣿⣿⣿⣿⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀   16.87 % 
Rust                     1 hr 59 mins        ⣿⣿⣿⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀   12.18 % 
TypeScript               1 hr 55 mins        ⣿⣿⣿⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀   11.82 % 

💻 Operating System: 
Mac                      16 hrs 17 mins      ⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿   100.00 % 

🤖 AI Coding This Week

⏱ AI Coding Time: 15 hrs 5 mins (92.63%)

✍️ 11,320 lines written by AI, 0 lines written by hand (100.0% AI-written)

🔤 434,550,320 Input Tokens, 1,622,624 Output Tokens

💵 $1783.15 Estimated AI Cost This Week

🧠 17 AI Sessions, 82 AI Prompts

Opus                     8,931 lines         ⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿   100.00 % 

🔎 AI Coding Insights:
🤖 AI-Driven — 100.0% of written lines came from AI
📚 Verbose Prompter — average 7,868 characters per prompt
🔁 Iterative Prompter — average 5 prompts per session
🚀 High AI Trust — 0.01% of changed lines were hand-edited

Discord is the one channel I actually read: