letting agents write most of your code makes you a better engineer

Unpopular take: letting agents write most of your code makes you a better engineer — if you treat their mistakes as the lesson. Six months of proof below.

Six months across ML, gamedev, backend, Android, and web — mostly self-driven, the goal being to touch something new in each instead of staying in one lane.

---

YAR Navala Siege

My entry for the Cursor Vibe Jam 2026. Learned a lot about gamedev. TLDR: write coherent requirements, ALWAYS keep stable decisions in AGENTS.md, and lean on predefined open-source libs (combat, shaders, physics, animations) instead of rolling your own — agents love writing things from scratch. Most of the game ended up running on a custom physics engine because the agent skipped the rapier requirement (cheap model) and I only caught it late. Nothing critical, but still a lesson.

Go hard on cheap visuals that buy a good picture: billboards, baked lighting. Optimize file delivery! I used Brotli compression and still couldn't hit the time-to-interactive I wanted. Wrestled with CDN caching too — a stale service worker kept beating me, so I went aggressive on cache-busting, learned about build-hashing the hard way!

Result: Place #431 of 945.

Full gamedev reflection + tips: x06.wtf/articles/vibejam_article

glmmedia-ocr

A z.ai SDK wrapper with Ollama ownership. Got hands-on with the Ollama lifecycle, swapped the full CUDA PyTorch build for the CPU-only wheel: ~500MB vs 4GB venv, which also sidestepped the OOM kills — two birds, one stone. Also the layout detection — and how training pipelines and timelines generally look (image preprocessing (depends) → layout detection → OCR → structured output). Some of it carried over into the handwritten-to-data competition.

GLM-OCR: github.com/dusy4/glmmedia-ocr

Handwritten to Data

A Kaggle competition by AI HOUSE: Ukrainian handwritten OCR to structured data, and my first real contact with ML. Learned what SLURM is and how to use a GPU node, Hugging Face, Kaggle. Got to know how training pipelines and timelines generally look, plus faced the common-sense ML concepts: overfitting, epochs, evals, gold/silver, LoRA, YOLO, source-aware routing, adapters during training. Most of the heavy lifting was done by agents since I have no AI/ML background — I was the one asking questions and digging through papers.

One interesting bit: on the 0.9B GLM-OCR base, training 4 distinct adapters (one per image type — archive scans, school homework photos, etc.) worked surprisingly well. My take is that the base had thin Ukrainian coverage, so the adapters had more capability to surface — sharpening Cyrillic/Slavic parameters toward Ukrainian and specializing on each visual domain. That's probably also why a 0.9B base hit a ceiling. Moving to the Qwen series gave stronger results but smaller marginal gains from fine-tuning — likely because its base already had solid Ukrainian coverage.

Result: #100 of 198 (public leaderboard with private validation datasets: 0.75185), which corresponds roughly to 84% character accuracy on cropped regions and 79% character accuracy on full-page reconstruction on the public dataset.

Small ML retrospective: x06.wtf/articles/ukrainian-ocr-revelation-retrospective GitHub: github.com/dusy4/handwritten-to-data-revelation

Sigram

A Signal messenger Android fork. Telegram's UI on top of Signal's client backend underneath: you see Telegram, you use Signal. Planning segmentation doesn't always hold up — some features have to go pending before they're properly tested, which creates circular dependencies. Not done yet, but login and text messages do work. Got a lot more comfortable with adb and emulators.

Sigram: x06.wtf/projects/sigram

Pingbox

An ntfy clone (notification relay) with one twist. You fire an HTTP POST via curl to the Pingbox endpoint with your API key as a bearer token and any tag in the body. Inside the app you define rules that match on that tag — e.g. a rule for hello. When an incoming message matches, Pingbox sends you a notification, and tapping it relays you to the activity screen you mapped to that rule, instead of just opening Pingbox. So a script can fire a POST tagged hello when a keyword hits, and one tap drops you straight into the screen you configured — a specific activity (com.whatsapp.conversation) with your parameters, like a chat with a set contact.

FastAPI, Redis for rate limiting, PostgreSQL for user data, REST, client-side parsing and intent firing, Docker, Jetpack Compose for UI. Picked up a lot of Android specifics — deep links, activity export, component linking, local storage.

PingBox: github.com/dusy4/pingbox

pi3

An autonomous pipeline that hunts exploitable smart contracts on Ethereum and BSC. Crawlers find funded contracts (BSC via RPC, ETH via GCP BigQuery) and surface them into a list, then an LLM agent (or several per contract) each gets dropped into an isolated workspace and has to prove a fund-drain on a local chain fork. Agent isolation with hard, strictly defined evals: 0xContract loses → attacker gains = pass, nothing else accepted. Mostly an excuse to mess with the pi.dev package ecosystem and run parallel agents. Tested successfully on own Sepolia contract.

pi3: github.com/dusy4/pi3

Crimson Royale

Part of the university web full-stack marathon — an online card game. The interesting part for me was the deployment (which wasn't required), though I did the frontend too. Backend, nginx and reverse proxies in general, Vercel, serverless MariaDB.

Crimson Royale: github.com/dusy4/web_full-stack_marathon2026/race01