I'm a computer science student who ships practical software the way an engineer should, a disciplined AI-assisted workflow, self-hosted cloud infrastructure, centralized context across tools, and human judgment on quality and security.
I started programming because I wanted to understand how things actually work, then kept building until the process itself became the thing I enjoyed most.
Most of what I know, I learned by building and breaking real things: shipping features, tracing bugs to their root, standing up servers, and cleaning up my own mistakes. Somewhere along the way the interesting part stopped being individual snippets of code and became the system around the work, how context flows, how decisions get recorded, how something moves from an idea to a running service.
I think in workflows. I keep a centralized context so my tools don't repeat each other, I document decisions as I make them, and I treat security and correctness as steps I don't skip. I use AI to move faster, but I own the final code, its quality, its security, and whether it actually holds up.
I'm still early, and I'd rather be honest about that than oversell. What I can say plainly: I know how to organize real engineering work, deploy it, and keep it running, and I'm getting better at it every project.
Ignoring AI in 2026 is a mistake. Leaning on it without research or judgment is a bigger one. So I do both, I understand the problem myself, then use AI to move fast on the parts that shouldn't be slow.
I do the thinking first. I dig into the problem, read the docs, and form a direction myself. I don't outsource understanding, that's the part that's actually mine.
Then AI does the heavy lifting. With sharp prompts and full project context, I use it to accelerate the build, not to decide what to build or to hand me code I can't read.
Every tool shares one brain. Claude, Antigravity, and Codex all read the same context and write to the same journal, so nothing repeats and nothing gets lost between them.
My main driver: coding, architecture, and reasoning across the whole system. Most of the build runs through here.
My agentic IDE for frontend and UI. I reach for it on interface work, visual iteration, and a fresh second angle.
Scoped implementation and quick edits: an extra set of hands and a cross-check on focused tasks.
A shared decision log. Every action, fix, and issue gets written down, so any tool, or me next week, can pick up exactly where things left off.
One tool can request another's opinion; the answer lands in the same journal. No repeated work, no wasted tokens, no lost reasoning between tools.
Before anything is published I review the diff for exposed secrets and obvious risks. Secrets live in gitignored env files, never in the repo.
The final gate is me reading the code, confirming it does what it should, then committing and deploying. The tools accelerate; the judgment stays mine.
I use AI to cut repetition and raise throughput, but I keep ownership of the final code, its security, and its quality.
Not one-click-and-forget. My projects run on Ubuntu VMs I provision and manage myself, with the application and database deliberately kept on separate hosts.
The app is hosted on an Oracle Cloud Ubuntu VM. The database is a self-hosted PostgreSQL instance on its own Ubuntu VM, currently on Google Cloud, separated on purpose, so application and data have independent lifecycles, networking, and failure domains.
Running my own machines means I actually deal with the parts a managed platform hides: SSH, firewall rules, updates, service management, connection strings, and backups. It's more work, and that's the point, it's where the real systems understanding comes from.
I'd rather understand a system end-to-end than push to a platform and forget it exists.
Fewer projects, more depth. Each is here for the judgment and engineering it took, not to pad a list. Open one to read the short case study.
Most simple combat agents are scripted or reward-blind: once you find a pattern they stop adapting and become memorization. Mahoraga is an environment built to make adaptation, reward shaping, and agent behavior inspectable turn by turn, not a black box.
A FastAPI backend exposing reset / step / model-status served a 4-bit-quantized Qwen2.5-3B LoRA agent with a rule-based fallback, deployed to Hugging Face Spaces via a multi-stage Docker build. The agent was fine-tuned with an iterative reward-weighted SFT loop (Unsloth + TRL) using rejection sampling and expert-trajectory seeding over five training rounds.
National in-person finalist, backed by a compact, testable environment with 33 unit tests over its mechanics and reward logic.
View on GitHubCampus event information lives in posters, group chats, and club pages, and gets missed. The Loop is a single source of truth for workshops, fests, and club activity that also connects the people going.
A FastAPI + React app across 8 relational models and 25+ REST endpoints with JWT and Google OAuth. A cosine-similarity engine ranks events against a per-user weighted interest vector that updates as people engage, and a WebSocket chat runs on a server-side connection manager (multi-session presence) with client-side auto-reconnect and exponential backoff.
A working three-tier PWA with live recommendations and real-time presence, deployed and running.
View on GitHubA full community toolkit: music, leveling, moderation, and admin tooling, maintained continuously in production rather than shipped once and forgotten. Long enough in service that the interesting work became keeping it fast and stable under real load.
A Lavalink / wavelink music pipeline, and a migration of core database access from synchronous psycopg2 to async pooling (aiopg / asyncpg) to stop the event loop from blocking. Leveling renders rank cards on the fly with Pillow, and a hot cog load / unload / reload interface allows updates without downtime.
Three years in production across 25+ cogs and 70+ commands, still serving its community today.
View on GitHubGrouped by what they're for, not listed as a badge wall. Each cluster is a part of how the work gets done.
Where most of my backend work lives. From there I move across the stack, systems-level in C++, and full-stack web in the JavaScript/TypeScript world.
Three assistants, one shared brain. Claude leads the build; Antigravity covers frontend; Codex fills in scoped work, all coordinated through shared context files and a written journal so nothing repeats.
Software that actually runs somewhere, on VMs I provision and manage myself. Application and database deliberately split across two clouds.
The habits that keep the work trustworthy over time, checked before anything ships, not assumed on the way out.
One source of truth every tool reads, so nothing gets re-derived or repeated.
Write down the why as it happens. A clear log is worth more than perfect memory.
AI speeds up output; it doesn't replace understanding what the code does.
Security and correctness get checked at the gate, never assumed on the way out.
From local code to a running server, I'd rather understand the whole path.
Prefer quiet, correct execution to noisy complexity that impresses no one useful.
Picked up programming to understand how software actually works, and kept going by building small, real things.
Shipped first working projects end to end, and learned as much from what broke as from what worked.
Started using AI assistants deliberately, coordinating them instead of prompting at random.
Introduced centralized context and a work journal so tools hand off cleanly and decisions stay recorded.
Moved from localhost to real infrastructure, provisioning and running services on my own cloud VMs.
Building more complete systems, with the process, infrastructure, and review discipline to back them.